fakeredis-2.31.0/fakeredis/__init__.py0000644000000000000000000000231113615410400014515 0ustar00import sys from . import typing from ._connection import ( FakeRedis, FakeStrictRedis, FakeConnection, ) from ._server import FakeServer from .aioredis import ( FakeRedis as FakeAsyncRedis, FakeConnection as FakeAsyncConnection, ) if sys.version_info >= (3, 11): from ._tcp_server import TcpFakeServer else: class TcpFakeServer: def __init__(self, *args, **kwargs): raise NotImplementedError("TcpFakeServer is only available in Python 3.11+") __version__ = typing.lib_version __author__ = "Daniel Moran" __maintainer__ = "Daniel Moran" __email__ = "daniel@moransoftware.ca" __license__ = "BSD-3-Clause" __url__ = "https://github.com/cunla/fakeredis-py" __bugtrack_url__ = "https://github.com/cunla/fakeredis-py/issues" __all__ = [ "FakeServer", "FakeRedis", "FakeStrictRedis", "FakeConnection", "FakeAsyncRedis", "FakeAsyncConnection", "TcpFakeServer", ] try: import valkey # noqa: F401 from ._valkey import FakeValkey, FakeAsyncValkey, FakeStrictValkey # noqa: F401 __all__.extend( [ "FakeValkey", "FakeAsyncValkey", "FakeStrictValkey", ] ) except ImportError: pass fakeredis-2.31.0/fakeredis/_basefakesocket.py0000644000000000000000000004362213615410400016101 0ustar00import itertools import queue import time import weakref from typing import List, Any, Tuple, Optional, Callable, Union, Match, AnyStr, Generator, Dict, Sequence from xmlrpc.client import ResponseError import redis from fakeredis.model import XStream, ZSet, Hash, ExpiringMembersSet from . import _msgs as msgs from ._command_args_parsing import extract_args from ._commands import Int, Float, SUPPORTED_COMMANDS, COMMANDS_WITH_SUB, Signature, CommandItem from ._helpers import ( SimpleError, valid_response_type, SimpleString, NoResponse, casematch, compile_pattern, QUEUED, decode_command_bytes, ) def _convert_to_resp2(val: Any) -> Any: if isinstance(val, str): return val.encode() if isinstance(val, float): return Float.encode(val, humanfriendly=False) if isinstance(val, dict): result = list(itertools.chain(*val.items())) return [_convert_to_resp2(item) for item in result] if isinstance(val, (list, tuple)): res = [_convert_to_resp2(item) for item in val] return res return val def _extract_command(fields: List[bytes]) -> Tuple[Any, List[Any]]: """Extracts the command and command arguments from a list of `bytes` fields. :param fields: A list of `bytes` fields containing the command and command arguments. :return: A tuple of the command and command arguments. Example: ``` fields = [b'GET', b'key1'] result = _extract_command(fields) print(result) # ('GET', ['key1']) ``` """ cmd = decode_command_bytes(fields[0]) if cmd in COMMANDS_WITH_SUB and len(fields) >= 2: cmd += " " + decode_command_bytes(fields[1]) cmd_arguments = fields[2:] else: cmd_arguments = fields[1:] return cmd, cmd_arguments def bin_reverse(x: int, bits_count: int) -> int: result = 0 for i in range(bits_count): if (x >> i) & 1: result |= 1 << (bits_count - 1 - i) return result class BaseFakeSocket: _clear_watches: Callable[[], None] ACCEPTED_COMMANDS_WHILE_PUBSUB = { "ping", "subscribe", "unsubscribe", "psubscribe", "punsubscribe", "ssubscribe", "sunsubscribe", } _connection_error_class = redis.ConnectionError def __init__(self, server: "FakeServer", db: int, client_class, *args: Any, **kwargs: Any) -> None: # type: ignore # noqa: F821 super(BaseFakeSocket, self).__init__(*args, **kwargs) from fakeredis import FakeServer self._server: FakeServer = server self._db_num = db self._db = server.dbs[self._db_num] self._client_class = client_class self.responses: Optional[queue.Queue[bytes]] = queue.Queue() # Prevents parser from processing commands. Not used in this module, # but set by aioredis module to prevent new commands being processed # while handling a blocking command. self._paused = False self._parser = self._parse_commands() self._parser.send(None) # Assigned elsewhere self._transaction: Optional[List[Any]] self._in_transaction: bool self._pubsub: int self._transaction_failed: bool info = kwargs.pop("client_info", dict(user="default")) self._client_info: Dict[str, Union[str, int]] = {k.replace("_", "-"): v for k, v in info.items()} self._server.sockets.append(self) @property def client_info(self) -> Dict[str, Union[str, int]]: res = {k: v for k, v in self._client_info.items() if not k.startswith("-")} res["age"] = int(time.time()) - int(self._client_info.get("-created", 0)) return res @property def client_info_as_bytes(self) -> bytes: return " ".join([f"{k}={v}" for k, v in self.client_info.items()]).encode() @property def current_user(self) -> bytes: return str(self._client_info.get("user", "")).encode() @property def protocol_version(self) -> int: return int(self._client_info.get("resp", 2)) @property def version(self) -> Tuple[int, ...]: return self._server.version @property def server_type(self) -> str: return self._server.server_type def put_response(self, msg: Any) -> None: """Put a response message into the queue of responses. :param msg: The response message. """ # redis.Connection.__del__ might call self.close at any time, which # will set self.responses to None. We assume this will happen # atomically, and the code below then protects us against this. responses = self.responses if responses: responses.put(msg) def pause(self) -> None: self._paused = True def resume(self) -> None: self._paused = False self._parser.send(b"") def shutdown(self, _: Any) -> None: self._parser.close() @staticmethod def fileno() -> int: # Our fake socket must return an integer from `FakeSocket.fileno()` since a real selector # will be created. The value does not matter since we replace the selector with our own # `FakeSelector` before it is ever used. return 0 def _cleanup(self, server: Any) -> None: # noqa: F821 """Remove all the references to `self` from `server`. This is called with the server lock held, but it may be some time after self.close. """ for subs in server.subscribers.values(): subs.discard(self) for subs in server.psubscribers.values(): subs.discard(self) self._clear_watches() def close(self) -> None: # Mark ourselves for cleanup. This might be called from # redis.Connection.__del__, which the garbage collection could call # at any time, and hence we can't safely take the server lock. # We rely on list.append being atomic. self._server.sockets.remove(self) self._server.closed_sockets.append(weakref.ref(self)) self._server = None # type: ignore self._db = None self.responses = None @staticmethod def _extract_line(buf: bytes) -> Tuple[bytes, bytes]: pos = buf.find(b"\n") + 1 assert pos > 0 line = buf[:pos] buf = buf[pos:] assert line.endswith(b"\r\n") return line, buf def _parse_commands(self) -> Generator[None, Any, None]: """Generator that parses commands. It is fed pieces of redis protocol data (via `send`) and calls `_process_command` whenever it has a complete one. """ buf = b"" while True: while self._paused or b"\n" not in buf: buf += yield line, buf = self._extract_line(buf) assert line[:1] == b"*" # array n_fields = int(line[1:-2]) fields = [] for i in range(n_fields): while b"\n" not in buf: buf += yield line, buf = self._extract_line(buf) assert line[:1] == b"$" # string length = int(line[1:-2]) while len(buf) < length + 2: buf += yield fields.append(buf[:length]) buf = buf[length + 2 :] # +2 to skip the CRLF self._process_command(fields) def _process_command(self, fields: List[bytes]) -> None: if not fields: return result: Any cmd, cmd_arguments = _extract_command(fields) try: func, sig = self._name_to_func(cmd) # ACL check self._server.acl.validate_command(self.current_user, self.client_info_as_bytes, fields) with self._server.lock: # Clean out old connections while True: try: weak_sock = self._server.closed_sockets.pop() except IndexError: break else: sock = weak_sock() if sock: sock._cleanup(self._server) now = time.time() for db in self._server.dbs.values(): db.time = now sig.check_arity(cmd_arguments, self.version) if self._transaction is not None and msgs.FLAG_TRANSACTION not in sig.flags: self._transaction.append((func, sig, cmd_arguments)) result = QUEUED else: result = self._run_command(func, sig, cmd_arguments, False) except SimpleError as exc: if self._transaction is not None: # TODO: should not apply if the exception is from _run_command # e.g. watch inside multi self._transaction_failed = True if cmd == "exec" and exc.value.startswith("ERR "): exc.value = "EXECABORT Transaction discarded because of: " + exc.value[4:] self._transaction = None self._transaction_failed = False self._clear_watches() result = exc result = self._decode_result(result) if not isinstance(result, NoResponse): self.put_response(result) def _run_command( self, func: Optional[Callable[[Any], Any]], sig: Signature, args: List[Any], from_script: bool ) -> Any: command_items: List[CommandItem] = [] try: ret = sig.apply(args, self._db, self.version) if from_script and msgs.FLAG_NO_SCRIPT in sig.flags: raise SimpleError(msgs.COMMAND_IN_SCRIPT_MSG) if self._pubsub and sig.name not in BaseFakeSocket.ACCEPTED_COMMANDS_WHILE_PUBSUB: raise SimpleError(msgs.BAD_COMMAND_IN_PUBSUB_MSG) if len(ret) == 1: result = ret[0] else: args, command_items = ret result = func(*args) # type: ignore if self.protocol_version == 2 and msgs.FLAG_SKIP_CONVERT_TO_RESP2 not in sig.flags: result = _convert_to_resp2(result) if msgs.FLAG_SKIP_CONVERT_TO_RESP2 not in sig.flags: assert valid_response_type(result, self.protocol_version), f"Invalid response type for {result}" except SimpleError as exc: result = exc for command_item in command_items: command_item.writeback(remove_empty_val=msgs.FLAG_LEAVE_EMPTY_VAL not in sig.flags) return result def _decode_error(self, error: SimpleError) -> ResponseError: if self._client_class.__module__.startswith("redis"): from redis.connection import DefaultParser return DefaultParser(socket_read_size=65536).parse_error(error.value) else: from valkey.connection import DefaultParser return DefaultParser(socket_read_size=65536).parse_error(error.value) def _decode_result(self, result: Any) -> Any: """Convert SimpleString and SimpleError, recursively""" if isinstance(result, list): return [self._decode_result(r) for r in result] elif isinstance(result, SimpleString): return result.value elif isinstance(result, SimpleError): return self._decode_error(result) else: return result def _blocking(self, timeout: Optional[Union[float, int]], func: Callable[[bool], Any]) -> Any: """Run a function until it succeeds or timeout is reached. The timeout is in seconds, and 0 means infinite. The function is called with a boolean to indicate whether this is the first call. If it returns None, it is considered to have "failed" and is retried each time the condition variable is notified, until the timeout is reached. Returns the function return value, or None if the timeout has passed. """ ret = func(True) # Call with first_pass=True if ret is not None or self._in_transaction: return ret deadline = time.time() + timeout if timeout else None while True: timeout = (deadline - time.time()) if deadline is not None else None if timeout is not None and timeout <= 0: return None if self._db.condition.wait(timeout=timeout) is False: return None # Timeout expired ret = func(False) # Second pass => first_pass=False if ret is not None: return ret def _name_to_func(self, cmd_name: str) -> Tuple[Optional[Callable[[Any], Any]], Signature]: """Get the signature and the method from the command name.""" if cmd_name not in SUPPORTED_COMMANDS: # redis remaps \r or \n in an error to ' ' to make it legal protocol clean_name = cmd_name.replace("\r", " ").replace("\n", " ") raise SimpleError(msgs.UNKNOWN_COMMAND_MSG.format(clean_name)) sig = SUPPORTED_COMMANDS[cmd_name] if self._server.server_type not in sig.server_types: # redis remaps \r or \n in an error to ' ' to make it legal protocol clean_name = cmd_name.replace("\r", " ").replace("\n", " ") raise SimpleError(msgs.UNKNOWN_COMMAND_MSG.format(clean_name)) func = getattr(self, sig.func_name, None) return func, sig def sendall(self, data: AnyStr) -> None: if not self._server.connected: raise self._connection_error_class(msgs.CONNECTION_ERROR_MSG) if isinstance(data, str): data = data.encode("ascii") # type: ignore self._parser.send(data) def _scan(self, keys: Sequence[bytes], cursor: int, *args: bytes) -> List[Union[bytes, List[bytes]]]: """This is the basis of most of the ``scan`` methods. This implementation is KNOWN to be un-performant, as it requires grabbing the full set of keys over which we are investigating subsets. The SCAN command, and the other commands in the SCAN family, are able to provide to the user a set of guarantees associated with full iterations. - A full iteration always retrieves all the elements that were present in the collection from the start to the end of a full iteration. This means that if a given element is inside the collection when an iteration is started and is still there when an iteration terminates, then at some point the SCAN command returned it to the user. - A full iteration never returns any element that was NOT present in the collection from the start to the end of a full iteration. So if an element was removed before the start of an iteration and is never added back to the collection for all the time an iteration lasts, the SCAN command ensures that this element will never be returned. However, because the SCAN command has very little state associated (just the cursor), it has the following drawbacks: - A given element may be returned multiple times. It is up to the application to handle the case of duplicated elements, for example, only using the returned elements to perform operations that are safe when re-applied multiple times. - Elements that were not constantly present in the collection during a full iteration may be returned or not: it is undefined. """ cursor = int(cursor) (pattern, _type, count), _ = extract_args(args, ("*match", "*type", "+count")) count = 10 if count is None else count data = sorted(keys) bits_len = (len(keys) - 1).bit_length() cursor = bin_reverse(cursor, bits_len) if cursor >= len(keys): return [b"0", []] result_cursor = cursor + count result_data = [] regex = compile_pattern(pattern) if pattern is not None else None def match_key(key: bytes) -> Union[bool, Match[bytes], None]: if isinstance(key, str): key = key.encode("utf-8") return regex.match(key) if regex is not None else True def match_type(key: bytes) -> bool: return _type is None or casematch(BaseFakeSocket._key_value_type(self._db[key]).value, _type) if pattern is not None or _type is not None: for val in itertools.islice(data, cursor, cursor + count): compare_val = val[0] if isinstance(val, tuple) else val if match_key(compare_val) and match_type(compare_val): result_data.append(val) else: result_data = data[cursor : cursor + count] if result_cursor >= len(data): result_cursor = 0 return [str(bin_reverse(result_cursor, bits_len)).encode(), result_data] def _ttl(self, key: CommandItem, scale: float) -> int: if not key: return -2 elif key.expireat is None: return -1 else: return int(round((key.expireat - self._db.time) * scale)) def _encodefloat(self, value: float, humanfriendly: bool) -> bytes: if self.version >= (7,): value = 0 + value return Float.encode(value, humanfriendly) def _encodeint(self, value: int) -> bytes: if self.version >= (7,): value = 0 + value return Int.encode(value) @staticmethod def _key_value_type(key: CommandItem) -> SimpleString: if key.value is None: return SimpleString(b"none") elif isinstance(key.value, bytes): return SimpleString(b"string") elif isinstance(key.value, list): return SimpleString(b"list") elif isinstance(key.value, ExpiringMembersSet): return SimpleString(b"set") elif isinstance(key.value, ZSet): return SimpleString(b"zset") elif isinstance(key.value, Hash): return SimpleString(b"hash") elif isinstance(key.value, XStream): return SimpleString(b"stream") else: assert False # pragma: nocover fakeredis-2.31.0/fakeredis/_command_args_parsing.py0000644000000000000000000001161613615410400017302 0ustar00from typing import Tuple, List, Dict, Any, Sequence, Optional from . import _msgs as msgs from ._commands import Int, Float from ._helpers import SimpleError, null_terminate def _count_params(s: str) -> int: res = 0 while res < len(s) and s[res] in ".+*~": res += 1 return res def _encode_arg(s: str) -> bytes: return s[_count_params(s) :].encode() def _default_value(s: str) -> Any: if s[0] == "~": return None ind = _count_params(s) if ind == 0: return False elif ind == 1: return None else: return [None] * ind def extract_args( actual_args: Tuple[bytes, ...], expected: Tuple[str, ...], error_on_unexpected: bool = True, left_from_first_unexpected: bool = True, exception: Optional[str] = None, ) -> Tuple[List[Any], Sequence[Any]]: """Parse argument values. Extract from actual arguments which arguments exist and their value if relevant. :param actual_args: The actual arguments to parse :param expected: Arguments to look for, see below explanation. :param error_on_unexpected: Should an error be raised when actual_args contain an unexpected argument? :param left_from_first_unexpected: Once reaching an unexpected argument in actual_args, Should parsing stop? :param exception: What exception msg to raise :returns: - List of values for expected arguments. - List of remaining args. An expected argument can have parameters: - A numerical (Int) parameter is identified with '+' - A float (Float) parameter is identified with '.' - A non-numerical parameter is identified with a '*' - An argument with potentially ~ or = between the argument name and the value is identified with a '~' - A numberical argument with potentially ~ or = between the argument name and the value marked with a '~+' E.g. '++limit' will translate as an argument with 2 int parameters. >>> extract_args((b'nx', b'ex', b'324', b'xx',), ('nx', 'xx', '+ex', 'keepttl')) [True, True, 324, False], None >>> extract_args( (b'maxlen', b'10',b'nx', b'ex', b'324', b'xx',), ('~+maxlen', 'nx', 'xx', '+ex', 'keepttl')) 10, [True, True, 324, False], None """ args_info: Dict[bytes, Tuple[int, int]] = {_encode_arg(k): (i, _count_params(k)) for (i, k) in enumerate(expected)} def _parse_params(key: bytes, ind: int, _actual_args: Tuple[bytes, ...]) -> Tuple[Any, int]: """Parse an argument from actual args. :param key: Argument name to parse :param ind: index of argument in actual_args :param _actual_args: actual args """ pos, expected_following = args_info[key] argument_name = expected[pos] # Deal with parameters with optional ~/= before numerical value. arg: Any if argument_name[0] == "~": if ind + 1 >= len(_actual_args): raise SimpleError(msgs.SYNTAX_ERROR_MSG) if _actual_args[ind + 1] != b"~" and _actual_args[ind + 1] != b"=": arg, _parsed = _actual_args[ind + 1], 1 elif ind + 2 >= len(_actual_args): raise SimpleError(msgs.SYNTAX_ERROR_MSG) else: arg, _parsed = _actual_args[ind + 2], 2 if argument_name[1] == "+": arg = Int.decode(arg) return arg, _parsed # Boolean parameters if expected_following == 0: return True, 0 if ind + expected_following >= len(_actual_args): raise SimpleError(msgs.SYNTAX_ERROR_MSG) temp_res = [] for i in range(expected_following): curr_arg: Any = _actual_args[ind + i + 1] if argument_name[i] == "+": curr_arg = Int.decode(curr_arg) elif argument_name[i] == ".": curr_arg = Float.decode(curr_arg) temp_res.append(curr_arg) if len(temp_res) == 1: return temp_res[0], expected_following else: return temp_res, expected_following results: List[Any] = [_default_value(key) for key in expected] left_args = [] i = 0 while i < len(actual_args): found = False for key in args_info: if null_terminate(actual_args[i]) == key: arg_position, _ = args_info[key] results[arg_position], parsed = _parse_params(key, i, actual_args) i += parsed found = True break if not found: if error_on_unexpected: raise ( SimpleError(msgs.SYNTAX_ERROR_MSG) if exception is None else SimpleError(exception.format(actual_args[i])) ) if left_from_first_unexpected: return results, actual_args[i:] left_args.append(actual_args[i]) i += 1 return results, left_args fakeredis-2.31.0/fakeredis/_commands.py0000644000000000000000000003616313615410400014732 0ustar00""" Helper classes and methods used in mixins implementing various commands. Unlike _helpers.py, here the methods should be used only in mixins. """ import functools import math import re import sys import time from typing import Tuple, Union, Optional, Any, Type, List, Callable, Sequence, Dict, Set, Collection from . import _msgs as msgs from ._helpers import null_terminate, SimpleError, Database from .typing import VersionType, ServerType MAX_STRING_SIZE = 512 * 1024 * 1024 SUPPORTED_COMMANDS: Dict[str, "Signature"] = dict() # Dictionary of supported commands name => Signature COMMANDS_WITH_SUB: Set[str] = set() # Commands with sub-commands class Key: """Marker to indicate that argument in signature is a key""" UNSPECIFIED = object() def __init__(self, type_: Optional[Type[Any]] = None, missing_return: Any = UNSPECIFIED) -> None: self.type_ = type_ self.missing_return = missing_return class Item: """An item stored in the database""" __slots__ = ["value", "expireat"] def __init__(self, value: Any) -> None: self.value = value self.expireat = None class CommandItem: """An item referenced by a command. It wraps an Item but has extra fields to manage updates and notifications. """ def __init__(self, key: bytes, db: Database, item: Optional["CommandItem"] = None, default: Any = None) -> None: self._expireat: Optional[float] if item is None: self._value = default self._expireat = None else: self._value = item.value self._expireat = item.expireat self.key = key self.db = db self._modified = False self._expireat_modified = False @property def value(self) -> Any: return self._value @value.setter def value(self, new_value: Any) -> None: self._value = new_value self._modified = True self.expireat = None @property def expireat(self) -> Optional[float]: return self._expireat @expireat.setter def expireat(self, value: Optional[float]) -> None: self._expireat = value self._expireat_modified = True self._modified = True # Since redis 6.0.7 def get(self, default: Any) -> Any: return self._value if self else default def update(self, new_value: Any) -> None: self._value = new_value self._modified = True def updated(self) -> None: self._modified = True def writeback(self, remove_empty_val: bool = True) -> None: if self._modified: self.db.notify_watch(self.key) if not isinstance(self.value, bytes) and (self.value is None or (not self.value and remove_empty_val)): self.db.pop(self.key, None) return item = self.db.setdefault(self.key, Item(None)) item.value = self.value item.expireat = self.expireat return if self._expireat_modified and self.key in self.db: self.db[self.key].expireat = self.expireat def __bool__(self) -> bool: return bool(self._value) or isinstance(self._value, bytes) __nonzero__ = __bool__ # For Python 2 class RedisType: @classmethod def decode(cls, *args, **kwargs): # type:ignore raise NotImplementedError class Int(RedisType): """Argument converter for 64-bit signed integers""" DECODE_ERROR = msgs.INVALID_INT_MSG ENCODE_ERROR = msgs.OVERFLOW_MSG MIN_VALUE = -(2**63) MAX_VALUE = 2**63 - 1 @classmethod def valid(cls, value: int) -> bool: return cls.MIN_VALUE <= value <= cls.MAX_VALUE @classmethod def decode(cls, value: bytes, decode_error: Optional[str] = None) -> int: try: out = int(value) if not cls.valid(out) or str(out).encode() != value: raise ValueError return out except ValueError: raise SimpleError(decode_error or cls.DECODE_ERROR) @classmethod def encode(cls, value: int) -> bytes: if cls.valid(value): return str(value).encode() else: raise SimpleError(cls.ENCODE_ERROR) class DbIndex(Int): """Argument converter for database indices""" DECODE_ERROR = msgs.INVALID_DB_MSG MIN_VALUE = 0 MAX_VALUE = 15 class BitOffset(Int): """Argument converter for unsigned bit positions""" DECODE_ERROR = msgs.INVALID_BIT_OFFSET_MSG MIN_VALUE = 0 MAX_VALUE = 8 * MAX_STRING_SIZE - 1 # Redis imposes 512MB limit on keys class BitValue(Int): DECODE_ERROR = msgs.INVALID_BIT_VALUE_MSG MIN_VALUE = 0 MAX_VALUE = 1 class Float(RedisType): """Argument converter for floating-point values. Redis uses long double for some cases (INCRBYFLOAT, HINCRBYFLOAT) and double for others (zset scores), but Python doesn't support `long double`. """ DECODE_ERROR = msgs.INVALID_FLOAT_MSG @classmethod def decode( cls, value: bytes, allow_leading_whitespace: bool = False, allow_erange: bool = False, allow_empty: bool = False, crop_null: bool = False, decode_error: Optional[str] = None, ) -> float: # Redis has some quirks in float parsing, with several variants. # See https://github.com/antirez/redis/issues/5706 try: if crop_null: value = null_terminate(value) if allow_empty and value == b"": value = b"0.0" if not allow_leading_whitespace and value[:1].isspace(): raise ValueError if value[-1:].isspace(): raise ValueError out = float(value) if math.isnan(out): raise ValueError if not allow_erange: # Values that over- or under-flow are explicitly rejected by # redis. This is a crude hack to determine whether the input # may have been such a value. if out in (math.inf, -math.inf, 0.0) and re.match(b"^[^a-zA-Z]*[1-9]", value): raise ValueError return out except ValueError: raise SimpleError(decode_error or cls.DECODE_ERROR) @classmethod def encode(cls, value: float, humanfriendly: bool) -> bytes: if math.isinf(value): return str(value).encode() elif humanfriendly: # Algorithm from `ld2string` in redis out = "{:.17f}".format(value) out = re.sub(r"\.?0+$", "", out) return out.encode() else: return "{:.17g}".format(value).encode() class Timeout(Float): """Argument converter for timeouts""" DECODE_ERROR = msgs.TIMEOUT_NEGATIVE_MSG MIN_VALUE = 0.0 class SortFloat(Float): DECODE_ERROR = msgs.INVALID_SORT_FLOAT_MSG @classmethod def decode( cls, value: bytes, allow_leading_whitespace: bool = True, allow_erange: bool = False, allow_empty: bool = True, crop_null: bool = True, decode_error: Optional[str] = None, ) -> float: return super().decode(value, allow_leading_whitespace=True, allow_empty=True, crop_null=True) @functools.total_ordering class BeforeAny: def __gt__(self, other: Any) -> bool: return False def __eq__(self, other: Any) -> bool: return isinstance(other, BeforeAny) def __hash__(self) -> int: return 1 @functools.total_ordering class AfterAny: def __lt__(self, other: Any) -> bool: return False def __eq__(self, other: Any) -> bool: return isinstance(other, AfterAny) def __hash__(self) -> int: return 1 class ScoreTest(RedisType): """Argument converter for sorted set score endpoints.""" def __init__(self, value: float, exclusive: bool = False, bytes_val: Optional[bytes] = None): self.value = value self.exclusive = exclusive self.bytes_val = bytes_val @classmethod def decode(cls, value: bytes) -> "ScoreTest": try: original_value = value exclusive = False if value[:1] == b"(": exclusive = True value = value[1:] fvalue = Float.decode( value, allow_leading_whitespace=True, allow_erange=True, allow_empty=True, crop_null=True, ) return cls(fvalue, exclusive, original_value) except SimpleError: raise SimpleError(msgs.INVALID_MIN_MAX_FLOAT_MSG) def __str__(self) -> str: if self.exclusive: return "({!r}".format(self.value) else: return repr(self.value) @property def lower_bound(self) -> Tuple[float, Union[AfterAny, BeforeAny]]: return self.value, AfterAny() if self.exclusive else BeforeAny() @property def upper_bound(self) -> Tuple[float, Union[AfterAny, BeforeAny]]: return self.value, BeforeAny() if self.exclusive else AfterAny() class StringTest(RedisType): """Argument converter for sorted set LEX endpoints.""" def __init__(self, value: Union[bytes, BeforeAny, AfterAny], exclusive: bool): self.value = value self.exclusive = exclusive @classmethod def decode(cls, value: bytes) -> "StringTest": if value == b"-": return cls(BeforeAny(), True) elif value == b"+": return cls(AfterAny(), True) elif value[:1] == b"(": return cls(value[1:], True) elif value[:1] == b"[": return cls(value[1:], False) else: raise SimpleError(msgs.INVALID_MIN_MAX_STR_MSG) # def to_scoretest(self, zset: ZSet) -> ScoreTest: # if isinstance(self.value, BeforeAny): # return ScoreTest(float("-inf"), False) # if isinstance(self.value, AfterAny): # return ScoreTest(float("inf"), False) # val: float = zset.get(self.value, None) # return ScoreTest(val, self.exclusive) class Signature: def __init__( self, name: str, func_name: str, fixed: Tuple[Type[Union[RedisType, bytes]]], repeat: Tuple[Type[Union[RedisType, bytes]]] = (), # type:ignore args: Tuple[str] = (), # type:ignore flags: str = "", server_types: Collection[ServerType] = ( "redis", "valkey", "dragonfly", ), # supported server types: redis, dragonfly, valkey ): self.name = name self.func_name = func_name self.fixed = fixed self.repeat = repeat self.flags = set(flags) self.command_args = args self.server_types: Set[ServerType] = set(server_types) def check_arity(self, args: Sequence[Any], version: VersionType) -> None: if len(args) == len(self.fixed): return delta = len(args) - len(self.fixed) if delta < 0 or not self.repeat: msg = msgs.WRONG_ARGS_MSG6.format(self.name) raise SimpleError(msg) if delta % len(self.repeat) != 0: msg = msgs.WRONG_ARGS_MSG7 if version >= (7,) else msgs.WRONG_ARGS_MSG6.format(self.name) raise SimpleError(msg) def apply( self, args: Sequence[Any], db: Database, version: VersionType ) -> Union[Tuple[Any], Tuple[List[Any], List[CommandItem]]]: """Returns a tuple, which is either: - transformed args and a dict of CommandItems; or - a single containing a short-circuit return value """ self.check_arity(args, version) types = list(self.fixed) for i in range(len(args) - len(types)): types.append(self.repeat[i % len(self.repeat)]) args_list = list(args) # First pass: convert/validate non-keys, and short-circuit on missing keys for i, (arg, type_) in enumerate(zip(args_list, types)): if isinstance(type_, Key): if type_.missing_return is not Key.UNSPECIFIED and arg not in db: return (type_.missing_return,) elif type_ is not bytes: args_list[i] = type_.decode( args_list[i], ) # Second pass: read keys and check their types command_items: List[CommandItem] = [] for i, (arg, type_) in enumerate(zip(args_list, types)): if isinstance(type_, Key): item = db.get(arg) default = None if type_.type_ is not None and item is not None and type(item.value) is not type_.type_: raise SimpleError(msgs.WRONGTYPE_MSG) if ( msgs.FLAG_DO_NOT_CREATE not in self.flags and type_.type_ is not None and item is None and type_.type_ is not bytes ): default = type_.type_() args_list[i] = CommandItem(arg, db, item, default=default) command_items.append(args_list[i]) return args_list, command_items def command(*args, **kwargs) -> Callable: # type:ignore def create_signature(func: Callable[..., Any], cmd_name: str) -> None: if " " in cmd_name: COMMANDS_WITH_SUB.add(cmd_name.split(" ")[0]) SUPPORTED_COMMANDS[cmd_name] = Signature(cmd_name, func.__name__, *args, **kwargs) def decorator(func: Callable[..., Any]) -> Callable[..., Any]: cmd_names = kwargs.pop("name", func.__name__) if isinstance(cmd_names, list): # Support for alias commands for cmd_name in cmd_names: create_signature(func, cmd_name.lower()) elif isinstance(cmd_names, str): create_signature(func, cmd_names.lower()) else: raise ValueError("command name should be a string or list of strings") return func return decorator def delete_keys(*keys: CommandItem) -> int: ans = 0 done = set() for key in keys: if key and key.key not in done: key.value = None done.add(key.key) ans += 1 return ans def fix_range(start: int, end: int, length: int) -> Tuple[int, int]: # Redis handles negative slightly differently for zrange if start < 0: start = max(0, start + length) if end < 0: end += length if start > end or start >= length: return -1, -1 end = min(end, length - 1) return start, end + 1 def fix_range_string(start: int, end: int, length: int) -> Tuple[int, int]: # Negative number handling is based on the redis source code if 0 > start > end and end < 0: return -1, -1 if start < 0: start = max(0, start + length) if end < 0: end = max(0, end + length) end = min(end, length - 1) return start, end + 1 class Timestamp(Int): """Argument converter for timestamps""" @classmethod def decode(cls, value: bytes, decode_error: Optional[str] = None) -> int: if value == b"*": return int(time.time() * 1000) if value == b"-": return -1 if value == b"+": return sys.maxsize return super().decode(value, decode_error=msgs.INVALID_EXPIRE_MSG) fakeredis-2.31.0/fakeredis/_connection.py0000644000000000000000000001655613615410400015274 0ustar00import queue import time import warnings from typing import Tuple, Any, List, Optional, Set, Sequence, Union import redis from fakeredis._fakesocket import FakeSocket from fakeredis._helpers import FakeSelector, convert_args_to_redis_init_kwargs from . import _msgs as msgs from ._server import FakeBaseConnectionMixin, FakeServer, VersionType, ServerType from .typing import Self, lib_version, RaiseErrorTypes class FakeConnection(FakeBaseConnectionMixin, redis.Connection): def __init__(*args: Any, **kwargs: Any) -> None: FakeBaseConnectionMixin.__init__(*args, **kwargs) def connect(self) -> None: super().connect() # type: ignore # The selector is set in redis.Connection.connect() after _connect() is called self._selector: Optional[FakeSelector] = FakeSelector(self._sock) def _connect(self) -> FakeSocket: if not self._server.connected: raise redis.ConnectionError(msgs.CONNECTION_ERROR_MSG) return FakeSocket( self._server, client_class=self._client_class, db=self.db, lua_modules=self._lua_modules, client_info=dict( id=3, addr="127.0.0.1:57275", # TODO get IP laddr="127.0.0.1:6379", # TODO get IP fd=8, name="", _created=int(time.time()), idle=0, flags="N", db=0, sub=0, psub=0, ssub=0, multi=-1, qbuf=48, qbuf_free=16842, argv_mem=25, multi_mem=0, rbs=1024, rbp=0, obl=0, oll=0, omem=0, tot_mem=18737, events="r", cmd="auth", user="default", redir=-1, resp=2, ), ) def can_read(self, timeout: Optional[float] = 0) -> bool: if not self._server.connected: return True if not self._sock: self.connect() # We use check_can_read rather than can_read, because on redis-py<3.2, # FakeSelector inherits from a stub BaseSelector which doesn't # implement can_read. Normally can_read provides retries on EINTR, # but that's not necessary for the implementation of # FakeSelector.check_can_read. return self._selector is not None and self._selector.check_can_read(timeout) def _decode(self, response: Any) -> Any: if isinstance(response, list): return [self._decode(item) for item in response] elif isinstance(response, dict): return {self._decode(k): self._decode(v) for k, v in response.items()} elif isinstance(response, bytes): return self.encoder.decode(response) # type: ignore else: return response def read_response(self, **kwargs: Any) -> Any: # type: ignore if not self._sock: raise redis.ConnectionError(msgs.CONNECTION_ERROR_MSG) if not self._server.connected: try: response = self._sock.responses.get_nowait() except queue.Empty: if kwargs.get("disconnect_on_error", True): self.disconnect() raise redis.ConnectionError(msgs.CONNECTION_ERROR_MSG) else: response = self._sock.responses.get() if isinstance(response, RaiseErrorTypes): raise response if kwargs.get("disable_decoding", False): return response else: return self._decode(response) def repr_pieces(self) -> List[Tuple[str, Any]]: pieces = [("server", self._server), ("db", self.db)] if self.client_name: pieces.append(("client_name", self.client_name)) return pieces def _get_from_local_cache(self, command: Sequence[str]) -> None: return None def _add_to_local_cache(self, command: Sequence[str], response: Any, keys: List[Any]) -> None: return None def __str__(self) -> str: return self.server_key class FakeRedisMixin: def __init__( self, *args: Any, server: Optional[FakeServer] = None, version: Union[VersionType, str, int] = (7,), # https://github.com/cunla/fakeredis-py/issues/401 server_type: ServerType = "redis", lua_modules: Optional[Set[str]] = None, client_class=redis.Redis, **kwargs: Any, ) -> None: """ :param server: The FakeServer instance to use for this connection. :param version: The Redis version to use, as a tuple (major, minor). :param server_type: The type of server, e.g., "redis", "valkey". :param lua_modules: A set of Lua modules to load. :param client_class: The Redis client class to use, e.g., redis.Redis or valkey.Valkey. """ kwds = convert_args_to_redis_init_kwargs(client_class, *args, **kwargs) kwds["server"] = server if not kwds.get("connection_pool", None): charset = kwds.get("charset", None) errors = kwds.get("errors", None) # Adapted from redis-py if charset is not None: warnings.warn(DeprecationWarning('"charset" is deprecated. Use "encoding" instead')) kwds["encoding"] = charset if errors is not None: warnings.warn(DeprecationWarning('"errors" is deprecated. Use "encoding_errors" instead')) kwds["encoding_errors"] = errors conn_pool_args = { "host", "port", "db", "username", "password", "socket_timeout", "encoding", "encoding_errors", "decode_responses", "retry_on_timeout", "max_connections", "health_check_interval", "client_name", "connected", "server", "protocol", } connection_kwargs = { "connection_class": FakeConnection, "version": version, "server_type": server_type, "lua_modules": lua_modules, "client_class": client_class, } connection_kwargs.update({arg: kwds[arg] for arg in conn_pool_args if arg in kwds}) kwds["connection_pool"] = redis.connection.ConnectionPool(**connection_kwargs) # type: ignore kwds.pop("server", None) kwds.pop("connected", None) kwds.pop("version", None) kwds.pop("server_type", None) kwds.pop("lua_modules", None) kwds.setdefault("lib_name", "fakeredis") kwds.setdefault("lib_version", lib_version) super().__init__(**kwds) @classmethod def from_url(cls, *args: Any, **kwargs: Any) -> Self: kwargs.setdefault("version", "7.4") kwargs.setdefault("server_type", "redis") pool = redis.ConnectionPool.from_url(*args, **kwargs) # Now override how it creates connections pool.connection_class = FakeConnection return cls(connection_pool=pool, *args, **kwargs) class FakeStrictRedis(FakeRedisMixin, redis.StrictRedis): pass class FakeRedis(FakeRedisMixin, redis.Redis): pass fakeredis-2.31.0/fakeredis/_fakesocket.py0000644000000000000000000000331713615410400015243 0ustar00from typing import Optional, Set, Any from fakeredis.commands_mixins import ( BitmapCommandsMixin, ConnectionCommandsMixin, GenericCommandsMixin, GeoCommandsMixin, HashCommandsMixin, ListCommandsMixin, PubSubCommandsMixin, ScriptingCommandsMixin, ServerCommandsMixin, StringCommandsMixin, TransactionsCommandsMixin, SetCommandsMixin, StreamsCommandsMixin, AclCommandsMixin, ) from fakeredis.stack import ( JSONCommandsMixin, BFCommandsMixin, CFCommandsMixin, CMSCommandsMixin, TopkCommandsMixin, TDigestCommandsMixin, TimeSeriesCommandsMixin, ) from ._basefakesocket import BaseFakeSocket from ._server import FakeServer from .commands_mixins.sortedset_mixin import SortedSetCommandsMixin from .server_specific_commands import DragonflyCommandsMixin class FakeSocket( BaseFakeSocket, GenericCommandsMixin, ScriptingCommandsMixin, HashCommandsMixin, ConnectionCommandsMixin, ListCommandsMixin, ServerCommandsMixin, StringCommandsMixin, TransactionsCommandsMixin, PubSubCommandsMixin, SetCommandsMixin, BitmapCommandsMixin, SortedSetCommandsMixin, StreamsCommandsMixin, JSONCommandsMixin, GeoCommandsMixin, BFCommandsMixin, CFCommandsMixin, CMSCommandsMixin, TopkCommandsMixin, TDigestCommandsMixin, TimeSeriesCommandsMixin, DragonflyCommandsMixin, AclCommandsMixin, ): def __init__( self, server: FakeServer, db: int, lua_modules: Optional[Set[str]] = None, # noqa: F821 *args: Any, **kwargs: Any, ) -> None: super(FakeSocket, self).__init__(server, db, *args, lua_modules=lua_modules, **kwargs) fakeredis-2.31.0/fakeredis/_helpers.py0000644000000000000000000002177113615410400014572 0ustar00import inspect import re import threading import time import uuid import weakref from collections import defaultdict from typing import Any, Set, Callable, Dict, Optional, Iterator, AnyStr, Type, MutableMapping import redis class SimpleString: def __init__(self, value: bytes) -> None: assert isinstance(value, bytes) self.value = value @classmethod def decode(cls, value: bytes) -> bytes: return value def __repr__(self) -> str: return f"{self.__class__.__name__}({self.value!r})" class SimpleError(Exception): """Exception that will be turned into a frontend-specific exception.""" def __init__(self, value: str) -> None: assert isinstance(value, str) self.value = value class NoResponse: """Returned by pub/sub commands to indicate that no response should be returned""" pass OK = SimpleString(b"OK") QUEUED = SimpleString(b"QUEUED") BGSAVE_STARTED = SimpleString(b"Background saving started") def current_time() -> int: """Return current_time in ms""" return int(time.time() * 1000) def null_terminate(s: bytes) -> bytes: # Redis uses C functions on some strings, which means they stop at the # first NULL. ind = s.find(b"\0") if ind > -1: return s[:ind].lower() return s.lower() def casematch(a: bytes, b: bytes) -> bool: return null_terminate(a) == null_terminate(b) def decode_command_bytes(s: bytes) -> str: return s.decode(encoding="utf-8", errors="replace").lower() def asbytes(value: AnyStr) -> bytes: if isinstance(value, str): return value.encode("utf-8") return value def compile_pattern(pattern_bytes: bytes) -> re.Pattern: # type: ignore """Compile a glob pattern (e.g., for keys) to a `bytes` regex. `fnmatch.fnmatchcase` doesn't work for this because it uses different escaping rules to redis, uses ! instead of ^ to negate a character set, and handles invalid cases (such as a [ without a ]) differently. This implementation was written by studying the redis implementation. """ # It's easier to work with text than bytes, because indexing bytes # doesn't behave the same in Python 3. Latin-1 will round-trip safely. pattern: str = pattern_bytes.decode( "latin-1", ) parts = ["^"] i = 0 pattern_len = len(pattern) while i < pattern_len: c = pattern[i] i += 1 if c == "?": parts.append(".") elif c == "*": parts.append(".*") elif c == "\\": if i == pattern_len: i -= 1 parts.append(re.escape(pattern[i])) i += 1 elif c == "[": parts.append("[") if i < pattern_len and pattern[i] == "^": i += 1 parts.append("^") parts_len = len(parts) # To detect if anything was added while i < pattern_len: if pattern[i] == "\\" and i + 1 < pattern_len: i += 1 parts.append(re.escape(pattern[i])) elif pattern[i] == "]": i += 1 break elif i + 2 < pattern_len and pattern[i + 1] == "-": start = pattern[i] end = pattern[i + 2] if start > end: start, end = end, start parts.append(re.escape(start) + "-" + re.escape(end)) i += 2 else: parts.append(re.escape(pattern[i])) i += 1 if len(parts) == parts_len: if parts[-1] == "[": # Empty group - will never match parts[-1] = "(?:$.)" else: # Negated empty group - matches any character assert parts[-1] == "^" parts.pop() parts[-1] = "." else: parts.append("]") else: parts.append(re.escape(c)) parts.append("\\Z") regex: bytes = "".join(parts).encode("latin-1") return re.compile(regex, flags=re.S) class Database(MutableMapping): # type: ignore def __init__(self, lock: Optional[threading.Lock], *args: Any, **kwargs: Any) -> None: self._dict: Dict[bytes, Any] = dict(*args, **kwargs) self.time = 0.0 # key to the set of connections self._watches: Dict[bytes, weakref.WeakSet[Any]] = defaultdict(weakref.WeakSet) self.condition = threading.Condition(lock) self._change_callbacks: Set[Callable[[], None]] = set() def swap(self, other: "Database") -> None: self._dict, other._dict = other._dict, self._dict self.time, other.time = other.time, self.time def notify_watch(self, key: bytes) -> None: for sock in self._watches.get(key, set()): sock.notify_watch() self.condition.notify_all() for callback in self._change_callbacks: callback() def add_watch(self, key: bytes, sock: Any) -> None: self._watches[key].add(sock) def remove_watch(self, key: bytes, sock: Any) -> None: watches = self._watches[key] watches.discard(sock) if not watches: del self._watches[key] def add_change_callback(self, callback: Callable[[], None]) -> None: self._change_callbacks.add(callback) def remove_change_callback(self, callback: Callable[[], None]) -> None: self._change_callbacks.remove(callback) def clear(self) -> None: for key in self: self.notify_watch(key) self._dict.clear() def expired(self, item: Any) -> bool: return item.expireat is not None and item.expireat < self.time def _remove_expired(self) -> None: for key in list(self._dict): item = self._dict[key] if self.expired(item): del self._dict[key] def __getitem__(self, key: bytes) -> Any: item = self._dict[key] if self.expired(item): del self._dict[key] raise KeyError(key) return item def __setitem__(self, key: bytes, value: Any) -> None: self._dict[key] = value def __delitem__(self, key: bytes) -> None: del self._dict[key] def __iter__(self) -> Iterator[bytes]: self._remove_expired() return iter(self._dict) def __len__(self) -> int: self._remove_expired() return len(self._dict) def __hash__(self) -> int: return hash(super(object, self)) def __eq__(self, other: object) -> bool: return super(object, self) == other _VALID_RESPONSE_TYPES_RESP2 = (bytes, SimpleString, SimpleError, float, int, list) _VALID_RESPONSE_TYPES_RESP3 = (bytes, SimpleString, SimpleError, float, int, list, dict, str) def valid_response_type(value: Any, protocol_version: int, nested: bool = False) -> bool: if isinstance(value, NoResponse) and not nested: return True allowed_types = _VALID_RESPONSE_TYPES_RESP2 if protocol_version == 2 else _VALID_RESPONSE_TYPES_RESP3 if value is not None and not isinstance(value, allowed_types): return False if isinstance(value, list): if any(not valid_response_type(item, protocol_version, True) for item in value): return False return True class FakeSelector(object): def __init__(self, sock: Any): self.sock = sock def check_can_read(self, timeout: Optional[float]) -> bool: if self.sock.responses.qsize(): return True if timeout is not None and timeout <= 0: return False # A sleep/poll loop is easier to mock out than messing with condition # variables. start = time.time() while True: if self.sock.responses.qsize(): return True time.sleep(0.01) now = time.time() if timeout is not None and now > start + timeout: return False @staticmethod def check_is_ready_for_command(_: Any) -> bool: return True def _get_args_to_warn() -> Set[str]: closure = redis.Redis.__init__.__closure__ if closure is None: return set() for cell in closure: value = cell.cell_contents if isinstance(value, list) and len(value) > 0: return set(value) return set() def convert_args_to_redis_init_kwargs(redis_class: Type[redis.Redis], *args: Any, **kwargs: Any) -> Dict[str, Any]: """Interpret the positional and keyword arguments according to the version of redis in use""" parameters = list(inspect.signature(redis_class.__init__).parameters.values())[1:] args_to_warn = _get_args_to_warn() # Convert args => kwargs kwargs.update({parameters[i].name: args[i] for i in range(len(args))}) kwargs.setdefault("host", uuid.uuid4().hex) kwds = { p.name: kwargs.get(p.name, p.default) for ind, p in enumerate(parameters) if p.default != inspect.Parameter.empty and (p.name not in args_to_warn or p.name in kwargs) } return kwds fakeredis-2.31.0/fakeredis/_msgs.py0000644000000000000000000001774713615410400014111 0ustar00INVALID_EXPIRE_MSG = "ERR invalid expire time in {}" WRONGTYPE_MSG = "WRONGTYPE Operation against a key holding the wrong kind of value" SYNTAX_ERROR_MSG = "ERR syntax error" SYNTAX_ERROR_LIMIT_ONLY_WITH_MSG = ( "ERR syntax error, LIMIT is only supported in combination with either BYSCORE or BYLEX" ) INVALID_HASH_MSG = "ERR hash value is not an integer" INVALID_INT_MSG = "ERR value is not an integer or out of range" INVALID_FLOAT_MSG = "ERR value is not a valid float" INVALID_WEIGHT_MSG = "ERR weight value is not a float" INVALID_OFFSET_MSG = "ERR offset is out of range" INVALID_BIT_OFFSET_MSG = "ERR bit offset is not an integer or out of range" INVALID_BIT_VALUE_MSG = "ERR bit is not an integer or out of range" BITOP_NOT_ONE_KEY_ONLY = "ERR BITOP NOT must be called with a single source key" INVALID_DB_MSG = "ERR DB index is out of range" INVALID_MIN_MAX_FLOAT_MSG = "ERR min or max is not a float" INVALID_MIN_MAX_STR_MSG = "ERR min or max not a valid string range item" STRING_OVERFLOW_MSG = "ERR string exceeds maximum allowed size (proto-max-bulk-len)" OVERFLOW_MSG = "ERR increment or decrement would overflow" NONFINITE_MSG = "ERR increment would produce NaN or Infinity" SCORE_NAN_MSG = "ERR resulting score is not a number (NaN)" INVALID_SORT_FLOAT_MSG = "ERR One or more scores can't be converted into double" SRC_DST_SAME_MSG = "ERR source and destination objects are the same" NO_KEY_MSG = "ERR no such key" INDEX_ERROR_MSG = "ERR index out of range" INDEX_NEGATIVE_ERROR_MSG = "ERR value is out of range, must be positive" # ZADD_NX_XX_ERROR_MSG6 = "ERR ZADD allows either 'nx' or 'xx', not both" ZADD_NX_XX_ERROR_MSG = "ERR XX and NX options at the same time are not compatible" ZADD_INCR_LEN_ERROR_MSG = "ERR INCR option supports a single increment-element pair" ZADD_NX_GT_LT_ERROR_MSG = "ERR GT, LT, and/or NX options at the same time are not compatible" NX_XX_GT_LT_ERROR_MSG = "ERR NX and XX, GT or LT options at the same time are not compatible" EXPIRE_UNSUPPORTED_OPTION = "ERR Unsupported option {}" ZUNIONSTORE_KEYS_MSG = "ERR at least 1 input key is needed for {}" WRONG_ARGS_MSG7 = "ERR Wrong number of args calling Redis command from script" WRONG_ARGS_MSG6 = "ERR wrong number of arguments for '{}' command" UNKNOWN_COMMAND_MSG = "ERR unknown command `{}`, with args beginning with: " EXECABORT_MSG = "EXECABORT Transaction discarded because of previous errors." MULTI_NESTED_MSG = "ERR MULTI calls can not be nested" WITHOUT_MULTI_MSG = "ERR {0} without MULTI" WATCH_INSIDE_MULTI_MSG = "ERR WATCH inside MULTI is not allowed" NEGATIVE_KEYS_MSG = "ERR Number of keys can't be negative" TOO_MANY_KEYS_MSG = "ERR Number of keys can't be greater than number of args" TIMEOUT_NEGATIVE_MSG = "ERR timeout is negative" NO_MATCHING_SCRIPT_MSG = "NOSCRIPT No matching script. Please use EVAL." GLOBAL_VARIABLE_MSG = "ERR Script attempted to set global variables: {}" COMMAND_IN_SCRIPT_MSG = "ERR This Redis command is not allowed from scripts" BAD_SUBCOMMAND_MSG = "ERR Unknown {} subcommand or wrong # of args." BAD_COMMAND_IN_PUBSUB_MSG = "ERR only (P)SUBSCRIBE / (P)UNSUBSCRIBE / PING / QUIT allowed in this context" CONNECTION_ERROR_MSG = "FakeRedis is emulating a connection error." REQUIRES_MORE_ARGS_MSG = "ERR {} requires {} arguments or more." LOG_INVALID_DEBUG_LEVEL_MSG = "ERR Invalid debug level." LUA_COMMAND_ARG_MSG6 = "ERR Lua redis() command arguments must be strings or integers" LUA_COMMAND_ARG_MSG = "ERR Lua redis lib command arguments must be strings or integers" VALKEY_LUA_COMMAND_ARG_MSG = "Command arguments must be strings or integers script: {}" LUA_WRONG_NUMBER_ARGS_MSG = "ERR wrong number or type of arguments" SCRIPT_ERROR_MSG = "ERR Error running script (call to f_{}): @user_script:?: {}" RESTORE_KEY_EXISTS = "BUSYKEY Target key name already exists." RESTORE_INVALID_CHECKSUM_MSG = "ERR DUMP payload version or checksum are wrong" RESTORE_INVALID_TTL_MSG = "ERR Invalid TTL value, must be >= 0" JSON_WRONG_REDIS_TYPE = "ERR Existing key has wrong Redis type" JSON_KEY_NOT_FOUND = "ERR could not perform this operation on a key that doesn't exist" JSON_PATH_NOT_FOUND_OR_NOT_STRING = "ERR Path '{}' does not exist or not a string" JSON_PATH_DOES_NOT_EXIST = "ERR Path '{}' does not exist" LCS_CANT_HAVE_BOTH_LEN_AND_IDX = "ERR If you want both the length and indexes, please just use IDX." BIT_ARG_MUST_BE_ZERO_OR_ONE = "ERR The bit argument must be 1 or 0." XADD_ID_LOWER_THAN_LAST = "ERR The ID specified in XADD is equal or smaller than the target stream top item" XADD_INVALID_ID = "ERR Invalid stream ID specified as stream command argument" XGROUP_BUSYGROUP = "ERR BUSYGROUP Consumer Group name already exists" XREADGROUP_KEY_OR_GROUP_NOT_FOUND_MSG = ( "NOGROUP No such key '{0}' or consumer group '{1}' in XREADGROUP with GROUP option" ) XGROUP_GROUP_NOT_FOUND_MSG = "NOGROUP No such consumer group '{0}' for key name '{1}'" XGROUP_KEY_NOT_FOUND_MSG = ( "ERR The XGROUP subcommand requires the key to exist." " Note that for CREATE you may want to use the MKSTREAM option to create an empty stream automatically." ) GEO_UNSUPPORTED_UNIT = "unsupported unit provided. please use M, KM, FT, MI" LPOS_RANK_CAN_NOT_BE_ZERO = ( "RANK can't be zero: use 1 to start from the first match, 2 from the second ... " "or use negative to start from the end of the list" ) NUMKEYS_GREATER_THAN_ZERO_MSG = "numkeys should be greater than 0" FILTER_FULL_MSG = "" NONSCALING_FILTERS_CANNOT_EXPAND_MSG = "Nonscaling filters cannot expand" ITEM_EXISTS_MSG = "item exists" NOT_FOUND_MSG = "not found" INVALID_BITFIELD_TYPE = ( "ERR Invalid bitfield type. Use something like i16 u8. Note that u64 is not supported but i64 is." ) INVALID_OVERFLOW_TYPE = "ERR Invalid OVERFLOW type specified" # ACL specific errors AUTH_FAILURE = "WRONGPASS invalid username-password pair or user is disabled." # TDigest error messages TDIGEST_KEY_EXISTS = "T-Digest: key already exists" TDIGEST_KEY_NOT_EXISTS = "T-Digest: key does not exist" TDIGEST_ERROR_PARSING_VALUE = "T-Digest: error parsing val parameter" TDIGEST_BAD_QUANTILE = "T-Digest: quantile should be in [0,1]" TDIGEST_BAD_RANK = "T-Digest: rank needs to be non negative" # TimeSeries error messages TIMESERIES_KEY_EXISTS = "TSDB: key already exists" TIMESERIES_INVALID_DUPLICATE_POLICY = "TSDB: Unknown DUPLICATE_POLICY" TIMESERIES_KEY_DOES_NOT_EXIST = "TSDB: the key does not exist" TIMESERIES_RULE_DOES_NOT_EXIST = "TSDB: compaction rule does not exist" TIMESERIES_RULE_EXISTS = "TSDB: the destination key already has a src rule" TIMESERIES_BAD_AGGREGATION_TYPE = "TSDB: Unknown aggregation type" TIMESERIES_INVALID_TIMESTAMP = "TSDB: invalid timestamp" TIMESERIES_BAD_TIMESTAMP = "TSDB: Couldn't parse alignTimestamp" TIMESERIES_TIMESTAMP_OLDER_THAN_RETENTION = "TSDB: Timestamp is older than retention" TIMESERIES_TIMESTAMP_LOWER_THAN_MAX_V7 = ( "TSDB: timestamp must be equal to or higher than the maximum existing timestamp" ) TIMESERIES_TIMESTAMP_LOWER_THAN_MAX_V6 = "TSDB: for incrby/decrby, timestamp should be newer than the lastest one" TIMESERIES_BAD_CHUNK_SIZE = "TSDB: CHUNK_SIZE value must be a multiple of 8 in the range [48 .. 1048576]" TIMESERIES_DUPLICATE_POLICY_BLOCK = ( "TSDB: Error at upsert, update is not supported when DUPLICATE_POLICY is set to BLOCK mode" ) TIMESERIES_BAD_FILTER_EXPRESSION = "TSDB: failed parsing labels" HEXPIRE_NUMFIELDS_DIFFERENT = "The `numfields` parameter must match the number of arguments" MISSING_ACLFILE_CONFIG = "ERR This Redis instance is not configured to use an ACL file. You may want to specify users via the ACL SETUSER command and then issue a CONFIG REWRITE (assuming you have a Redis configuration file set) in order to store users in the Redis configuration." NO_PERMISSION_ERROR = "NOPERM User {} has no permissions to run the '{}' command" NO_PERMISSION_KEY_ERROR = "NOPERM No permissions to access a key" NO_PERMISSION_CHANNEL_ERROR = "NOPERM No permissions to access a channel" # Command flags FLAG_NO_SCRIPT = "s" # Command not allowed in scripts FLAG_LEAVE_EMPTY_VAL = "v" FLAG_TRANSACTION = "t" FLAG_DO_NOT_CREATE = "i" FLAG_SKIP_CONVERT_TO_RESP2 = "2" fakeredis-2.31.0/fakeredis/_server.py0000644000000000000000000000752713615410400014441 0ustar00import logging import threading import time import weakref from collections import defaultdict from typing import Dict, Tuple, Any, List, Optional, Union import redis from fakeredis.model import AccessControlList from fakeredis._helpers import Database, FakeSelector from fakeredis.typing import VersionType, ServerType LOGGER = logging.getLogger("fakeredis") def _create_version(v: Union[Tuple[int, ...], int, str]) -> VersionType: if isinstance(v, tuple): return v if isinstance(v, int): return (v,) if isinstance(v, str): v_split = v.split(".") return tuple(int(x) for x in v_split) return v def _version_to_str(v: VersionType) -> str: if isinstance(v, tuple): return ".".join(str(x) for x in v) return str(v) class FakeServer: _servers_map: Dict[str, "FakeServer"] = dict() def __init__( self, version: VersionType = (7,), server_type: ServerType = "redis", config: Optional[Dict[bytes, bytes]] = None, ) -> None: """Initialize a new FakeServer instance. :param version: The version of the server (e.g. 6, 7.4, "7.4.1", can also be a tuple) :param server_type: The type of server (redis, dragonfly, valkey) :param config: A dictionary of configuration options. Configuration options: - `requirepass`: The password required to authenticate to the server. - `aclfile`: The path to the ACL file. """ self.lock = threading.Lock() self.dbs: Dict[int, Database] = defaultdict(lambda: Database(self.lock)) # Maps channel/pattern to a weak set of sockets self.subscribers: Dict[bytes, weakref.WeakSet[Any]] = defaultdict(weakref.WeakSet) self.psubscribers: Dict[bytes, weakref.WeakSet[Any]] = defaultdict(weakref.WeakSet) self.ssubscribers: Dict[bytes, weakref.WeakSet[Any]] = defaultdict(weakref.WeakSet) self.lastsave: int = int(time.time()) self.connected = True # List of weakrefs to sockets that are being closed lazily self.sockets: List[Any] = [] self.closed_sockets: List[Any] = [] self.version: VersionType = _create_version(version) if server_type not in ("redis", "dragonfly", "valkey"): raise ValueError(f"Unsupported server type: {server_type}") self.server_type: str = server_type self.config: Dict[bytes, bytes] = config or dict() self.acl: AccessControlList = AccessControlList() @staticmethod def get_server(key: str, version: VersionType, server_type: ServerType) -> "FakeServer": if key not in FakeServer._servers_map: FakeServer._servers_map[key] = FakeServer(version=version, server_type=server_type) return FakeServer._servers_map[key] class FakeBaseConnectionMixin(object): def __init__( self, *args: Any, version: VersionType = (7, 0), server_type: ServerType = "redis", **kwargs: Any ) -> None: self.client_name: Optional[str] = None self.server_key: str self._sock = None self._selector: Optional[FakeSelector] = None self._server = kwargs.pop("server", None) self._client_class = kwargs.pop("client_class", redis.Redis) self._lua_modules = kwargs.pop("lua_modules", set()) path = kwargs.pop("path", None) connected = kwargs.pop("connected", True) if self._server is None: if path: self.server_key = path else: host, port = kwargs.get("host"), kwargs.get("port") self.server_key = f"{host}:{port}" self.server_key += f":{server_type}:v{_version_to_str(version)[0]}" self._server = FakeServer.get_server(self.server_key, server_type=server_type, version=version) self._server.connected = connected super().__init__(*args, **kwargs) fakeredis-2.31.0/fakeredis/_tcp_server.py0000644000000000000000000001013013615410400015267 0ustar00import logging from dataclasses import dataclass from itertools import count from socketserver import ThreadingTCPServer, StreamRequestHandler from typing import BinaryIO, Dict, Tuple, Any from fakeredis import FakeRedis from fakeredis import FakeServer from fakeredis.typing import VersionType, ServerType LOGGER = logging.getLogger("fakeredis") LOGGER.setLevel(logging.DEBUG) def to_bytes(value) -> bytes: if isinstance(value, bytes): return value return str(value).encode() @dataclass class Client: connection: FakeRedis client_address: int @dataclass class Reader: reader: BinaryIO def load(self) -> Any: line = self.reader.readline().strip() match line[0:1], line[1:]: case b"*", length: length = int(length) array = [None] * length for i in range(length): array[i] = self.load() return array case b"$", length: bulk_string = self.reader.read(int(length) + 2).strip() if len(bulk_string) != int(length): raise ValueError() return bulk_string case b":", value: return int(value) case b"+", value: return value case b"-", value: return Exception(value) case _: return None @dataclass class Writer: writer: BinaryIO def dump(self, value: Any, dump_bulk=False) -> None: if isinstance(value, int): self.writer.write(f":{value}\r\n".encode()) elif isinstance(value, (str, bytes)): value = to_bytes(value) if dump_bulk or b"\r" in value or b"\n" in value: self.writer.write(b"$" + str(len(value)).encode() + b"\r\n" + value + b"\r\n") else: self.writer.write(b"+" + value + b"\r\n") elif isinstance(value, (list, set)): self.writer.write(f"*{len(value)}\r\n".encode()) for item in value: self.dump(item, dump_bulk=True) elif value is None: self.writer.write("$-1\r\n".encode()) elif isinstance(value, Exception): self.writer.write(f"-{value.args[0]}\r\n".encode()) class TCPFakeRequestHandler(StreamRequestHandler): def setup(self) -> None: super().setup() if self.client_address in self.server.clients: self.current_client = self.server.clients[self.client_address] else: self.current_client = Client( connection=FakeRedis(server=self.server.fake_server), client_address=self.client_address, ) self.reader = Reader(self.rfile) self.writer = Writer(self.wfile) self.server.clients[self.client_address] = self.current_client def handle(self): while True: try: self.data = self.reader.load() LOGGER.debug(f">>> {self.client_address[0]}: {self.data}") res = self.current_client.connection.execute_command(*self.data) LOGGER.debug(f"<<< {self.client_address[0]}: {res}") self.writer.dump(res) except Exception as e: LOGGER.debug(f"!!! {self.client_address[0]}: {e}") self.writer.dump(e) break def finish(self) -> None: del self.server.clients[self.current_client.client_address] super().finish() class TcpFakeServer(ThreadingTCPServer): def __init__( self, server_address: Tuple[str | bytes | bytearray, int], bind_and_activate: bool = True, server_type: ServerType = "redis", server_version: VersionType = (8, 0), ): super().__init__(server_address, TCPFakeRequestHandler, bind_and_activate) self.fake_server = FakeServer(server_type=server_type, version=server_version) self.client_ids = count(0) self.clients: Dict[int, FakeRedis] = dict() if __name__ == "__main__": server = TcpFakeServer(("localhost", 19000)) server.serve_forever() fakeredis-2.31.0/fakeredis/_valkey.py0000644000000000000000000000302213615410400014410 0ustar00from typing import Any, Dict import valkey from ._connection import FakeRedisMixin from .aioredis import FakeRedisMixin as FakeAsyncRedisMixin from .typing import Self def _validate_server_type(args_dict: Dict[str, Any]) -> None: if "server_type" in args_dict and args_dict["server_type"] != "valkey": raise ValueError("server_type must be valkey") args_dict.setdefault("server_type", "valkey") args_dict.setdefault("client_class", valkey.Valkey) class FakeValkey(FakeRedisMixin, valkey.Valkey): def __init__(self, *args: Any, **kwargs: Any) -> None: _validate_server_type(kwargs) super().__init__(*args, **kwargs) @classmethod def from_url(cls, *args: Any, **kwargs: Any) -> Self: return super().from_url(*args, **kwargs) class FakeStrictValkey(FakeRedisMixin, valkey.StrictValkey): def __init__(self, *args: Any, **kwargs: Any) -> None: _validate_server_type(kwargs) super(FakeStrictValkey, self).__init__(*args, **kwargs) @classmethod def from_url(cls, *args: Any, **kwargs: Any) -> Self: return super().from_url(*args, **kwargs) class FakeAsyncValkey(FakeAsyncRedisMixin, valkey.asyncio.Valkey): def __init__(self, *args: Any, **kwargs: Any) -> None: kwargs.setdefault("client_class", valkey.asyncio.Valkey) _validate_server_type(kwargs) super(FakeAsyncValkey, self).__init__(*args, **kwargs) @classmethod def from_url(cls, *args: Any, **kwargs: Any) -> Self: return super().from_url(*args, **kwargs) fakeredis-2.31.0/fakeredis/aioredis.py0000644000000000000000000002244313615410400014565 0ustar00from __future__ import annotations import asyncio import warnings from typing import Union, Optional, Any, Callable, Iterable, Tuple, List, Set, Sequence import redis.asyncio as redis_async from redis import ResponseError from redis.asyncio.connection import DefaultParser from . import _fakesocket from . import _helpers from . import _msgs as msgs from ._helpers import SimpleError, convert_args_to_redis_init_kwargs from ._server import FakeBaseConnectionMixin, VersionType, FakeServer, ServerType from .typing import async_timeout, Self class AsyncFakeSocket(_fakesocket.FakeSocket): _connection_error_class = redis_async.ConnectionError def __init__(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) self.responses: asyncio.Queue = asyncio.Queue() # type:ignore def _decode_error(self, error: SimpleError) -> ResponseError: parser = DefaultParser(1) return parser.parse_error(error.value) def put_response(self, msg: Any) -> None: if not self.responses: return self.responses.put_nowait(msg) async def _async_blocking( self, timeout: Optional[Union[float, int]], func: Callable[[bool], Any], event: asyncio.Event, callback: Callable[[], None], ) -> None: result = None try: async with async_timeout(timeout if timeout else None): while True: await event.wait() event.clear() # This is a coroutine outside the normal control flow that # locks the server, so we have to take our own lock. with self._server.lock: ret = func(False) if ret is not None: result = self._decode_result(ret) break except asyncio.TimeoutError: pass finally: with self._server.lock: self._db.remove_change_callback(callback) self.put_response(result) self.resume() def _blocking( self, timeout: Optional[Union[float, int]], func: Callable[[bool], None], ) -> Any: loop = asyncio.get_event_loop() ret = func(True) if ret is not None or self._in_transaction: return ret event = asyncio.Event() def callback() -> None: loop.call_soon_threadsafe(event.set) self._db.add_change_callback(callback) self.pause() loop.create_task(self._async_blocking(timeout, func, event, callback)) return _helpers.NoResponse() class FakeReader: def __init__(self, socket: AsyncFakeSocket) -> None: self._socket = socket async def read(self, _: int) -> bytes: return await self._socket.responses.get() # type:ignore def at_eof(self) -> bool: return self._socket.responses.empty() and not self._socket._server.connected class FakeWriter: def __init__(self, socket: AsyncFakeSocket) -> None: self._socket: Optional[AsyncFakeSocket] = socket def close(self) -> None: self._socket = None async def wait_closed(self) -> None: pass async def drain(self) -> None: pass def writelines(self, data: Iterable[Any]) -> None: if self._socket is None: return for chunk in data: self._socket.sendall(chunk) # type:ignore class FakeConnection(FakeBaseConnectionMixin, redis_async.Connection): async def _connect(self) -> None: if not self._server.connected: raise redis_async.ConnectionError(msgs.CONNECTION_ERROR_MSG) self._sock: Optional[AsyncFakeSocket] = AsyncFakeSocket( self._server, self.db, client_class=self._client_class, lua_modules=self._lua_modules ) self._reader: Optional[FakeReader] = FakeReader(self._sock) self._writer: Optional[FakeWriter] = FakeWriter(self._sock) async def disconnect(self, nowait: bool = False, **kwargs: Any) -> None: await super().disconnect(**kwargs) self._sock = None async def can_read(self, timeout: Optional[float] = 0) -> bool: if not self.is_connected: await self.connect() if timeout == 0: return self._sock is not None and not self._sock.responses.empty() # asyncio.Queue doesn't have a way to wait for the queue to be # non-empty without consuming an item, so kludge it with a sleep/poll # loop. loop = asyncio.get_event_loop() start = loop.time() while True: if self._sock and not self._sock.responses.empty(): return True await asyncio.sleep(0.01) now = loop.time() if timeout is not None and now > start + timeout: return False async def _get_from_local_cache(self, command: Sequence[str]) -> None: return None def _add_to_local_cache(self, command: Sequence[str], response: Any, keys: List[Any]) -> None: return None def _decode(self, response: Any) -> Any: if isinstance(response, list): return [self._decode(item) for item in response] elif isinstance(response, bytes): return self.encoder.decode(response) else: return response async def read_response(self, **kwargs: Any) -> Any: # type: ignore if not self._sock: raise redis_async.ConnectionError(msgs.CONNECTION_ERROR_MSG) if not self._server.connected: try: response = self._sock.responses.get_nowait() except asyncio.QueueEmpty: if kwargs.get("disconnect_on_error", True): await self.disconnect() raise redis_async.ConnectionError(msgs.CONNECTION_ERROR_MSG) else: timeout: Optional[float] = kwargs.pop("timeout", None) can_read = await self.can_read(timeout) response = await self._reader.read(0) if can_read and self._reader else None if isinstance(response, redis_async.ResponseError): raise response if kwargs.get("disable_decoding", False): return response return self._decode(response) def repr_pieces(self) -> List[Tuple[str, Any]]: pieces = [("server", self._server), ("db", self.db)] if self.client_name: pieces.append(("client_name", self.client_name)) return pieces def __str__(self) -> str: return self.server_key class FakeRedisMixin: def __init__( self, *args: Any, server: Optional[FakeServer] = None, version: Union[VersionType, str, int] = (7,), # https://github.com/cunla/fakeredis-py/issues/401 server_type: ServerType = "redis", lua_modules: Optional[Set[str]] = None, client_class=redis_async.Redis, **kwargs: Any, ) -> None: kwds = convert_args_to_redis_init_kwargs(client_class, *args, **kwargs) kwds["server"] = server kwds["connected"] = kwargs.get("connected", True) if not kwds.get("connection_pool", None): charset = kwds.get("charset", None) errors = kwds.get("errors", None) # Adapted from redis-py if charset is not None: warnings.warn(DeprecationWarning('"charset" is deprecated. Use "encoding" instead')) kwds["encoding"] = charset if errors is not None: warnings.warn(DeprecationWarning('"errors" is deprecated. Use "encoding_errors" instead')) kwds["encoding_errors"] = errors conn_pool_args = { "host", "port", "db", "username", "password", "socket_timeout", "encoding", "encoding_errors", "decode_responses", "retry_on_timeout", "max_connections", "health_check_interval", "client_name", "connected", "server", } connection_kwargs = { "connection_class": FakeConnection, "version": version, "server_type": server_type, "lua_modules": lua_modules, } connection_kwargs.update({arg: kwds[arg] for arg in conn_pool_args if arg in kwds}) kwds["connection_pool"] = redis_async.connection.ConnectionPool(**connection_kwargs) # type: ignore kwds.pop("server", None) kwds.pop("connected", None) kwds.pop("version", None) kwds.pop("server_type", None) kwds.pop("lua_modules", None) super().__init__(**kwds) @classmethod def from_url(cls, url: str, **kwargs: Any) -> Self: self: redis_async.Redis = super().from_url(url, **kwargs) pool = self.connection_pool # Now override how it creates connections pool.connection_class = FakeConnection pool.connection_kwargs.setdefault("version", "7.4") pool.connection_kwargs.setdefault("server_type", "redis") pool.connection_kwargs.pop("username", None) pool.connection_kwargs.pop("password", None) return self class FakeRedis(FakeRedisMixin, redis_async.Redis): pass fakeredis-2.31.0/fakeredis/commands.json0000644000000000000000000013031513615410400015106 0ustar00{"acl cat": ["acl|cat", -2, ["noscript", "loading", "stale"], 0, 0, 0, ["@slow"], [], [], []], "acl": ["acl", -1, [], 0, 0, 0, [], [], [], [["acl|cat", -2, ["noscript", "loading", "stale"], 0, 0, 0, ["@slow"], [], [], []], ["acl|deluser", -3, ["admin", "noscript", "loading", "stale"], 0, 0, 0, ["@admin", "@slow", "@dangerous"], [], [], []], ["acl|genpass", -2, ["noscript", "loading", "stale"], 0, 0, 0, ["@slow"], [], [], []], ["acl|getuser", 3, ["admin", "noscript", "loading", "stale"], 0, 0, 0, ["@admin", "@slow", "@dangerous"], [], [], []], ["acl|list", 2, ["admin", "noscript", "loading", "stale"], 0, 0, 0, ["@admin", "@slow", "@dangerous"], [], [], []], ["acl|load", 2, ["admin", "noscript", "loading", "stale"], 0, 0, 0, ["@admin", "@slow", "@dangerous"], [], [], []], ["acl|log", -2, ["admin", "noscript", "loading", "stale"], 0, 0, 0, ["@admin", "@slow", "@dangerous"], [], [], []], ["acl|save", 2, ["admin", "noscript", "loading", "stale"], 0, 0, 0, ["@admin", "@slow", "@dangerous"], [], [], []], ["acl|setuser", -3, ["admin", "noscript", "loading", "stale"], 0, 0, 0, ["@admin", "@slow", "@dangerous"], [], [], []], ["acl|users", 2, ["admin", "noscript", "loading", "stale"], 0, 0, 0, ["@admin", "@slow", "@dangerous"], [], [], []], ["acl|whoami", 2, ["noscript", "loading", "stale"], 0, 0, 0, ["@slow"], [], [], []]]], "acl deluser": ["acl|deluser", -3, ["admin", "noscript", "loading", "stale"], 0, 0, 0, ["@admin", "@slow", "@dangerous"], [], [], []], "acl genpass": ["acl|genpass", -2, ["noscript", "loading", "stale"], 0, 0, 0, ["@slow"], [], [], []], "acl getuser": ["acl|getuser", 3, ["admin", "noscript", "loading", "stale"], 0, 0, 0, ["@admin", "@slow", "@dangerous"], [], [], []], "acl list": ["acl|list", 2, ["admin", "noscript", "loading", "stale"], 0, 0, 0, ["@admin", "@slow", "@dangerous"], [], [], []], "acl load": ["acl|load", 2, ["admin", "noscript", "loading", "stale"], 0, 0, 0, ["@admin", "@slow", "@dangerous"], [], [], []], "acl log": ["acl|log", -2, ["admin", "noscript", "loading", "stale"], 0, 0, 0, ["@admin", "@slow", "@dangerous"], [], [], []], "acl save": ["acl|save", 2, ["admin", "noscript", "loading", "stale"], 0, 0, 0, ["@admin", "@slow", "@dangerous"], [], [], []], "acl setuser": ["acl|setuser", -3, ["admin", "noscript", "loading", "stale"], 0, 0, 0, ["@admin", "@slow", "@dangerous"], [], [], []], "acl users": ["acl|users", 2, ["admin", "noscript", "loading", "stale"], 0, 0, 0, ["@admin", "@slow", "@dangerous"], [], [], []], "acl whoami": ["acl|whoami", 2, ["noscript", "loading", "stale"], 0, 0, 0, ["@slow"], [], [], []], "append": ["append", 3, ["write", "denyoom", "fast"], 1, 1, 1, ["@fast", "@string", "@write"], [], [], []], "auth": ["auth", -2, ["noscript", "loading", "stale", "fast", "no_auth", "allow_busy"], 0, 0, 0, ["@fast", "@connection"], [], [], []], "bgsave": ["bgsave", -1, ["admin", "noscript", "no_async_loading"], 0, 0, 0, ["@admin", "@slow", "@dangerous"], [], [], []], "bitcount": ["bitcount", -2, ["readonly"], 1, 1, 1, ["@read", "@slow", "@bitmap"], [], [], []], "bitfield": ["bitfield", -2, ["write", "denyoom"], 1, 1, 1, ["@bitmap", "@slow", "@write"], [], [], [["bitfield_ro", -2, ["readonly", "fast"], 1, 1, 1, ["@fast", "@read", "@bitmap"], [], [], []]]], "bitop": ["bitop", -4, ["write", "denyoom"], 2, 3, 1, ["@bitmap", "@slow", "@write"], [], [], []], "bitpos": ["bitpos", -3, ["readonly"], 1, 1, 1, ["@read", "@slow", "@bitmap"], [], [], []], "blmove": ["blmove", 6, ["write", "denyoom", "blocking"], 1, 2, 1, ["@list", "@blocking", "@slow", "@write"], [], [], []], "blmpop": ["blmpop", -5, ["write", "blocking", "movablekeys"], 2, 2, 1, ["@list", "@blocking", "@slow", "@write"], [], [], []], "blpop": ["blpop", -3, ["write", "blocking"], 1, 1, 1, ["@list", "@blocking", "@slow", "@write"], [], [], []], "brpop": ["brpop", -3, ["write", "blocking"], 1, 1, 1, ["@list", "@blocking", "@slow", "@write"], [], [], [["brpoplpush", 4, ["write", "denyoom", "blocking"], 1, 2, 1, ["@list", "@blocking", "@slow", "@write"], [], [], []]]], "brpoplpush": ["brpoplpush", 4, ["write", "denyoom", "blocking"], 1, 2, 1, ["@list", "@blocking", "@slow", "@write"], [], [], []], "bzmpop": ["bzmpop", -5, ["write", "blocking", "movablekeys"], 2, 2, 1, ["@blocking", "@sortedset", "@slow", "@write"], [], [], []], "bzpopmax": ["bzpopmax", -3, ["write", "blocking", "fast"], 1, 1, 1, ["@blocking", "@fast", "@sortedset", "@write"], [], [], []], "bzpopmin": ["bzpopmin", -3, ["write", "blocking", "fast"], 1, 1, 1, ["@blocking", "@fast", "@sortedset", "@write"], [], [], []], "client getname": ["client|getname", 2, ["noscript", "loading", "stale"], 0, 0, 0, ["@connection", "@slow"], [], [], []], "client": ["client", -1, [], 0, 0, 0, [], [], [], [["client|getname", 2, ["noscript", "loading", "stale"], 0, 0, 0, ["@connection", "@slow"], [], [], []], ["client|id", 2, ["noscript", "loading", "stale"], 0, 0, 0, ["@connection", "@slow"], [], [], []], ["client|info", 2, ["noscript", "loading", "stale"], 0, 0, 0, ["@connection", "@slow"], [], [], []], ["client|list", -2, ["admin", "noscript", "loading", "stale"], 0, 0, 0, ["@admin", "@connection", "@slow", "@dangerous"], [], [], []], ["client|setinfo", 4, ["noscript", "loading", "stale"], 0, 0, 0, ["@connection", "@slow"], [], [], []], ["client|setname", 3, ["noscript", "loading", "stale"], 0, 0, 0, ["@connection", "@slow"], [], [], []]]], "client id": ["client|id", 2, ["noscript", "loading", "stale"], 0, 0, 0, ["@connection", "@slow"], [], [], []], "client info": ["client|info", 2, ["noscript", "loading", "stale"], 0, 0, 0, ["@connection", "@slow"], [], [], []], "client list": ["client|list", -2, ["admin", "noscript", "loading", "stale"], 0, 0, 0, ["@admin", "@connection", "@slow", "@dangerous"], [], [], []], "client setinfo": ["client|setinfo", 4, ["noscript", "loading", "stale"], 0, 0, 0, ["@connection", "@slow"], [], [], []], "client setname": ["client|setname", 3, ["noscript", "loading", "stale"], 0, 0, 0, ["@connection", "@slow"], [], [], []], "command": ["command", -1, ["loading", "stale"], 0, 0, 0, ["@connection", "@slow"], [], [], [["command|count", 2, ["loading", "stale"], 0, 0, 0, ["@connection", "@slow"], [], [], []], ["command|docs", -2, ["loading", "stale"], 0, 0, 0, ["@connection", "@slow"], [], [], []], ["command|getkeys", -3, ["loading", "stale"], 0, 0, 0, ["@connection", "@slow"], [], [], [["command|getkeysandflags", -3, ["loading", "stale"], 0, 0, 0, ["@connection", "@slow"], [], [], []]]], ["command|getkeysandflags", -3, ["loading", "stale"], 0, 0, 0, ["@connection", "@slow"], [], [], []], ["command|help", 2, ["loading", "stale"], 0, 0, 0, ["@connection", "@slow"], [], [], []], ["command|info", -2, ["loading", "stale"], 0, 0, 0, ["@connection", "@slow"], [], [], []], ["command|list", -2, ["loading", "stale"], 0, 0, 0, ["@connection", "@slow"], [], [], []], ["command|count", 2, ["loading", "stale"], 0, 0, 0, ["@connection", "@slow"], [], [], []], ["command|info", -2, ["loading", "stale"], 0, 0, 0, ["@connection", "@slow"], [], [], []]]], "command count": ["command|count", 2, ["loading", "stale"], 0, 0, 0, ["@connection", "@slow"], [], [], []], "command info": ["command|info", -2, ["loading", "stale"], 0, 0, 0, ["@connection", "@slow"], [], [], []], "config set": ["config|set", -4, ["admin", "noscript", "loading", "stale"], 0, 0, 0, ["@admin", "@slow", "@dangerous"], [], [], []], "config": ["config", -1, [], 0, 0, 0, [], [], [], [["config|set", -4, ["admin", "noscript", "loading", "stale"], 0, 0, 0, ["@admin", "@slow", "@dangerous"], [], [], []]]], "copy": ["copy", -3, ["write", "denyoom"], 1, 2, 1, ["@keyspace", "@slow", "@write"], [], [], []], "dbsize": ["dbsize", 1, ["readonly", "fast"], 0, 0, 0, ["@keyspace", "@fast", "@read"], [], [], []], "decr": ["decr", 2, ["write", "denyoom", "fast"], 1, 1, 1, ["@fast", "@string", "@write"], [], [], [["decrby", 3, ["write", "denyoom", "fast"], 1, 1, 1, ["@fast", "@string", "@write"], [], [], []]]], "decrby": ["decrby", 3, ["write", "denyoom", "fast"], 1, 1, 1, ["@fast", "@string", "@write"], [], [], []], "del": ["del", -2, ["write"], 1, 1, 1, ["@keyspace", "@slow", "@write"], [], [], []], "discard": ["discard", 1, ["noscript", "loading", "stale", "fast", "allow_busy"], 0, 0, 0, ["@transaction", "@fast"], [], [], []], "dump": ["dump", 2, ["readonly"], 1, 1, 1, ["@keyspace", "@read", "@slow"], [], [], []], "echo": ["echo", 2, ["loading", "stale", "fast"], 0, 0, 0, ["@fast", "@connection"], [], [], []], "eval": ["eval", -3, ["noscript", "stale", "skip_monitor", "no_mandatory_keys", "movablekeys"], 2, 2, 1, ["@scripting", "@slow"], [], [], [["evalsha", -3, ["noscript", "stale", "skip_monitor", "no_mandatory_keys", "movablekeys"], 2, 2, 1, ["@scripting", "@slow"], [], [], [["evalsha_ro", -3, ["readonly", "noscript", "stale", "skip_monitor", "no_mandatory_keys", "movablekeys"], 2, 2, 1, ["@scripting", "@slow"], [], [], []]]], ["evalsha_ro", -3, ["readonly", "noscript", "stale", "skip_monitor", "no_mandatory_keys", "movablekeys"], 2, 2, 1, ["@scripting", "@slow"], [], [], []], ["eval_ro", -3, ["readonly", "noscript", "stale", "skip_monitor", "no_mandatory_keys", "movablekeys"], 2, 2, 1, ["@scripting", "@slow"], [], [], []]]], "evalsha": ["evalsha", -3, ["noscript", "stale", "skip_monitor", "no_mandatory_keys", "movablekeys"], 2, 2, 1, ["@scripting", "@slow"], [], [], [["evalsha_ro", -3, ["readonly", "noscript", "stale", "skip_monitor", "no_mandatory_keys", "movablekeys"], 2, 2, 1, ["@scripting", "@slow"], [], [], []]]], "exec": ["exec", 1, ["noscript", "loading", "stale", "skip_slowlog"], 0, 0, 0, ["@transaction", "@slow"], [], [], []], "exists": ["exists", -2, ["readonly", "fast"], 1, 1, 1, ["@keyspace", "@fast", "@read"], [], [], []], "expire": ["expire", -3, ["write", "fast"], 1, 1, 1, ["@keyspace", "@fast", "@write"], [], [], [["expireat", -3, ["write", "fast"], 1, 1, 1, ["@keyspace", "@fast", "@write"], [], [], []], ["expiretime", 2, ["readonly", "fast"], 1, 1, 1, ["@keyspace", "@fast", "@read"], [], [], []]]], "expireat": ["expireat", -3, ["write", "fast"], 1, 1, 1, ["@keyspace", "@fast", "@write"], [], [], []], "expiretime": ["expiretime", 2, ["readonly", "fast"], 1, 1, 1, ["@keyspace", "@fast", "@read"], [], [], []], "flushall": ["flushall", -1, ["write"], 0, 0, 0, ["@keyspace", "@dangerous", "@slow", "@write"], [], [], []], "flushdb": ["flushdb", -1, ["write"], 0, 0, 0, ["@keyspace", "@dangerous", "@slow", "@write"], [], [], []], "geoadd": ["geoadd", -5, ["write", "denyoom"], 1, 1, 1, ["@geo", "@slow", "@write"], [], [], []], "geodist": ["geodist", -4, ["readonly"], 1, 1, 1, ["@read", "@slow", "@geo"], [], [], []], "geohash": ["geohash", -2, ["readonly"], 1, 1, 1, ["@read", "@slow", "@geo"], [], [], []], "geopos": ["geopos", -2, ["readonly"], 1, 1, 1, ["@read", "@slow", "@geo"], [], [], []], "georadius": ["georadius", -6, ["write", "denyoom", "movablekeys"], 1, 0, 1, ["@geo", "@slow", "@write"], [], [], [["georadiusbymember", -5, ["write", "denyoom", "movablekeys"], 1, 0, 1, ["@geo", "@slow", "@write"], [], [], [["georadiusbymember_ro", -5, ["readonly"], 1, 1, 1, ["@read", "@slow", "@geo"], [], [], []]]], ["georadiusbymember_ro", -5, ["readonly"], 1, 1, 1, ["@read", "@slow", "@geo"], [], [], []], ["georadius_ro", -6, ["readonly"], 1, 1, 1, ["@read", "@slow", "@geo"], [], [], []]]], "georadiusbymember": ["georadiusbymember", -5, ["write", "denyoom", "movablekeys"], 1, 0, 1, ["@geo", "@slow", "@write"], [], [], [["georadiusbymember_ro", -5, ["readonly"], 1, 1, 1, ["@read", "@slow", "@geo"], [], [], []]]], "georadiusbymember_ro": ["georadiusbymember_ro", -5, ["readonly"], 1, 1, 1, ["@read", "@slow", "@geo"], [], [], []], "georadius_ro": ["georadius_ro", -6, ["readonly"], 1, 1, 1, ["@read", "@slow", "@geo"], [], [], []], "geosearch": ["geosearch", -7, ["readonly"], 1, 1, 1, ["@read", "@slow", "@geo"], [], [], [["geosearchstore", -8, ["write", "denyoom"], 1, 2, 1, ["@geo", "@slow", "@write"], [], [], []]]], "geosearchstore": ["geosearchstore", -8, ["write", "denyoom"], 1, 2, 1, ["@geo", "@slow", "@write"], [], [], []], "get": ["get", 2, ["readonly", "fast"], 1, 1, 1, ["@fast", "@read", "@string"], [], [], [["getbit", 3, ["readonly", "fast"], 1, 1, 1, ["@fast", "@read", "@bitmap"], [], [], []], ["getdel", 2, ["write", "fast"], 1, 1, 1, ["@fast", "@string", "@write"], [], [], []], ["getex", -2, ["write", "fast"], 1, 1, 1, ["@fast", "@string", "@write"], [], [], []], ["getrange", 4, ["readonly"], 1, 1, 1, ["@read", "@string", "@slow"], [], [], []], ["getset", 3, ["write", "denyoom", "fast"], 1, 1, 1, ["@fast", "@string", "@write"], [], [], []]]], "getbit": ["getbit", 3, ["readonly", "fast"], 1, 1, 1, ["@fast", "@read", "@bitmap"], [], [], []], "getdel": ["getdel", 2, ["write", "fast"], 1, 1, 1, ["@fast", "@string", "@write"], [], [], []], "getex": ["getex", -2, ["write", "fast"], 1, 1, 1, ["@fast", "@string", "@write"], [], [], []], "getrange": ["getrange", 4, ["readonly"], 1, 1, 1, ["@read", "@string", "@slow"], [], [], []], "getset": ["getset", 3, ["write", "denyoom", "fast"], 1, 1, 1, ["@fast", "@string", "@write"], [], [], []], "hdel": ["hdel", -3, ["write", "fast"], 1, 1, 1, ["@hash", "@fast", "@write"], [], [], []], "hello": ["hello", -1, ["noscript", "loading", "stale", "fast", "no_auth", "allow_busy"], 0, 0, 0, ["@fast", "@connection"], [], [], []], "hexists": ["hexists", 3, ["readonly", "fast"], 1, 1, 1, ["@hash", "@fast", "@read"], [], [], []], "hexpire": ["hexpire", -5, ["write", "denyoom", "fast"], 1, 1, 1, ["@hash", "@fast", "@write"], [], [], [["hexpireat", -5, ["write", "denyoom", "fast"], 1, 1, 1, ["@hash", "@fast", "@write"], [], [], []], ["hexpiretime", -4, ["readonly", "fast"], 1, 1, 1, ["@hash", "@fast", "@read"], [], [], []]]], "hexpireat": ["hexpireat", -5, ["write", "denyoom", "fast"], 1, 1, 1, ["@hash", "@fast", "@write"], [], [], []], "hexpiretime": ["hexpiretime", -4, ["readonly", "fast"], 1, 1, 1, ["@hash", "@fast", "@read"], [], [], []], "hget": ["hget", 3, ["readonly", "fast"], 1, 1, 1, ["@hash", "@fast", "@read"], [], [], [["hgetall", 2, ["readonly"], 1, 1, 1, ["@hash", "@read", "@slow"], [], [], []], ["hgetf", -5, ["write", "denyoom", "fast"], 1, 1, 1, ["@hash", "@fast", "@write"], [], [], []]]], "hgetall": ["hgetall", 2, ["readonly"], 1, 1, 1, ["@hash", "@read", "@slow"], [], [], []], "hincrby": ["hincrby", 4, ["write", "denyoom", "fast"], 1, 1, 1, ["@hash", "@fast", "@write"], [], [], [["hincrbyfloat", 4, ["write", "denyoom", "fast"], 1, 1, 1, ["@hash", "@fast", "@write"], [], [], []]]], "hincrbyfloat": ["hincrbyfloat", 4, ["write", "denyoom", "fast"], 1, 1, 1, ["@hash", "@fast", "@write"], [], [], []], "hkeys": ["hkeys", 2, ["readonly"], 1, 1, 1, ["@hash", "@read", "@slow"], [], [], []], "hlen": ["hlen", 2, ["readonly", "fast"], 1, 1, 1, ["@hash", "@fast", "@read"], [], [], []], "hmget": ["hmget", -3, ["readonly", "fast"], 1, 1, 1, ["@hash", "@fast", "@read"], [], [], []], "hmset": ["hmset", -4, ["write", "denyoom", "fast"], 1, 1, 1, ["@hash", "@fast", "@write"], [], [], []], "hpersist": ["hpersist", -4, ["readonly", "fast"], 1, 1, 1, ["@hash", "@fast", "@read"], [], [], []], "hpexpire": ["hpexpire", -5, ["write", "denyoom", "fast"], 1, 1, 1, ["@hash", "@fast", "@write"], [], [], [["hpexpireat", -5, ["write", "denyoom", "fast"], 1, 1, 1, ["@hash", "@fast", "@write"], [], [], []], ["hpexpiretime", -4, ["readonly", "fast"], 1, 1, 1, ["@hash", "@fast", "@read"], [], [], []]]], "hpexpireat": ["hpexpireat", -5, ["write", "denyoom", "fast"], 1, 1, 1, ["@hash", "@fast", "@write"], [], [], []], "hpexpiretime": ["hpexpiretime", -4, ["readonly", "fast"], 1, 1, 1, ["@hash", "@fast", "@read"], [], [], []], "hpttl": ["hpttl", -4, ["readonly", "fast"], 1, 1, 1, ["@hash", "@fast", "@read"], [], [], []], "hrandfield": ["hrandfield", -2, ["readonly"], 1, 1, 1, ["@hash", "@read", "@slow"], [], [], []], "hscan": ["hscan", -3, ["readonly"], 1, 1, 1, ["@hash", "@read", "@slow"], [], [], []], "hset": ["hset", -4, ["write", "denyoom", "fast"], 1, 1, 1, ["@hash", "@fast", "@write"], [], [], [["hsetf", -6, ["write", "denyoom", "fast"], 1, 1, 1, ["@hash", "@fast", "@write"], [], [], []], ["hsetnx", 4, ["write", "denyoom", "fast"], 1, 1, 1, ["@hash", "@fast", "@write"], [], [], []]]], "hsetnx": ["hsetnx", 4, ["write", "denyoom", "fast"], 1, 1, 1, ["@hash", "@fast", "@write"], [], [], []], "hstrlen": ["hstrlen", 3, ["readonly", "fast"], 1, 1, 1, ["@hash", "@fast", "@read"], [], [], []], "httl": ["httl", -4, ["readonly", "fast"], 1, 1, 1, ["@hash", "@fast", "@read"], [], [], []], "hvals": ["hvals", 2, ["readonly"], 1, 1, 1, ["@hash", "@read", "@slow"], [], [], []], "incr": ["incr", 2, ["write", "denyoom", "fast"], 1, 1, 1, ["@fast", "@string", "@write"], [], [], [["incrby", 3, ["write", "denyoom", "fast"], 1, 1, 1, ["@fast", "@string", "@write"], [], [], [["incrbyfloat", 3, ["write", "denyoom", "fast"], 1, 1, 1, ["@fast", "@string", "@write"], [], [], []]]], ["incrbyfloat", 3, ["write", "denyoom", "fast"], 1, 1, 1, ["@fast", "@string", "@write"], [], [], []]]], "incrby": ["incrby", 3, ["write", "denyoom", "fast"], 1, 1, 1, ["@fast", "@string", "@write"], [], [], [["incrbyfloat", 3, ["write", "denyoom", "fast"], 1, 1, 1, ["@fast", "@string", "@write"], [], [], []]]], "incrbyfloat": ["incrbyfloat", 3, ["write", "denyoom", "fast"], 1, 1, 1, ["@fast", "@string", "@write"], [], [], []], "keys": ["keys", 2, ["readonly"], 0, 0, 0, ["@keyspace", "@read", "@slow", "@dangerous"], [], [], []], "lastsave": ["lastsave", 1, ["loading", "stale", "fast"], 0, 0, 0, ["@admin", "@fast", "@dangerous"], [], [], []], "lcs": ["lcs", -3, ["readonly"], 1, 1, 1, ["@read", "@string", "@slow"], [], [], []], "lindex": ["lindex", 3, ["readonly"], 1, 1, 1, ["@list", "@read", "@slow"], [], [], []], "linsert": ["linsert", 5, ["write", "denyoom"], 1, 1, 1, ["@list", "@slow", "@write"], [], [], []], "llen": ["llen", 2, ["readonly", "fast"], 1, 1, 1, ["@list", "@fast", "@read"], [], [], []], "lmove": ["lmove", 5, ["write", "denyoom"], 1, 2, 1, ["@list", "@slow", "@write"], [], [], []], "lmpop": ["lmpop", -4, ["write", "movablekeys"], 1, 1, 1, ["@list", "@slow", "@write"], [], [], []], "lpop": ["lpop", -2, ["write", "fast"], 1, 1, 1, ["@list", "@fast", "@write"], [], [], []], "lpos": ["lpos", -3, ["readonly"], 1, 1, 1, ["@list", "@read", "@slow"], [], [], []], "lpush": ["lpush", -3, ["write", "denyoom", "fast"], 1, 1, 1, ["@list", "@fast", "@write"], [], [], [["lpushx", -3, ["write", "denyoom", "fast"], 1, 1, 1, ["@list", "@fast", "@write"], [], [], []]]], "lpushx": ["lpushx", -3, ["write", "denyoom", "fast"], 1, 1, 1, ["@list", "@fast", "@write"], [], [], []], "lrange": ["lrange", 4, ["readonly"], 1, 1, 1, ["@list", "@read", "@slow"], [], [], []], "lrem": ["lrem", 4, ["write"], 1, 1, 1, ["@list", "@slow", "@write"], [], [], []], "lset": ["lset", 4, ["write", "denyoom"], 1, 1, 1, ["@list", "@slow", "@write"], [], [], []], "ltrim": ["ltrim", 4, ["write"], 1, 1, 1, ["@list", "@slow", "@write"], [], [], []], "mget": ["mget", -2, ["readonly", "fast"], 1, 1, 1, ["@fast", "@read", "@string"], [], [], []], "move": ["move", 3, ["write", "fast"], 1, 1, 1, ["@keyspace", "@fast", "@write"], [], [], []], "mset": ["mset", -3, ["write", "denyoom"], 1, 1, 2, ["@string", "@slow", "@write"], [], [], [["msetnx", -3, ["write", "denyoom"], 1, 1, 2, ["@string", "@slow", "@write"], [], [], []]]], "msetnx": ["msetnx", -3, ["write", "denyoom"], 1, 1, 2, ["@string", "@slow", "@write"], [], [], []], "multi": ["multi", 1, ["noscript", "loading", "stale", "fast", "allow_busy"], 0, 0, 0, ["@transaction", "@fast"], [], [], []], "persist": ["persist", 2, ["write", "fast"], 1, 1, 1, ["@keyspace", "@fast", "@write"], [], [], []], "pexpire": ["pexpire", -3, ["write", "fast"], 1, 1, 1, ["@keyspace", "@fast", "@write"], [], [], [["pexpireat", -3, ["write", "fast"], 1, 1, 1, ["@keyspace", "@fast", "@write"], [], [], []], ["pexpiretime", 2, ["readonly", "fast"], 1, 1, 1, ["@keyspace", "@fast", "@read"], [], [], []]]], "pexpireat": ["pexpireat", -3, ["write", "fast"], 1, 1, 1, ["@keyspace", "@fast", "@write"], [], [], []], "pexpiretime": ["pexpiretime", 2, ["readonly", "fast"], 1, 1, 1, ["@keyspace", "@fast", "@read"], [], [], []], "pfadd": ["pfadd", -2, ["write", "denyoom", "fast"], 1, 1, 1, ["@fast", "@hyperloglog", "@write"], [], [], []], "pfcount": ["pfcount", -2, ["readonly"], 1, 1, 1, ["@read", "@hyperloglog", "@slow"], [], [], []], "pfmerge": ["pfmerge", -2, ["write", "denyoom"], 1, 2, 1, ["@hyperloglog", "@slow", "@write"], [], [], []], "ping": ["ping", -1, ["fast"], 0, 0, 0, ["@fast", "@connection"], [], [], []], "psetex": ["psetex", 4, ["write", "denyoom"], 1, 1, 1, ["@string", "@slow", "@write"], [], [], []], "psubscribe": ["psubscribe", -2, ["pubsub", "noscript", "loading", "stale"], 0, 0, 0, ["@slow", "@pubsub"], [], [], []], "pttl": ["pttl", 2, ["readonly", "fast"], 1, 1, 1, ["@keyspace", "@fast", "@read"], [], [], []], "publish": ["publish", 3, ["pubsub", "loading", "stale", "fast"], 0, 0, 0, ["@fast", "@pubsub"], [], [], []], "pubsub": ["pubsub", -2, [], 0, 0, 0, ["@slow"], [], [], [["pubsub|channels", -2, ["pubsub", "loading", "stale"], 0, 0, 0, ["@slow", "@pubsub"], [], [], []], ["pubsub|help", 2, ["loading", "stale"], 0, 0, 0, ["@slow"], [], [], []], ["pubsub|numpat", 2, ["pubsub", "loading", "stale"], 0, 0, 0, ["@slow", "@pubsub"], [], [], []], ["pubsub|numsub", -2, ["pubsub", "loading", "stale"], 0, 0, 0, ["@slow", "@pubsub"], [], [], []], ["pubsub|shardchannels", -2, ["pubsub", "loading", "stale"], 0, 0, 0, ["@slow", "@pubsub"], [], [], []], ["pubsub|shardnumsub", -2, ["pubsub", "loading", "stale"], 0, 0, 0, ["@slow", "@pubsub"], [], [], []], ["pubsub|channels", -2, ["pubsub", "loading", "stale"], 0, 0, 0, ["@slow", "@pubsub"], [], [], []], ["pubsub|help", 2, ["loading", "stale"], 0, 0, 0, ["@slow"], [], [], []], ["pubsub|numpat", 2, ["pubsub", "loading", "stale"], 0, 0, 0, ["@slow", "@pubsub"], [], [], []], ["pubsub|numsub", -2, ["pubsub", "loading", "stale"], 0, 0, 0, ["@slow", "@pubsub"], [], [], []], ["pubsub|shardchannels", -2, ["pubsub", "loading", "stale"], 0, 0, 0, ["@slow", "@pubsub"], [], [], []], ["pubsub|shardnumsub", -2, ["pubsub", "loading", "stale"], 0, 0, 0, ["@slow", "@pubsub"], [], [], []]]], "pubsub channels": ["pubsub|channels", -2, ["pubsub", "loading", "stale"], 0, 0, 0, ["@slow", "@pubsub"], [], [], []], "pubsub help": ["pubsub|help", 2, ["loading", "stale"], 0, 0, 0, ["@slow"], [], [], []], "pubsub numpat": ["pubsub|numpat", 2, ["pubsub", "loading", "stale"], 0, 0, 0, ["@slow", "@pubsub"], [], [], []], "pubsub numsub": ["pubsub|numsub", -2, ["pubsub", "loading", "stale"], 0, 0, 0, ["@slow", "@pubsub"], [], [], []], "pubsub shardchannels": ["pubsub|shardchannels", -2, ["pubsub", "loading", "stale"], 0, 0, 0, ["@slow", "@pubsub"], [], [], []], "pubsub shardnumsub": ["pubsub|shardnumsub", -2, ["pubsub", "loading", "stale"], 0, 0, 0, ["@slow", "@pubsub"], [], [], []], "punsubscribe": ["punsubscribe", -1, ["pubsub", "noscript", "loading", "stale"], 0, 0, 0, ["@slow", "@pubsub"], [], [], []], "randomkey": ["randomkey", 1, ["readonly"], 0, 0, 0, ["@keyspace", "@read", "@slow"], [], [], []], "rename": ["rename", 3, ["write"], 1, 2, 1, ["@keyspace", "@slow", "@write"], [], [], [["renamenx", 3, ["write", "fast"], 1, 2, 1, ["@keyspace", "@fast", "@write"], [], [], []]]], "renamenx": ["renamenx", 3, ["write", "fast"], 1, 2, 1, ["@keyspace", "@fast", "@write"], [], [], []], "restore": ["restore", -4, ["write", "denyoom"], 1, 1, 1, ["@keyspace", "@dangerous", "@slow", "@write"], [], [], [["restore-asking", -4, ["write", "denyoom", "asking"], 1, 1, 1, ["@keyspace", "@dangerous", "@slow", "@write"], [], [], []]]], "rpop": ["rpop", -2, ["write", "fast"], 1, 1, 1, ["@list", "@fast", "@write"], [], [], [["rpoplpush", 3, ["write", "denyoom"], 1, 2, 1, ["@list", "@slow", "@write"], [], [], []]]], "rpoplpush": ["rpoplpush", 3, ["write", "denyoom"], 1, 2, 1, ["@list", "@slow", "@write"], [], [], []], "rpush": ["rpush", -3, ["write", "denyoom", "fast"], 1, 1, 1, ["@list", "@fast", "@write"], [], [], [["rpushx", -3, ["write", "denyoom", "fast"], 1, 1, 1, ["@list", "@fast", "@write"], [], [], []]]], "rpushx": ["rpushx", -3, ["write", "denyoom", "fast"], 1, 1, 1, ["@list", "@fast", "@write"], [], [], []], "sadd": ["sadd", -3, ["write", "denyoom", "fast"], 1, 1, 1, ["@fast", "@set", "@write"], [], [], []], "save": ["save", 1, ["admin", "noscript", "no_async_loading", "no_multi"], 0, 0, 0, ["@admin", "@slow", "@dangerous"], [], [], []], "scan": ["scan", -2, ["readonly"], 0, 0, 0, ["@keyspace", "@read", "@slow"], [], [], []], "scard": ["scard", 2, ["readonly", "fast"], 1, 1, 1, ["@fast", "@set", "@read"], [], [], []], "script": ["script", -2, [], 0, 0, 0, ["@slow"], [], [], [["script|debug", 3, ["noscript"], 0, 0, 0, ["@scripting", "@slow"], [], [], []], ["script|exists", -3, ["noscript"], 0, 0, 0, ["@scripting", "@slow"], [], [], []], ["script|flush", -2, ["noscript"], 0, 0, 0, ["@scripting", "@slow"], [], [], []], ["script|help", 2, ["loading", "stale"], 0, 0, 0, ["@scripting", "@slow"], [], [], []], ["script|kill", 2, ["noscript", "allow_busy"], 0, 0, 0, ["@scripting", "@slow"], [], [], []], ["script|load", 3, ["noscript", "stale"], 0, 0, 0, ["@scripting", "@slow"], [], [], []], ["script|exists", -3, ["noscript"], 0, 0, 0, ["@scripting", "@slow"], [], [], []], ["script|flush", -2, ["noscript"], 0, 0, 0, ["@scripting", "@slow"], [], [], []], ["script|help", 2, ["loading", "stale"], 0, 0, 0, ["@scripting", "@slow"], [], [], []], ["script|load", 3, ["noscript", "stale"], 0, 0, 0, ["@scripting", "@slow"], [], [], []]]], "script exists": ["script|exists", -3, ["noscript"], 0, 0, 0, ["@scripting", "@slow"], [], [], []], "script flush": ["script|flush", -2, ["noscript"], 0, 0, 0, ["@scripting", "@slow"], [], [], []], "script help": ["script|help", 2, ["loading", "stale"], 0, 0, 0, ["@scripting", "@slow"], [], [], []], "script load": ["script|load", 3, ["noscript", "stale"], 0, 0, 0, ["@scripting", "@slow"], [], [], []], "sdiff": ["sdiff", -2, ["readonly"], 1, 1, 1, ["@set", "@read", "@slow"], [], [], [["sdiffstore", -3, ["write", "denyoom"], 1, 2, 1, ["@set", "@slow", "@write"], [], [], []]]], "sdiffstore": ["sdiffstore", -3, ["write", "denyoom"], 1, 2, 1, ["@set", "@slow", "@write"], [], [], []], "select": ["select", 2, ["loading", "stale", "fast"], 0, 0, 0, ["@fast", "@connection"], [], [], []], "set": ["set", -3, ["write", "denyoom"], 1, 1, 1, ["@string", "@slow", "@write"], [], [], [["setbit", 4, ["write", "denyoom"], 1, 1, 1, ["@bitmap", "@slow", "@write"], [], [], []], ["setex", 4, ["write", "denyoom"], 1, 1, 1, ["@string", "@slow", "@write"], [], [], []], ["setnx", 3, ["write", "denyoom", "fast"], 1, 1, 1, ["@fast", "@string", "@write"], [], [], []], ["setrange", 4, ["write", "denyoom"], 1, 1, 1, ["@string", "@slow", "@write"], [], [], []]]], "setbit": ["setbit", 4, ["write", "denyoom"], 1, 1, 1, ["@bitmap", "@slow", "@write"], [], [], []], "setex": ["setex", 4, ["write", "denyoom"], 1, 1, 1, ["@string", "@slow", "@write"], [], [], []], "setnx": ["setnx", 3, ["write", "denyoom", "fast"], 1, 1, 1, ["@fast", "@string", "@write"], [], [], []], "setrange": ["setrange", 4, ["write", "denyoom"], 1, 1, 1, ["@string", "@slow", "@write"], [], [], []], "sinter": ["sinter", -2, ["readonly"], 1, 1, 1, ["@set", "@read", "@slow"], [], [], [["sintercard", -3, ["readonly", "movablekeys"], 1, 1, 1, ["@set", "@read", "@slow"], [], [], []], ["sinterstore", -3, ["write", "denyoom"], 1, 2, 1, ["@set", "@slow", "@write"], [], [], []]]], "sintercard": ["sintercard", -3, ["readonly", "movablekeys"], 1, 1, 1, ["@set", "@read", "@slow"], [], [], []], "sinterstore": ["sinterstore", -3, ["write", "denyoom"], 1, 2, 1, ["@set", "@slow", "@write"], [], [], []], "sismember": ["sismember", 3, ["readonly", "fast"], 1, 1, 1, ["@fast", "@set", "@read"], [], [], []], "smembers": ["smembers", 2, ["readonly"], 1, 1, 1, ["@set", "@read", "@slow"], [], [], []], "smismember": ["smismember", -3, ["readonly", "fast"], 1, 1, 1, ["@fast", "@set", "@read"], [], [], []], "smove": ["smove", 4, ["write", "fast"], 1, 2, 1, ["@fast", "@set", "@write"], [], [], []], "sort": ["sort", -2, ["write", "denyoom", "movablekeys"], 1, 0, 1, ["@list", "@dangerous", "@sortedset", "@write", "@set", "@slow"], [], [], [["sort_ro", -2, ["readonly", "movablekeys"], 1, 0, 1, ["@list", "@dangerous", "@sortedset", "@read", "@set", "@slow"], [], [], []]]], "sort_ro": ["sort_ro", -2, ["readonly", "movablekeys"], 1, 0, 1, ["@list", "@dangerous", "@sortedset", "@read", "@set", "@slow"], [], [], []], "spop": ["spop", -2, ["write", "fast"], 1, 1, 1, ["@fast", "@set", "@write"], [], [], []], "spublish": ["spublish", 3, ["pubsub", "loading", "stale", "fast"], 1, 1, 1, ["@fast", "@pubsub"], [], [], []], "srandmember": ["srandmember", -2, ["readonly"], 1, 1, 1, ["@set", "@read", "@slow"], [], [], []], "srem": ["srem", -3, ["write", "fast"], 1, 1, 1, ["@fast", "@set", "@write"], [], [], []], "sscan": ["sscan", -3, ["readonly"], 1, 1, 1, ["@set", "@read", "@slow"], [], [], []], "ssubscribe": ["ssubscribe", -2, ["pubsub", "noscript", "loading", "stale"], 1, 1, 1, ["@slow", "@pubsub"], [], [], []], "strlen": ["strlen", 2, ["readonly", "fast"], 1, 1, 1, ["@fast", "@read", "@string"], [], [], []], "subscribe": ["subscribe", -2, ["pubsub", "noscript", "loading", "stale"], 0, 0, 0, ["@slow", "@pubsub"], [], [], []], "substr": ["substr", 4, ["readonly"], 1, 1, 1, ["@read", "@string", "@slow"], [], [], []], "sunion": ["sunion", -2, ["readonly"], 1, 1, 1, ["@set", "@read", "@slow"], [], [], [["sunionstore", -3, ["write", "denyoom"], 1, 2, 1, ["@set", "@slow", "@write"], [], [], []]]], "sunionstore": ["sunionstore", -3, ["write", "denyoom"], 1, 2, 1, ["@set", "@slow", "@write"], [], [], []], "sunsubscribe": ["sunsubscribe", -1, ["pubsub", "noscript", "loading", "stale"], 1, 1, 1, ["@slow", "@pubsub"], [], [], []], "swapdb": ["swapdb", 3, ["write", "fast"], 0, 0, 0, ["@keyspace", "@dangerous", "@fast", "@write"], [], [], []], "time": ["time", 1, ["loading", "stale", "fast"], 0, 0, 0, ["@fast"], [], [], []], "ttl": ["ttl", 2, ["readonly", "fast"], 1, 1, 1, ["@keyspace", "@fast", "@read"], [], [], []], "type": ["type", 2, ["readonly", "fast"], 1, 1, 1, ["@keyspace", "@fast", "@read"], [], [], []], "unlink": ["unlink", -2, ["write", "fast"], 1, 1, 1, ["@keyspace", "@fast", "@write"], [], [], []], "unsubscribe": ["unsubscribe", -1, ["pubsub", "noscript", "loading", "stale"], 0, 0, 0, ["@slow", "@pubsub"], [], [], []], "unwatch": ["unwatch", 1, ["noscript", "loading", "stale", "fast", "allow_busy"], 0, 0, 0, ["@transaction", "@fast"], [], [], []], "watch": ["watch", -2, ["noscript", "loading", "stale", "fast", "allow_busy"], 1, 1, 1, ["@transaction", "@fast"], [], [], []], "xack": ["xack", -4, ["write", "fast"], 1, 1, 1, ["@stream", "@fast", "@write"], [], [], []], "xadd": ["xadd", -5, ["write", "denyoom", "fast"], 1, 1, 1, ["@stream", "@fast", "@write"], [], [], []], "xautoclaim": ["xautoclaim", -6, ["write", "fast"], 1, 1, 1, ["@stream", "@fast", "@write"], [], [], []], "xclaim": ["xclaim", -6, ["write", "fast"], 1, 1, 1, ["@stream", "@fast", "@write"], [], [], []], "xdel": ["xdel", -3, ["write", "fast"], 1, 1, 1, ["@stream", "@fast", "@write"], [], [], []], "xgroup create": ["xgroup|create", -5, ["write", "denyoom"], 2, 2, 1, ["@stream", "@slow", "@write"], [], [], [["xgroup|createconsumer", 5, ["write", "denyoom"], 2, 2, 1, ["@stream", "@slow", "@write"], [], [], []]]], "xgroup": ["xgroup", -1, [], 0, 0, 0, [], [], [], [["xgroup|create", -5, ["write", "denyoom"], 2, 2, 1, ["@stream", "@slow", "@write"], [], [], [["xgroup|createconsumer", 5, ["write", "denyoom"], 2, 2, 1, ["@stream", "@slow", "@write"], [], [], []]]], ["xgroup|createconsumer", 5, ["write", "denyoom"], 2, 2, 1, ["@stream", "@slow", "@write"], [], [], []], ["xgroup|delconsumer", 5, ["write"], 2, 2, 1, ["@stream", "@slow", "@write"], [], [], []], ["xgroup|destroy", 4, ["write"], 2, 2, 1, ["@stream", "@slow", "@write"], [], [], []], ["xgroup|setid", -5, ["write"], 2, 2, 1, ["@stream", "@slow", "@write"], [], [], []]]], "xgroup createconsumer": ["xgroup|createconsumer", 5, ["write", "denyoom"], 2, 2, 1, ["@stream", "@slow", "@write"], [], [], []], "xgroup delconsumer": ["xgroup|delconsumer", 5, ["write"], 2, 2, 1, ["@stream", "@slow", "@write"], [], [], []], "xgroup destroy": ["xgroup|destroy", 4, ["write"], 2, 2, 1, ["@stream", "@slow", "@write"], [], [], []], "xgroup setid": ["xgroup|setid", -5, ["write"], 2, 2, 1, ["@stream", "@slow", "@write"], [], [], []], "xinfo consumers": ["xinfo|consumers", 4, ["readonly"], 2, 2, 1, ["@stream", "@read", "@slow"], [], [], []], "xinfo": ["xinfo", -1, [], 0, 0, 0, [], [], [], [["xinfo|consumers", 4, ["readonly"], 2, 2, 1, ["@stream", "@read", "@slow"], [], [], []], ["xinfo|groups", 3, ["readonly"], 2, 2, 1, ["@stream", "@read", "@slow"], [], [], []], ["xinfo|stream", -3, ["readonly"], 2, 2, 1, ["@stream", "@read", "@slow"], [], [], []]]], "xinfo groups": ["xinfo|groups", 3, ["readonly"], 2, 2, 1, ["@stream", "@read", "@slow"], [], [], []], "xinfo stream": ["xinfo|stream", -3, ["readonly"], 2, 2, 1, ["@stream", "@read", "@slow"], [], [], []], "xlen": ["xlen", 2, ["readonly", "fast"], 1, 1, 1, ["@stream", "@fast", "@read"], [], [], []], "xpending": ["xpending", -3, ["readonly"], 1, 1, 1, ["@stream", "@read", "@slow"], [], [], []], "xrange": ["xrange", -4, ["readonly"], 1, 1, 1, ["@stream", "@read", "@slow"], [], [], []], "xread": ["xread", -4, ["readonly", "blocking", "movablekeys"], 0, 0, 1, ["@stream", "@read", "@blocking", "@slow"], [], [], [["xreadgroup", -7, ["write", "blocking", "movablekeys"], 0, 0, 1, ["@stream", "@blocking", "@slow", "@write"], [], [], []]]], "xreadgroup": ["xreadgroup", -7, ["write", "blocking", "movablekeys"], 0, 0, 1, ["@stream", "@blocking", "@slow", "@write"], [], [], []], "xrevrange": ["xrevrange", -4, ["readonly"], 1, 1, 1, ["@stream", "@read", "@slow"], [], [], []], "xtrim": ["xtrim", -4, ["write"], 1, 1, 1, ["@stream", "@slow", "@write"], [], [], []], "zadd": ["zadd", -4, ["write", "denyoom", "fast"], 1, 1, 1, ["@fast", "@sortedset", "@write"], [], [], []], "zcard": ["zcard", 2, ["readonly", "fast"], 1, 1, 1, ["@fast", "@read", "@sortedset"], [], [], []], "zcount": ["zcount", 4, ["readonly", "fast"], 1, 1, 1, ["@fast", "@read", "@sortedset"], [], [], []], "zdiff": ["zdiff", -3, ["readonly", "movablekeys"], 1, 1, 1, ["@read", "@sortedset", "@slow"], [], [], [["zdiffstore", -4, ["write", "denyoom", "movablekeys"], 1, 2, 1, ["@sortedset", "@slow", "@write"], [], [], []]]], "zdiffstore": ["zdiffstore", -4, ["write", "denyoom", "movablekeys"], 1, 2, 1, ["@sortedset", "@slow", "@write"], [], [], []], "zincrby": ["zincrby", 4, ["write", "denyoom", "fast"], 1, 1, 1, ["@fast", "@sortedset", "@write"], [], [], []], "zinter": ["zinter", -3, ["readonly", "movablekeys"], 1, 1, 1, ["@read", "@sortedset", "@slow"], [], [], [["zintercard", -3, ["readonly", "movablekeys"], 1, 1, 1, ["@read", "@sortedset", "@slow"], [], [], []], ["zinterstore", -4, ["write", "denyoom", "movablekeys"], 1, 2, 1, ["@sortedset", "@slow", "@write"], [], [], []]]], "zintercard": ["zintercard", -3, ["readonly", "movablekeys"], 1, 1, 1, ["@read", "@sortedset", "@slow"], [], [], []], "zinterstore": ["zinterstore", -4, ["write", "denyoom", "movablekeys"], 1, 2, 1, ["@sortedset", "@slow", "@write"], [], [], []], "zlexcount": ["zlexcount", 4, ["readonly", "fast"], 1, 1, 1, ["@fast", "@read", "@sortedset"], [], [], []], "zmpop": ["zmpop", -4, ["write", "movablekeys"], 1, 1, 1, ["@sortedset", "@slow", "@write"], [], [], []], "zmscore": ["zmscore", -3, ["readonly", "fast"], 1, 1, 1, ["@fast", "@read", "@sortedset"], [], [], []], "zpopmax": ["zpopmax", -2, ["write", "fast"], 1, 1, 1, ["@fast", "@sortedset", "@write"], [], [], []], "zpopmin": ["zpopmin", -2, ["write", "fast"], 1, 1, 1, ["@fast", "@sortedset", "@write"], [], [], []], "zrandmember": ["zrandmember", -2, ["readonly"], 1, 1, 1, ["@read", "@sortedset", "@slow"], [], [], []], "zrange": ["zrange", -4, ["readonly"], 1, 1, 1, ["@read", "@sortedset", "@slow"], [], [], [["zrangebylex", -4, ["readonly"], 1, 1, 1, ["@read", "@sortedset", "@slow"], [], [], []], ["zrangebyscore", -4, ["readonly"], 1, 1, 1, ["@read", "@sortedset", "@slow"], [], [], []], ["zrangestore", -5, ["write", "denyoom"], 1, 2, 1, ["@sortedset", "@slow", "@write"], [], [], []]]], "zrangebylex": ["zrangebylex", -4, ["readonly"], 1, 1, 1, ["@read", "@sortedset", "@slow"], [], [], []], "zrangebyscore": ["zrangebyscore", -4, ["readonly"], 1, 1, 1, ["@read", "@sortedset", "@slow"], [], [], []], "zrangestore": ["zrangestore", -5, ["write", "denyoom"], 1, 2, 1, ["@sortedset", "@slow", "@write"], [], [], []], "zrank": ["zrank", -3, ["readonly", "fast"], 1, 1, 1, ["@fast", "@read", "@sortedset"], [], [], []], "zrem": ["zrem", -3, ["write", "fast"], 1, 1, 1, ["@fast", "@sortedset", "@write"], [], [], [["zremrangebylex", 4, ["write"], 1, 1, 1, ["@sortedset", "@slow", "@write"], [], [], []], ["zremrangebyrank", 4, ["write"], 1, 1, 1, ["@sortedset", "@slow", "@write"], [], [], []], ["zremrangebyscore", 4, ["write"], 1, 1, 1, ["@sortedset", "@slow", "@write"], [], [], []]]], "zremrangebylex": ["zremrangebylex", 4, ["write"], 1, 1, 1, ["@sortedset", "@slow", "@write"], [], [], []], "zremrangebyrank": ["zremrangebyrank", 4, ["write"], 1, 1, 1, ["@sortedset", "@slow", "@write"], [], [], []], "zremrangebyscore": ["zremrangebyscore", 4, ["write"], 1, 1, 1, ["@sortedset", "@slow", "@write"], [], [], []], "zrevrange": ["zrevrange", -4, ["readonly"], 1, 1, 1, ["@read", "@sortedset", "@slow"], [], [], [["zrevrangebylex", -4, ["readonly"], 1, 1, 1, ["@read", "@sortedset", "@slow"], [], [], []], ["zrevrangebyscore", -4, ["readonly"], 1, 1, 1, ["@read", "@sortedset", "@slow"], [], [], []]]], "zrevrangebylex": ["zrevrangebylex", -4, ["readonly"], 1, 1, 1, ["@read", "@sortedset", "@slow"], [], [], []], "zrevrangebyscore": ["zrevrangebyscore", -4, ["readonly"], 1, 1, 1, ["@read", "@sortedset", "@slow"], [], [], []], "zrevrank": ["zrevrank", -3, ["readonly", "fast"], 1, 1, 1, ["@fast", "@read", "@sortedset"], [], [], []], "zscan": ["zscan", -3, ["readonly"], 1, 1, 1, ["@read", "@sortedset", "@slow"], [], [], []], "zscore": ["zscore", 3, ["readonly", "fast"], 1, 1, 1, ["@fast", "@read", "@sortedset"], [], [], []], "zunion": ["zunion", -3, ["readonly", "movablekeys"], 1, 1, 1, ["@read", "@sortedset", "@slow"], [], [], [["zunionstore", -4, ["write", "denyoom", "movablekeys"], 1, 2, 1, ["@sortedset", "@slow", "@write"], [], [], []]]], "zunionstore": ["zunionstore", -4, ["write", "denyoom", "movablekeys"], 1, 2, 1, ["@sortedset", "@slow", "@write"], [], [], []], "json.del": ["json.del", -1, [], 0, 0, 0, ["@json"], [], [], []], "json.forget": ["json.forget", -1, [], 0, 0, 0, ["@json"], [], [], []], "json.get": ["json.get", -1, [], 0, 0, 0, ["@json"], [], [], []], "json.toggle": ["json.toggle", -1, [], 0, 0, 0, ["@json"], [], [], []], "json.clear": ["json.clear", -1, [], 0, 0, 0, ["@json"], [], [], []], "json.set": ["json.set", -1, [], 0, 0, 0, ["@json"], [], [], []], "json.mset": ["json.mset", -1, [], 0, 0, 0, ["@json"], [], [], []], "json.merge": ["json.merge", -1, [], 0, 0, 0, ["@json"], [], [], []], "json.mget": ["json.mget", -1, [], 0, 0, 0, ["@json"], [], [], []], "json.numincrby": ["json.numincrby", -1, [], 0, 0, 0, ["@json"], [], [], []], "json.nummultby": ["json.nummultby", -1, [], 0, 0, 0, ["@json"], [], [], []], "json.strappend": ["json.strappend", -1, [], 0, 0, 0, ["@json"], [], [], []], "json.strlen": ["json.strlen", -1, [], 0, 0, 0, ["@json"], [], [], []], "json.arrappend": ["json.arrappend", -1, [], 0, 0, 0, ["@json"], [], [], []], "json.arrindex": ["json.arrindex", -1, [], 0, 0, 0, ["@json"], [], [], []], "json.arrinsert": ["json.arrinsert", -1, [], 0, 0, 0, ["@json"], [], [], []], "json.arrlen": ["json.arrlen", -1, [], 0, 0, 0, ["@json"], [], [], []], "json.arrpop": ["json.arrpop", -1, [], 0, 0, 0, ["@json"], [], [], []], "json.arrtrim": ["json.arrtrim", -1, [], 0, 0, 0, ["@json"], [], [], []], "json.objkeys": ["json.objkeys", -1, [], 0, 0, 0, ["@json"], [], [], []], "json.objlen": ["json.objlen", -1, [], 0, 0, 0, ["@json"], [], [], []], "json.type": ["json.type", -1, [], 0, 0, 0, ["@json"], [], [], []], "ts.create": ["ts.create", -1, [], 0, 0, 0, ["@timeseries"], [], [], [["ts.createrule", -1, [], 0, 0, 0, ["@timeseries"], [], [], []]]], "ts.del": ["ts.del", -1, [], 0, 0, 0, ["@timeseries"], [], [], [["ts.deleterule", -1, [], 0, 0, 0, ["@timeseries"], [], [], []]]], "ts.alter": ["ts.alter", -1, [], 0, 0, 0, ["@timeseries"], [], [], []], "ts.add": ["ts.add", -1, [], 0, 0, 0, ["@timeseries"], [], [], []], "ts.madd": ["ts.madd", -1, [], 0, 0, 0, ["@timeseries"], [], [], []], "ts.incrby": ["ts.incrby", -1, [], 0, 0, 0, ["@timeseries"], [], [], []], "ts.decrby": ["ts.decrby", -1, [], 0, 0, 0, ["@timeseries"], [], [], []], "ts.createrule": ["ts.createrule", -1, [], 0, 0, 0, ["@timeseries"], [], [], []], "ts.deleterule": ["ts.deleterule", -1, [], 0, 0, 0, ["@timeseries"], [], [], []], "ts.range": ["ts.range", -1, [], 0, 0, 0, ["@timeseries"], [], [], []], "ts.revrange": ["ts.revrange", -1, [], 0, 0, 0, ["@timeseries"], [], [], []], "ts.mrange": ["ts.mrange", -1, [], 0, 0, 0, ["@timeseries"], [], [], []], "ts.mrevrange": ["ts.mrevrange", -1, [], 0, 0, 0, ["@timeseries"], [], [], []], "ts.get": ["ts.get", -1, [], 0, 0, 0, ["@timeseries"], [], [], []], "ts.mget": ["ts.mget", -1, [], 0, 0, 0, ["@timeseries"], [], [], []], "ts.info": ["ts.info", -1, [], 0, 0, 0, ["@timeseries"], [], [], []], "ts.queryindex": ["ts.queryindex", -1, [], 0, 0, 0, ["@timeseries"], [], [], []], "bf.reserve": ["bf.reserve", -1, [], 0, 0, 0, ["@bloom"], [], [], []], "bf.add": ["bf.add", -1, [], 0, 0, 0, ["@bloom"], [], [], []], "bf.madd": ["bf.madd", -1, [], 0, 0, 0, ["@bloom"], [], [], []], "bf.insert": ["bf.insert", -1, [], 0, 0, 0, ["@bloom"], [], [], []], "bf.exists": ["bf.exists", -1, [], 0, 0, 0, ["@bloom"], [], [], []], "bf.mexists": ["bf.mexists", -1, [], 0, 0, 0, ["@bloom"], [], [], []], "bf.scandump": ["bf.scandump", -1, [], 0, 0, 0, ["@bloom"], [], [], []], "bf.loadchunk": ["bf.loadchunk", -1, [], 0, 0, 0, ["@bloom"], [], [], []], "bf.info": ["bf.info", -1, [], 0, 0, 0, ["@bloom"], [], [], []], "bf.card": ["bf.card", -1, [], 0, 0, 0, ["@bloom"], [], [], []], "cf.reserve": ["cf.reserve", -1, [], 0, 0, 0, ["@cuckoo"], [], [], []], "cf.add": ["cf.add", -1, [], 0, 0, 0, ["@cuckoo"], [], [], [["cf.addnx", -1, [], 0, 0, 0, ["@cuckoo"], [], [], []]]], "cf.addnx": ["cf.addnx", -1, [], 0, 0, 0, ["@cuckoo"], [], [], []], "cf.insert": ["cf.insert", -1, [], 0, 0, 0, ["@cuckoo"], [], [], [["cf.insertnx", -1, [], 0, 0, 0, ["@cuckoo"], [], [], []]]], "cf.insertnx": ["cf.insertnx", -1, [], 0, 0, 0, ["@cuckoo"], [], [], []], "cf.exists": ["cf.exists", -1, [], 0, 0, 0, ["@cuckoo"], [], [], []], "cf.mexists": ["cf.mexists", -1, [], 0, 0, 0, ["@cuckoo"], [], [], []], "cf.del": ["cf.del", -1, [], 0, 0, 0, ["@cuckoo"], [], [], []], "cf.count": ["cf.count", -1, [], 0, 0, 0, ["@cuckoo"], [], [], []], "cf.scandump": ["cf.scandump", -1, [], 0, 0, 0, ["@cuckoo"], [], [], []], "cf.loadchunk": ["cf.loadchunk", -1, [], 0, 0, 0, ["@cuckoo"], [], [], []], "cf.info": ["cf.info", -1, [], 0, 0, 0, ["@cuckoo"], [], [], []], "cms.initbydim": ["cms.initbydim", -1, [], 0, 0, 0, ["@cms"], [], [], []], "cms.initbyprob": ["cms.initbyprob", -1, [], 0, 0, 0, ["@cms"], [], [], []], "cms.incrby": ["cms.incrby", -1, [], 0, 0, 0, ["@cms"], [], [], []], "cms.query": ["cms.query", -1, [], 0, 0, 0, ["@cms"], [], [], []], "cms.merge": ["cms.merge", -1, [], 0, 0, 0, ["@cms"], [], [], []], "cms.info": ["cms.info", -1, [], 0, 0, 0, ["@cms"], [], [], []], "topk.reserve": ["topk.reserve", -1, [], 0, 0, 0, ["@topk"], [], [], []], "topk.add": ["topk.add", -1, [], 0, 0, 0, ["@topk"], [], [], []], "topk.incrby": ["topk.incrby", -1, [], 0, 0, 0, ["@topk"], [], [], []], "topk.query": ["topk.query", -1, [], 0, 0, 0, ["@topk"], [], [], []], "topk.count": ["topk.count", -1, [], 0, 0, 0, ["@topk"], [], [], []], "topk.list": ["topk.list", -1, [], 0, 0, 0, ["@topk"], [], [], []], "topk.info": ["topk.info", -1, [], 0, 0, 0, ["@topk"], [], [], []], "tdigest.create": ["tdigest.create", -1, [], 0, 0, 0, ["@tdigest"], [], [], []], "tdigest.reset": ["tdigest.reset", -1, [], 0, 0, 0, ["@tdigest"], [], [], []], "tdigest.add": ["tdigest.add", -1, [], 0, 0, 0, ["@tdigest"], [], [], []], "tdigest.merge": ["tdigest.merge", -1, [], 0, 0, 0, ["@tdigest"], [], [], []], "tdigest.min": ["tdigest.min", -1, [], 0, 0, 0, ["@tdigest"], [], [], []], "tdigest.max": ["tdigest.max", -1, [], 0, 0, 0, ["@tdigest"], [], [], []], "tdigest.quantile": ["tdigest.quantile", -1, [], 0, 0, 0, ["@tdigest"], [], [], []], "tdigest.cdf": ["tdigest.cdf", -1, [], 0, 0, 0, ["@tdigest"], [], [], []], "tdigest.trimmed_mean": ["tdigest.trimmed_mean", -1, [], 0, 0, 0, ["@tdigest"], [], [], []], "tdigest.rank": ["tdigest.rank", -1, [], 0, 0, 0, ["@tdigest"], [], [], []], "tdigest.revrank": ["tdigest.revrank", -1, [], 0, 0, 0, ["@tdigest"], [], [], []], "tdigest.byrank": ["tdigest.byrank", -1, [], 0, 0, 0, ["@tdigest"], [], [], []], "tdigest.byrevrank": ["tdigest.byrevrank", -1, [], 0, 0, 0, ["@tdigest"], [], [], []], "tdigest.info": ["tdigest.info", -1, [], 0, 0, 0, ["@tdigest"], [], [], []]} fakeredis-2.31.0/fakeredis/py.typed0000644000000000000000000000000013615410400014074 0ustar00fakeredis-2.31.0/fakeredis/typing.py0000644000000000000000000000163413615410400014277 0ustar00import sys import redis if sys.version_info >= (3, 11): from typing import Self, Tuple, Literal from asyncio import timeout as async_timeout else: from async_timeout import timeout as async_timeout from typing_extensions import Self from typing import Tuple, Literal try: from importlib import metadata except ImportError: # for Python < 3.8 import importlib_metadata as metadata # type: ignore lib_version = metadata.version("fakeredis") VersionType = Tuple[int, ...] ServerType = Literal["redis", "dragonfly", "valkey"] RaiseErrorTypes = (redis.ResponseError, redis.AuthenticationError) try: import valkey RaiseErrorTypes = (redis.ResponseError, redis.AuthenticationError, valkey.ResponseError, valkey.AuthenticationError) except ImportError: pass __all__ = [ "Self", "async_timeout", "VersionType", "ServerType", "lib_version", "RaiseErrorTypes", ] fakeredis-2.31.0/fakeredis/commands_mixins/__init__.py0000644000000000000000000000252013615410400017707 0ustar00from typing import Any from .acl_mixin import AclCommandsMixin from .bitmap_mixin import BitmapCommandsMixin from .connection_mixin import ConnectionCommandsMixin from .generic_mixin import GenericCommandsMixin from .geo_mixin import GeoCommandsMixin from .hash_mixin import HashCommandsMixin from .list_mixin import ListCommandsMixin from .pubsub_mixin import PubSubCommandsMixin from .server_mixin import ServerCommandsMixin from .set_mixin import SetCommandsMixin from .streams_mixin import StreamsCommandsMixin from .string_mixin import StringCommandsMixin from .transactions_mixin import TransactionsCommandsMixin try: from .scripting_mixin import ScriptingCommandsMixin except ImportError: class ScriptingCommandsMixin: # type: ignore # noqa: E303 def __init__(self, *args: Any, **kwargs: Any) -> None: kwargs.pop("lua_modules", None) super(ScriptingCommandsMixin, self).__init__(*args, **kwargs) # type: ignore __all__ = [ "BitmapCommandsMixin", "ConnectionCommandsMixin", "GenericCommandsMixin", "GeoCommandsMixin", "HashCommandsMixin", "ListCommandsMixin", "PubSubCommandsMixin", "ScriptingCommandsMixin", "TransactionsCommandsMixin", "ServerCommandsMixin", "SetCommandsMixin", "StreamsCommandsMixin", "StringCommandsMixin", "AclCommandsMixin", ] fakeredis-2.31.0/fakeredis/commands_mixins/acl_mixin.py0000644000000000000000000001645713615410400020131 0ustar00import secrets from typing import Any, List, Dict, Optional, Union from fakeredis import _msgs as msgs from fakeredis._commands import command, Int from fakeredis._helpers import SimpleError, OK, casematch, SimpleString from fakeredis.model import AccessControlList from fakeredis.model import get_categories, get_commands_by_category from fakeredis.typing import VersionType class AclCommandsMixin: def __init(self, *args: Any, **kwargs: Any) -> None: super(AclCommandsMixin).__init__(*args, **kwargs) self.version: VersionType self._server: Any self._client_info: Dict[str, Union[str, int]] @property def _server_config(self) -> Dict[bytes, bytes]: return self._server.config @property def _acl(self) -> AccessControlList: return self._server.acl def _check_user_password(self, username: bytes, password: Optional[bytes]) -> bool: return self._acl.get_user_acl(username).check_password(password) def _set_user_acl(self, username: bytes, *args: bytes) -> None: user_acl = self._acl.get_user_acl(username) for arg in args: if casematch(arg, b"resetchannels"): user_acl.reset_channels_patterns() continue elif casematch(arg, b"resetkeys"): user_acl.reset_key_patterns() continue elif casematch(arg, b"on"): user_acl.enabled = True continue elif casematch(arg, b"off"): user_acl.enabled = False continue elif casematch(arg, b"nopass"): user_acl.set_nopass() continue elif casematch(arg, b"reset"): user_acl.reset() continue elif casematch(arg, b"nocommands"): arg = b"-@all" elif casematch(arg, b"allcommands"): arg = b"+@all" elif casematch(arg, b"allkeys"): arg = b"~*" elif casematch(arg, b"allchannels"): arg = b"&*" elif arg[0] == ord("(") and arg[-1] == ord(")"): user_acl.add_selector(arg[1:-1]) continue prefix = arg[0] if prefix == ord(">"): user_acl.add_password(arg[1:]) elif prefix == ord("<"): user_acl.remove_password(arg[1:]) elif prefix == ord("#"): user_acl.add_password_hex(arg[1:]) elif prefix == ord("!"): user_acl.remove_password_hex(arg[1:]) elif prefix == ord("+") or prefix == ord("-"): user_acl.add_command_or_category(arg) elif prefix == ord("~"): user_acl.add_key_pattern(arg[1:]) elif prefix == ord("&"): user_acl.add_channel_pattern(arg[1:]) @command(name="CONFIG SET", fixed=(bytes, bytes), repeat=(bytes, bytes)) def config_set(self, *args: bytes): if len(args) % 2 != 0: raise SimpleError(msgs.WRONG_ARGS_MSG6.format("CONFIG SET")) for i in range(0, len(args), 2): self._server_config[args[i]] = args[i + 1] return OK @command(name="AUTH", fixed=(), repeat=(bytes,)) def _auth(self, *args: bytes) -> bytes: if not 1 <= len(args) <= 2: raise SimpleError(msgs.WRONG_ARGS_MSG6.format("AUTH")) username = None if len(args) == 1 else args[0] password = args[1] if len(args) == 2 else args[0] if (username is None or username == b"default") and (password == self._server_config.get(b"requirepass", b"")): self._client_info["user"] = "default" return OK username = username or b"default" if len(args) >= 1 and self._check_user_password(username, password): self._client_info["user"] = username.decode() return OK self._acl.add_log_record(b"auth", b"auth", b"AUTH", username, self.client_info_as_bytes) raise SimpleError(msgs.AUTH_FAILURE) @command(name="ACL CAT", fixed=(), repeat=(bytes,)) def acl_cat(self, *category: bytes) -> List[bytes]: if len(category) == 0: res = get_categories() else: res = get_commands_by_category(category[0]) res = [cmd.replace(b" ", b"|") for cmd in res] return res @command(name="ACL GENPASS", fixed=(), repeat=(bytes,)) def acl_genpass(self, *args: bytes) -> bytes: bits = Int.decode(args[0]) if len(args) > 0 else 256 bits = bits + bits % 4 # Round to 4 nbytes: int = bits // 8 return secrets.token_hex(nbytes).encode() @command(name="ACL SETUSER", fixed=(bytes,), repeat=(bytes,)) def acl_setuser(self, username: bytes, *args: bytes) -> bytes: self._set_user_acl(username, *args) return OK @command(name="ACL LIST", fixed=(), repeat=()) def acl_list(self) -> List[bytes]: return self._acl.as_rules() @command(name="ACL DELUSER", fixed=(bytes,), repeat=()) def acl_deluser(self, username: bytes) -> bytes: self._acl.del_user(username) return OK @command(name="ACL GETUSER", fixed=(bytes,), repeat=()) def acl_getuser(self, username: bytes) -> List[bytes]: res = self._acl.get_user_acl(username).as_array() return res @command(name="ACL USERS", fixed=(), repeat=()) def acl_users(self) -> List[bytes]: res = self._acl.get_users() return res @command(name="ACL WHOAMI", fixed=(), repeat=()) def acl_whoami(self) -> bytes: return self._client_info.get("user", "").encode() @command(name="ACL SAVE", fixed=(), repeat=()) def acl_save(self) -> SimpleString: if b"aclfile" not in self._server_config: raise SimpleError(msgs.MISSING_ACLFILE_CONFIG) acl_filename = self._server_config[b"aclfile"] with open(acl_filename, "wb") as f: f.write(b"\n".join(self._acl.as_rules())) return OK @command(name="ACL LOAD", fixed=(), repeat=()) def acl_load(self) -> SimpleString: if b"aclfile" not in self._server_config: raise SimpleError(msgs.MISSING_ACLFILE_CONFIG) acl_filename = self._server_config[b"aclfile"] with open(acl_filename, "rb") as f: rules_list = f.readlines() for rule in rules_list: if not rule.startswith(b"user "): continue splitted = rule.split(b" ") components = list() i = 1 while i < len(splitted): current_component = splitted[i] if current_component.startswith(b"("): while not current_component.endswith(b")"): i += 1 current_component += b" " + splitted[i] components.append(current_component) i += 1 self._set_user_acl(components[0], *components[1:]) return OK @command(name="ACL LOG", fixed=(), repeat=(bytes,)) def acl_log(self, *args: bytes) -> Union[SimpleString, List[Dict[str, str]]]: if len(args) == 1 and casematch(args[0], b"RESET"): self._acl.reset_log() return OK count = Int.decode(args[0]) if len(args) == 1 else 0 return self._acl.log(count) fakeredis-2.31.0/fakeredis/commands_mixins/bitmap_mixin.py0000644000000000000000000002461313615410400020637 0ustar00import re from typing import Any, Callable, List, Optional from fakeredis import _msgs as msgs from fakeredis._commands import ( command, Key, Int, BitOffset, BitValue, fix_range_string, fix_range, CommandItem, ) from fakeredis._helpers import SimpleError, casematch from fakeredis.typing import VersionType class BitfieldEncoding: signed: bool size: int def __init__(self, encoding: bytes) -> None: match = re.match(rb"^([ui])(\d+)$", encoding) if match is None: raise SimpleError(msgs.INVALID_BITFIELD_TYPE) self.signed = match[1] == b"i" self.size = int(match[2]) if self.size < 1 or self.size > (64 if self.signed else 63): raise SimpleError(msgs.INVALID_BITFIELD_TYPE) class BitmapCommandsMixin: def __init(self, *args: Any, **kwargs: Any) -> None: super().__init__(*args, **kwargs) self.version: VersionType @staticmethod def _bytes_as_bin_string(value: bytes) -> str: return "".join([bin(i).lstrip("0b").rjust(8, "0") for i in value]) @command((Key(bytes), Int), (bytes,), flags=msgs.FLAG_DO_NOT_CREATE) def bitpos(self, key: CommandItem, bit: int, *args: bytes) -> int: if bit != 0 and bit != 1: raise SimpleError(msgs.BIT_ARG_MUST_BE_ZERO_OR_ONE) if len(args) > 3: raise SimpleError(msgs.SYNTAX_ERROR_MSG) if len(args) == 3 and self.version < (7,): raise SimpleError(msgs.SYNTAX_ERROR_MSG) bit_mode = False if len(args) == 3 and self.version >= (7,): bit_mode = casematch(args[2], b"bit") if not bit_mode and not casematch(args[2], b"byte"): raise SimpleError(msgs.SYNTAX_ERROR_MSG) if key.value is None: # The first clear bit is at 0, the first set bit is not found (-1). return -1 if bit == 1 else 0 start = 0 if len(args) == 0 else Int.decode(args[0]) source_value = self._bytes_as_bin_string(key.value) if bit_mode else key.value end = len(source_value) if len(args) <= 1 else Int.decode(args[1]) length = len(source_value) start, end = fix_range(start, end, length) if start == end == -1: return -1 source_value = source_value[start:end] if bit_mode else self._bytes_as_bin_string(source_value[start:end]) result = source_value.find(str(bit)) if result != -1: result += start if bit_mode else (start * 8) elif bit == 0 and len(args) <= 1: # Redis treats the value as padded with zero bytes to an infinity # if the user is looking for the first clear bit and no end is set. result = len(key.value) * 8 return result @command(name="BITCOUNT", fixed=(Key(bytes),), repeat=(bytes,), flags=msgs.FLAG_DO_NOT_CREATE) def bitcount(self, key: CommandItem, *args: bytes) -> int: # Redis checks the argument count before decoding integers. That's why # we can't declare them as Int. if len(args) == 0: if key.value is None: return 0 return bin(int.from_bytes(key.value, "little")).count("1") if not 2 <= len(args) <= 3: raise SimpleError(msgs.SYNTAX_ERROR_MSG) try: start = Int.decode(args[0]) end = Int.decode(args[1]) except SimpleError as e: if self.version >= (7, 4): raise e return 0 bit_mode = False if len(args) == 3 and self.version < (7,): raise SimpleError(msgs.SYNTAX_ERROR_MSG) if len(args) == 3 and self.version >= (7,): bit_mode = casematch(args[2], b"bit") if not bit_mode and not casematch(args[2], b"byte"): raise SimpleError(msgs.SYNTAX_ERROR_MSG) if key.value is None: return 0 if bit_mode: value = self._bytes_as_bin_string(key.value if key.value else b"") start, end = fix_range_string(start, end, len(value)) res: int = value.count("1", start, end) return res start, end = fix_range_string(start, end, len(key.value)) value = key.value[start:end] return bin(int.from_bytes(value, "little")).count("1") @command(fixed=(Key(bytes), BitOffset)) def getbit(self, key: CommandItem, offset: int) -> int: value = key.get(b"") byte = offset // 8 remaining = offset % 8 actual_bitoffset = 7 - remaining try: actual_val = value[byte] except IndexError: return 0 return 1 if (1 << actual_bitoffset) & actual_val else 0 @command((Key(bytes), BitOffset, BitValue)) def setbit(self, key: CommandItem, offset: int, value: int) -> int: val = key.value if key.value is not None else b"\x00" byte = offset // 8 remaining = offset % 8 actual_bitoffset = 7 - remaining if len(val) - 1 < byte: # We need to expand val so that we can set the appropriate # bit. needed = byte - (len(val) - 1) val += b"\x00" * needed old_byte = val[byte] if value == 1: new_byte = old_byte | (1 << actual_bitoffset) else: new_byte = old_byte & ~(1 << actual_bitoffset) old_value = value if old_byte == new_byte else 1 - value reconstructed = bytearray(val) reconstructed[byte] = new_byte if bytes(reconstructed) != key.value or (self.version == (6,) and old_byte != new_byte): key.update(bytes(reconstructed)) return old_value @staticmethod def _bitop(op: Callable[[Any, Any], Any], *keys: CommandItem) -> Any: value = keys[0].value ans = keys[0].value i = 1 while i < len(keys): value = keys[i].value if keys[i].value is not None else b"" ans = bytes(op(a, b) for a, b in zip(ans, value)) i += 1 return ans @command((bytes, Key()), (Key(bytes),)) def bitop(self, op_name: bytes, dst: CommandItem, *keys: CommandItem) -> int: if len(keys) == 0: raise SimpleError(msgs.WRONG_ARGS_MSG6.format("bitop")) if casematch(op_name, b"and"): res = self._bitop(lambda a, b: a & b, *keys) elif casematch(op_name, b"or"): res = self._bitop(lambda a, b: a | b, *keys) elif casematch(op_name, b"xor"): res = self._bitop(lambda a, b: a ^ b, *keys) elif casematch(op_name, b"not"): if len(keys) != 1: raise SimpleError(msgs.BITOP_NOT_ONE_KEY_ONLY) val = keys[0].value res = bytes([((1 << 8) - 1 - val[i]) for i in range(len(val))]) else: raise SimpleError(msgs.WRONG_ARGS_MSG6.format("bitop")) dst.value = res return len(dst.value) def _bitfield_get(self, key: CommandItem, encoding: BitfieldEncoding, offset: int) -> int: ans = 0 for i in range(0, encoding.size): ans <<= 1 if self.getbit(key, offset + i): ans += -1 if encoding.signed and i == 0 else 1 return ans def _bitfield_set( self, key: CommandItem, encoding: BitfieldEncoding, offset: int, overflow: bytes, value: Optional[int] = None, incr: int = 0, ) -> Optional[int]: if encoding.signed: min_value = -(1 << (encoding.size - 1)) max_value = (1 << (encoding.size - 1)) - 1 else: min_value = 0 max_value = (1 << encoding.size) - 1 ans = self._bitfield_get(key, encoding, offset) new_value = ans if value is None else value if not encoding.signed: new_value &= (1 << 64) - 1 # force cast to uint64_t if overflow == b"FAIL" and not (min_value <= new_value + incr <= max_value): return None # yes, failing in this context is not writing the value elif overflow == b"SAT": if new_value + incr > max_value: new_value, incr = max_value, 0 # REDIS only checks for unsigned underflow on negative incr: if (encoding.signed or incr < 0) and new_value + incr < min_value: new_value, incr = min_value, 0 new_value += incr new_value &= (1 << encoding.size) - 1 # normalize signed number by changing the sign associated to higher bit: if encoding.signed and new_value > max_value: new_value -= 1 << encoding.size for i in range(0, encoding.size): bit = (new_value >> (encoding.size - i - 1)) & 1 self.setbit(key, offset + i, bit) return new_value if value is None else ans @command(fixed=(Key(bytes),), repeat=(bytes,)) def bitfield(self, key: CommandItem, *args: bytes) -> List[Optional[int]]: overflow = b"WRAP" results: List[Optional[int]] = [] i = 0 while i < len(args): if casematch(args[i], b"overflow") and i + 1 < len(args): overflow = args[i + 1].upper() if overflow not in (b"WRAP", b"SAT", b"FAIL"): raise SimpleError(msgs.INVALID_OVERFLOW_TYPE) i += 2 elif casematch(args[i], b"get") and i + 2 < len(args): encoding = BitfieldEncoding(args[i + 1]) offset = BitOffset.decode(args[i + 2]) results.append(self._bitfield_get(key, encoding, offset)) i += 3 elif casematch(args[i], b"set") and i + 3 < len(args): old_value = self._bitfield_set( key=key, encoding=BitfieldEncoding(args[i + 1]), offset=BitOffset.decode(args[i + 2]), value=Int.decode(args[i + 3]), overflow=overflow, ) results.append(old_value) i += 4 elif casematch(args[i], b"incrby") and i + 3 < len(args): old_value = self._bitfield_set( key=key, encoding=BitfieldEncoding(args[i + 1]), offset=BitOffset.decode(args[i + 2]), incr=Int.decode(args[i + 3]), overflow=overflow, ) results.append(old_value) i += 4 else: raise SimpleError(msgs.SYNTAX_ERROR_MSG) return results fakeredis-2.31.0/fakeredis/commands_mixins/connection_mixin.py0000644000000000000000000001011713615410400021514 0ustar00from typing import Any, List, Union, Dict import fakeredis from fakeredis import _msgs as msgs from fakeredis._commands import command, DbIndex, Int from fakeredis._helpers import SimpleError, OK, SimpleString, Database, casematch PONG = SimpleString(b"PONG") class ConnectionCommandsMixin: def __init__(self, *args: Any, **kwargs: Any) -> None: super(ConnectionCommandsMixin, self).__init__(*args, **kwargs) self._db: Database self._db_num: int self._pubsub: int self._client_info: Dict[str, Union[str, int]] self._server: Any @command((bytes,)) def echo(self, message: bytes) -> bytes: return message @command((), (bytes,)) def ping(self, *args: bytes) -> Union[List[bytes], bytes, SimpleString]: if len(args) > 1: msg = msgs.WRONG_ARGS_MSG6.format("ping") raise SimpleError(msg) if self._pubsub and self.protocol_version == 2: return [b"pong", args[0] if args else b""] else: return args[0] if args else PONG @command(name="SELECT", fixed=(DbIndex,)) def select(self, index: DbIndex) -> SimpleString: self._db = self._server.dbs[index] self._db_num = index # type: ignore return OK @command(name="CLIENT SETINFO", fixed=(bytes, bytes), repeat=()) def client_setinfo(self, lib_data: bytes, value: bytes) -> SimpleString: if casematch(lib_data, b"LIB-NAME"): self._client_info["lib-name"] = value.decode("utf-8") return OK if casematch(lib_data, b"LIB-VER"): self._client_info["lib-ver"] = value.decode("utf-8") return OK raise SimpleError(msgs.SYNTAX_ERROR_MSG) @command(name="CLIENT SETNAME", fixed=(bytes,), repeat=()) def client_setname(self, value: bytes) -> SimpleString: self._client_info["name"] = value.decode("utf-8") return OK @command(name="CLIENT GETNAME", fixed=(), repeat=()) def client_getname(self) -> bytes: return self._client_info.get("name", "").encode("utf-8") @command(name="CLIENT ID", fixed=(), repeat=()) def client_getid(self) -> int: return self._client_info.get("id", 1) @command(name="CLIENT INFO", fixed=(), repeat=()) def client_info_cmd(self) -> bytes: return self.client_info_as_bytes @command(name="CLIENT LIST", fixed=(), repeat=(bytes,)) def client_list_cmd(self, *args: bytes) -> bytes: sockets = self._server.sockets.copy() i = 0 filter_ids = set() while i < len(args): if casematch(args[i], b"TYPE") and i + 1 < len(args): i += 2 if casematch(args[i], b"ID") and i + 1 < len(args): i += 1 while i < len(args): filter_ids.add(Int.decode(args[i])) i += 1 else: raise SimpleError(msgs.SYNTAX_ERROR_MSG) if len(filter_ids) > 0: sockets = [sock for sock in sockets if sock._client_info["id"] in filter_ids] res = [item.client_info_as_bytes for item in sockets] return b"\n".join(res) @command(name="HELLO", fixed=(), repeat=(bytes,)) def hello(self, *args: bytes) -> List[bytes]: self._client_info["resp"] = 2 if len(args) == 0 else Int.decode(args[0]) i = 1 while i < len(args): if args[i] == b"SETNAME" and i + 1 < len(args): self._client_info["name"] = args[i + 1].decode("utf-8") i += 2 elif args[i] == b"AUTH" and i + 2 < len(args): user = args[i + 1] password = args[i + 2] self._server._acl.get_user_acl(user).check_password(password) i += 3 else: raise SimpleError(msgs.SYNTAX_ERROR_MSG) data = dict( server="fakeredis", version=fakeredis.__version__, proto=self._client_info["resp"], id=self._client_info.get("id", 1), mode="standalone", role="master", modules=[], ) return data fakeredis-2.31.0/fakeredis/commands_mixins/generic_mixin.py0000644000000000000000000003414413615410400020777 0ustar00import hashlib import pickle import random from typing import Tuple, Any, Callable, List, Optional, Union, Sequence from fakeredis import _msgs as msgs from fakeredis._command_args_parsing import extract_args from fakeredis._commands import ( command, Key, Int, DbIndex, BeforeAny, CommandItem, SortFloat, delete_keys, ) from fakeredis._helpers import compile_pattern, SimpleError, OK, casematch, Database, SimpleString from fakeredis.model import ZSet, Hash, ExpiringMembersSet from fakeredis.typing import VersionType class GenericCommandsMixin: _ttl: Callable[[CommandItem, float], int] _scan: Callable[[Sequence[bytes], int, bytes], List[Union[bytes, List[bytes]]]] _key_value_type: Callable[[CommandItem], SimpleString] def __init__(self, *args: Any, **kwargs: Any) -> None: super(GenericCommandsMixin, self).__init__(*args, **kwargs) self.version: VersionType self._server: Any self._db: Database self._db_num: int def _lookup_key(self, key: bytes, pattern: bytes) -> Optional[bytes]: """Python implementation of lookupKeyByPattern from redis""" if pattern == b"#": return key p = pattern.find(b"*") if p == -1: return None prefix = pattern[:p] suffix = pattern[p + 1 :] arrow = suffix.find(b"->", 0, -1) if arrow != -1: field = suffix[arrow + 2 :] suffix = suffix[:arrow] else: field = None new_key = prefix + key + suffix item = CommandItem(new_key, self._db, item=self._db.get(new_key)) if item.value is None: return None if field is not None: if not isinstance(item.value, Hash): return None return item.value.get(field) # type: ignore else: if not isinstance(item.value, bytes): return None return item.value def _expireat(self, key: CommandItem, timestamp: float, *args: bytes) -> int: ( ( nx, xx, gt, lt, ), _, ) = extract_args( args, ( "nx", "xx", "gt", "lt", ), exception=msgs.EXPIRE_UNSUPPORTED_OPTION, ) if self.version < (7,) and any((nx, xx, gt, lt)): raise SimpleError(msgs.WRONG_ARGS_MSG6.format("expire")) counter = (nx, gt, lt).count(True) if (counter > 1) or (nx and xx): raise SimpleError(msgs.NX_XX_GT_LT_ERROR_MSG) if ( not key or (xx and key.expireat is None) or (nx and key.expireat is not None) or (gt and key.expireat is not None and timestamp < key.expireat) or (lt and key.expireat is not None and timestamp > key.expireat) ): return 0 key.expireat = timestamp return 1 @command(name="DEL", fixed=(Key(),), repeat=(Key(),)) def del_(self, *keys: CommandItem): return delete_keys(*keys) @command(name="DUMP", fixed=(Key(missing_return=None),)) def dump(self, key: CommandItem) -> Optional[bytes]: value = pickle.dumps(key.value) checksum = hashlib.sha1(value).digest() return checksum + value @command(name="EXISTS", fixed=(Key(),), repeat=(Key(),)) def exists(self, *keys): ret = 0 for key in keys: if key: ret += 1 return ret @command(name="EXPIRE", fixed=(Key(), Int), repeat=(bytes,)) def expire(self, key: CommandItem, seconds: int, *args: bytes) -> int: res = self._expireat(key, self._db.time + seconds, *args) return res @command(name="EXPIREAT", fixed=(Key(), Int)) def expireat(self, key: CommandItem, timestamp: int) -> int: return self._expireat(key, float(timestamp)) @command(name="KEYS", fixed=(bytes,)) def keys(self, pattern: bytes) -> List[bytes]: if pattern == b"*": return list(self._db) else: regex = compile_pattern(pattern) return [key for key in self._db if regex.match(key)] @command(name="MOVE", fixed=(Key(), DbIndex)) def move(self, key: CommandItem, db: int) -> int: if db == self._db_num: raise SimpleError(msgs.SRC_DST_SAME_MSG) if not key or key.key in self._server.dbs[db]: return 0 # TODO: what is the interaction with expiry? self._server.dbs[db][key.key] = self._server.dbs[self._db_num][key.key] key.value = None # Causes deletion return 1 @command(name="PERSIST", fixed=(Key(),)) def persist(self, key: CommandItem) -> int: if key.expireat is None: return 0 key.expireat = None return 1 @command(name="PEXPIRE", fixed=(Key(), Int)) def pexpire(self, key: CommandItem, ms: int) -> int: return self._expireat(key, self._db.time + ms / 1000.0) @command(name="PEXPIREAT", fixed=(Key(), Int)) def pexpireat(self, key: CommandItem, ms_timestamp: int) -> int: return self._expireat(key, ms_timestamp / 1000.0) @command(name="PTTL", fixed=(Key(),)) def pttl(self, key: CommandItem) -> int: return self._ttl(key, 1000.0) @command(name="EXPIRETIME", fixed=(Key(),)) def expiretime(self, key: CommandItem) -> int: if key.value is None: return -2 if key.expireat is None: return -1 return int(key.expireat) @command(name="PEXPIRETIME", fixed=(Key(),)) def pexpiretime(self, key: CommandItem) -> int: if key.value is None: return -2 if key.expireat is None: return -1 return int(key.expireat * 1000) @command(name="RANDOMKEY", fixed=()) def randomkey(self): keys = list(self._db.keys()) if not keys: return None return random.choice(keys) @command(name="RENAME", fixed=(Key(), Key())) def rename(self, key: CommandItem, newkey: CommandItem) -> SimpleString: if not key: raise SimpleError(msgs.NO_KEY_MSG) # TODO: check interaction with WATCH if newkey.key != key.key: newkey.value = key.value newkey.expireat = key.expireat key.value = None return OK @command(name="RENAMENX", fixed=(Key(), Key())) def renamenx(self, key: CommandItem, newkey: CommandItem) -> int: if not key: raise SimpleError(msgs.NO_KEY_MSG) if newkey: return 0 self.rename(key, newkey) return 1 @command(name="RESTORE", fixed=(Key(), Int, bytes), repeat=(bytes,)) def restore(self, key: CommandItem, ttl: int, value: bytes, *args: bytes) -> str: (replace,), _ = extract_args(args, ("replace",)) if key and not replace: raise SimpleError(msgs.RESTORE_KEY_EXISTS) checksum, value = value[:20], value[20:] if hashlib.sha1(value).digest() != checksum: raise SimpleError(msgs.RESTORE_INVALID_CHECKSUM_MSG) if ttl < 0: raise SimpleError(msgs.RESTORE_INVALID_TTL_MSG) if ttl == 0: expireat = None else: expireat = self._db.time + ttl / 1000.0 key.value = pickle.loads(value) key.expireat = expireat return OK @command(name="SCAN", fixed=(Int,), repeat=(bytes, bytes)) def scan(self, cursor, *args): return self._scan(list(self._db), cursor, *args) @command(name="SORT", fixed=(Key(),), repeat=(bytes,)) def sort(self, key, *args): if key.value is not None and not isinstance(key.value, (ExpiringMembersSet, list, ZSet)): raise SimpleError(msgs.WRONGTYPE_MSG) ( ( asc, desc, alpha, store, sortby, (limit_start, limit_count), ), left_args, ) = extract_args( args, ("asc", "desc", "alpha", "*store", "*by", "++limit"), error_on_unexpected=False, left_from_first_unexpected=False, ) limit_start = limit_start or 0 limit_count = -1 if limit_count is None else limit_count dontsort = sortby is not None and b"*" not in sortby i = 0 get = [] while i < len(left_args): if casematch(left_args[i], b"get") and i + 1 < len(left_args): get.append(left_args[i + 1]) i += 2 else: raise SimpleError(msgs.SYNTAX_ERROR_MSG) # TODO: force sorting if the object is a set and either in Lua or # storing to a key, to match redis behaviour. items = list(key.value) if key.value is not None else [] # These transformations are based on the redis implementation, but # changed to produce a half-open range. start = max(limit_start, 0) end = len(items) if limit_count < 0 else start + limit_count if start >= len(items): start = end = len(items) - 1 end = min(end, len(items)) if not get: get.append(b"#") if sortby is None: sortby = b"#" if not dontsort: def sort_key(val: bytes) -> bytes: byval = self._lookup_key(val, sortby) # TODO: use locale.strxfrm when not storing? But then need to decode too. if byval is None: byval = BeforeAny() return byval def sort_key_score(val: bytes) -> Tuple[float, bytes]: byval = self._lookup_key(val, sortby) score = SortFloat.decode(byval) if byval is not None else 0.0 return score, val sort_func = sort_key if alpha else sort_key_score items.sort(key=sort_func, reverse=desc) elif isinstance(key.value, (list, ZSet)): items.reverse() out = [] for row in items[start:end]: for g in get: v = self._lookup_key(row, g) if store is not None and v is None: v = b"" out.append(v) if store is not None: item = CommandItem(store, self._db, item=self._db.get(store)) item.value = out item.writeback() return len(out) else: return out @command(name="SORT_RO", fixed=(Key(),), repeat=(bytes,)) def sort_ro(self, key: CommandItem, *args: bytes) -> List[bytes]: if key.value is not None and not isinstance(key.value, (set, list, ZSet)): raise SimpleError(msgs.WRONGTYPE_MSG) ( ( asc, desc, alpha, sortby, (limit_start, limit_count), ), left_args, ) = extract_args( args, ("asc", "desc", "alpha", "*by", "++limit"), error_on_unexpected=False, left_from_first_unexpected=False, ) limit_start = limit_start or 0 limit_count = -1 if limit_count is None else limit_count dontsort = sortby is not None and b"*" not in sortby i = 0 get = [] while i < len(left_args): if casematch(left_args[i], b"get") and i + 1 < len(left_args): get.append(left_args[i + 1]) i += 2 else: raise SimpleError(msgs.SYNTAX_ERROR_MSG) # TODO: force sorting if the object is a set and either in Lua or # storing to a key, to match redis behaviour. items = list(key.value) if key.value is not None else [] # These transformations are based on the redis implementation, but # changed to produce a half-open range. start = max(limit_start, 0) end = len(items) if limit_count < 0 else start + limit_count if start >= len(items): start = end = len(items) - 1 end = min(end, len(items)) if not get: get.append(b"#") if sortby is None: sortby = b"#" if not dontsort: def sort_key(val: bytes) -> bytes: byval = self._lookup_key(val, sortby) # TODO: use locale.strxfrm when not storing? But then need to decode too. if byval is None: byval = BeforeAny() return byval def sort_key_score(val: bytes) -> Tuple[float, bytes]: byval = self._lookup_key(val, sortby) score = SortFloat.decode(byval) if byval is not None else 0.0 return score, val sort_func = sort_key if alpha else sort_key_score items.sort(key=sort_func, reverse=desc) elif isinstance(key.value, (list, ZSet)): items.reverse() out: List[bytes] = [] for row in items[start:end]: for g in get: v = self._lookup_key(row, g) out.append(v) return out @command(name="TTL", fixed=(Key(),)) def ttl(self, key: CommandItem) -> int: return self._ttl(key, 1.0) @command(name="TYPE", fixed=(Key(),)) def type_cmd(self, key: CommandItem) -> SimpleString: return self._key_value_type(key) @command(name="UNLINK", fixed=(Key(),), repeat=(Key(),)) def unlink(self, *keys: CommandItem) -> int: return delete_keys(*keys) @command(name="COPY", fixed=(Key(), Key()), repeat=(bytes,)) def copy(self, key: CommandItem, newkey: CommandItem, *args: bytes) -> int: (db_num, replace), _ = extract_args(args, ("+db", "replace")) db_num = db_num or self._db_num if key.key == newkey.key and db_num == self._db_num: raise SimpleError(msgs.SRC_DST_SAME_MSG) if (newkey.key in self._server.dbs[db_num] and not replace) or (key.key not in self._server.dbs[self._db_num]): return 0 newkey.value = key.value newkey.expireat = key.expireat self._server.dbs[db_num][newkey.key] = key newkey.db = self._server.dbs[db_num] return 1 fakeredis-2.31.0/fakeredis/commands_mixins/geo_mixin.py0000644000000000000000000002506113615410400020133 0ustar00import sys from collections import namedtuple from typing import List, Any, Callable, Optional, Union from fakeredis import _msgs as msgs from fakeredis._command_args_parsing import extract_args from fakeredis._commands import command, Key, Float, CommandItem from fakeredis._helpers import SimpleError, Database from fakeredis.model import ZSet from fakeredis.geo import distance, geo_encode, geo_decode UNIT_TO_M = {"km": 0.001, "mi": 0.000621371, "ft": 3.28084, "m": 1} def translate_meters_to_unit(unit_arg: bytes) -> float: """number of meters in a unit. :param unit_arg: unit name (km, mi, ft, m) :returns: number of meters in unit """ unit = UNIT_TO_M.get(unit_arg.decode().lower()) if unit is None: raise SimpleError(msgs.GEO_UNSUPPORTED_UNIT) return unit GeoResult = namedtuple("GeoResult", "name long lat hash distance") def _parse_results(items: List[GeoResult], withcoord: bool, withdist: bool) -> List[Any]: """Parse list of GeoResults to redis response :param withcoord: include coordinates in response :param withdist: include distance in response :returns: Parsed list """ res = list() for item in items: new_item = [ item.name, ] if withdist: new_item.append(Float.encode(item.distance, False)) if withcoord: new_item.append([Float.encode(item.long, False), Float.encode(item.lat, False)]) if len(new_item) == 1: new_item = new_item[0] res.append(new_item) return res def _find_near( zset: ZSet, lat: float, long: float, radius: float, conv: float, count: int, count_any: bool, desc: bool, ) -> List[GeoResult]: """Find items within area (lat,long)+radius :param zset: list of items to check :param lat: latitude :param long: longitude :param radius: radius in whatever units :param conv: conversion of radius to meters :param count: number of results to give :param count_any: should we return any results that match? (vs. sorted) :param desc: should results be sorted descending order? :returns: List of GeoResults """ results = list() for name, _hash in zset.items(): p_lat, p_long, _, _ = geo_decode(_hash) dist = distance((p_lat, p_long), (lat, long)) * conv if dist < radius: results.append(GeoResult(name, p_long, p_lat, _hash, dist)) if count_any and len(results) >= count: break results = sorted(results, key=lambda x: x.distance, reverse=desc) if count: results = results[:count] return results class GeoCommandsMixin: _encodefloat: Callable[[float, bool], bytes] def __init__(self, *args: Any, **kwargs: Any) -> None: super(GeoCommandsMixin, self).__init__(*args, **kwargs) self._db: Database def _store_geo_results(self, item_name: bytes, geo_results: List[GeoResult], scoredist: bool) -> int: db_item = CommandItem(item_name, self._db, item=self._db.get(item_name), default=ZSet()) db_item.value = ZSet() for item in geo_results: val = item.distance if scoredist else item.hash db_item.value.add(item.name, val) db_item.writeback() return len(geo_results) @command(name="GEOADD", fixed=(Key(ZSet),), repeat=(bytes,)) def geoadd(self, key: CommandItem, *args: bytes) -> int: (xx, nx, ch), data = extract_args( args, ("nx", "xx", "ch"), error_on_unexpected=False, left_from_first_unexpected=True, ) if xx and nx: raise SimpleError(msgs.NX_XX_GT_LT_ERROR_MSG) if len(data) == 0 or len(data) % 3 != 0: raise SimpleError(msgs.SYNTAX_ERROR_MSG) zset = key.value old_len, changed_items = len(zset), 0 for i in range(0, len(data), 3): long, lat, name = ( Float.decode(data[i + 0]), Float.decode(data[i + 1]), data[i + 2], ) if (name in zset and not xx) or (name not in zset and not nx): if zset.add(name, geo_encode(lat, long, 10)): changed_items += 1 if changed_items: key.updated() if ch: return changed_items return len(zset) - old_len @command(name="GEOHASH", fixed=(Key(ZSet), bytes), repeat=(bytes,)) def geohash(self, key: CommandItem, *members: bytes) -> List[bytes]: hashes = map(key.value.get, members) geohash_list = [((x + "0").encode() if x is not None else x) for x in hashes] return geohash_list @command(name="GEOPOS", fixed=(Key(ZSet), bytes), repeat=(bytes,)) def geopos(self, key: CommandItem, *members: bytes) -> List[Optional[List[float]]]: gospositions = map( lambda x: geo_decode(x) if x is not None else x, map(key.value.get, members), ) res = [([x[1], x[0]] if x is not None else None) for x in gospositions] return res @command(name="GEODIST", fixed=(Key(ZSet), bytes, bytes), repeat=(bytes,)) def geodist(self, key: CommandItem, m1: bytes, m2: bytes, *args: bytes) -> Optional[float]: geohashes = [key.value.get(m1), key.value.get(m2)] if any(elem is None for elem in geohashes): return None geo_locs = [geo_decode(x) for x in geohashes] res = distance((geo_locs[0][0], geo_locs[0][1]), (geo_locs[1][0], geo_locs[1][1])) unit = translate_meters_to_unit(args[0]) if len(args) == 1 else 1 return res * unit def _search( self, key: CommandItem, long: float, lat: float, radius: float, conv: float, withcoord: bool, withdist: bool, _: bool, count: int, count_any: bool, desc: bool, store: Optional[bytes], storedist: Optional[bytes], ) -> Union[List[Any], int]: zset = key.value geo_results = _find_near(zset, lat, long, radius, conv, count, count_any, desc) if store: self._store_geo_results(store, geo_results, scoredist=False) return len(geo_results) if storedist: self._store_geo_results(storedist, geo_results, scoredist=True) return len(geo_results) ret = _parse_results(geo_results, withcoord, withdist) return ret @command(name="GEORADIUS_RO", fixed=(Key(ZSet), Float, Float, Float), repeat=(bytes,)) def georadius_ro(self, key: CommandItem, long: float, lat: float, radius: float, *args: bytes) -> List[Any]: (withcoord, withdist, withhash, count, count_any, desc), left_args = extract_args( args, ("withcoord", "withdist", "withhash", "+count", "any", "desc"), error_on_unexpected=False, left_from_first_unexpected=False, ) count = count or sys.maxsize conv: float = translate_meters_to_unit(args[0]) if len(args) >= 1 else 1.0 res: List[Any] = self._search( # type: ignore key, long, lat, radius, conv, withcoord, withdist, withhash, count, count_any, desc, None, None ) return res @command(name="GEORADIUS", fixed=(Key(ZSet), Float, Float, Float), repeat=(bytes,)) def georadius(self, key: CommandItem, long: float, lat: float, radius: float, *args: bytes) -> List[Any]: (withcoord, withdist, withhash, count, count_any, desc, store, storedist), left_args = extract_args( args, ("withcoord", "withdist", "withhash", "+count", "any", "desc", "*store", "*storedist"), error_on_unexpected=False, left_from_first_unexpected=False, ) count = count or sys.maxsize conv = translate_meters_to_unit(args[0]) if len(args) >= 1 else 1 res: List[Any] = self._search( # type: ignore key, long, lat, radius, conv, withcoord, withdist, withhash, count, count_any, desc, store, storedist, ) return res @command(name="GEORADIUSBYMEMBER", fixed=(Key(ZSet), bytes, Float), repeat=(bytes,)) def georadiusbymember(self, key: CommandItem, member_name: bytes, radius: float, *args: bytes): member_score = key.value.get(member_name) lat, long, _, _ = geo_decode(member_score) return self.georadius(key, long, lat, radius, *args) @command(name="GEORADIUSBYMEMBER_RO", fixed=(Key(ZSet), bytes, Float), repeat=(bytes,)) def georadiusbymember_ro(self, key: CommandItem, member_name: bytes, radius: float, *args: float) -> List[Any]: member_score = key.value.get(member_name) lat, long, _, _ = geo_decode(member_score) return self.georadius_ro(key, long, lat, radius, *args) @command(name="GEOSEARCH", fixed=(Key(ZSet),), repeat=(bytes,)) def geosearch(self, key: CommandItem, *args: bytes) -> List[Any]: (frommember, (long, lat), radius), left_args = extract_args( args, ("*frommember", "..fromlonlat", ".byradius"), error_on_unexpected=False, left_from_first_unexpected=False, ) if frommember is None and long is None: raise SimpleError(msgs.SYNTAX_ERROR_MSG) if frommember is not None and long is not None: raise SimpleError(msgs.SYNTAX_ERROR_MSG) if frommember: return self.georadiusbymember_ro(key, frommember, radius, *left_args) else: return self.georadius_ro(key, long, lat, radius, *left_args) # type: ignore @command( name="GEOSEARCHSTORE", fixed=( bytes, Key(ZSet), ), repeat=(bytes,), ) def geosearchstore(self, dst: bytes, src: CommandItem, *args: bytes) -> List[Any]: (frommember, (long, lat), radius, storedist), left_args = extract_args( args, ("*frommember", "..fromlonlat", ".byradius", "storedist"), error_on_unexpected=False, left_from_first_unexpected=False, ) if frommember is None and long is None: raise SimpleError(msgs.SYNTAX_ERROR_MSG) if frommember is not None and long is not None: raise SimpleError(msgs.SYNTAX_ERROR_MSG) additional = [b"storedist", dst] if storedist else [b"store", dst] if frommember: return self.georadiusbymember(src, frommember, radius, *left_args, *additional) else: return self.georadius(src, long, lat, radius, *left_args, *additional) # type: ignore fakeredis-2.31.0/fakeredis/commands_mixins/hash_mixin.py0000644000000000000000000003303313615410400020302 0ustar00import random from typing import Callable, List, Any, Optional, Sequence, Union, Mapping import math from fakeredis import _msgs as msgs from fakeredis._command_args_parsing import extract_args from fakeredis._commands import command, Key, Int, Float, CommandItem from fakeredis._helpers import SimpleError, OK, casematch, SimpleString from fakeredis._helpers import current_time from fakeredis.model import Hash class HashCommandsMixin: _encodeint: Callable[ [ int, ], bytes, ] _encodefloat: Callable[[float, bool], bytes] _scan: Callable[[Sequence[bytes], int, bytes], List[Union[bytes, List[bytes]]]] def __init__(self, *args: Any, **kwargs: Any) -> None: super(HashCommandsMixin, self).__init__(*args, **kwargs) self.protocol_version: int def _hset(self, key: CommandItem, *args: bytes) -> int: h = key.value previous_keys_count = len(h.keys()) h.update(dict(zip(*[iter(args)] * 2)), clear_expiration=True) # type: ignore # https://stackoverflow.com/a/12739974/1056460 created = len(h.keys()) - previous_keys_count key.updated() return created @command((Key(Hash), bytes), (bytes,)) def hdel(self, key: CommandItem, *fields: bytes) -> int: h = key.value rem = 0 for field in fields: if field in h: del h[field] key.updated() rem += 1 return rem @command((Key(Hash), bytes)) def hexists(self, key: CommandItem, field: bytes) -> int: return int(field in key.value) @command((Key(Hash), bytes)) def hget(self, key: CommandItem, field: bytes) -> Any: return key.value.get(field) @command((Key(Hash),)) def hgetall(self, key: CommandItem) -> Mapping[str, str]: return key.value.getall() @command(fixed=(Key(Hash), bytes, bytes)) def hincrby(self, key: CommandItem, field: bytes, amount_bytes: bytes) -> int: amount = Int.decode(amount_bytes) field_value = Int.decode(key.value.get(field, b"0"), decode_error=msgs.INVALID_HASH_MSG) c = field_value + amount key.value.update({field: self._encodeint(c)}, clear_expiration=False) key.updated() return c @command((Key(Hash), bytes, bytes)) def hincrbyfloat(self, key: CommandItem, field: bytes, amount: bytes) -> bytes: c = Float.decode(key.value.get(field, b"0")) + Float.decode(amount) if not math.isfinite(c): raise SimpleError(msgs.NONFINITE_MSG) encoded = self._encodefloat(c, True) key.value.update({field: encoded}, clear_expiration=False) key.updated() return encoded @command((Key(Hash),)) def hkeys(self, key: CommandItem) -> List[bytes]: return list(key.value.keys()) @command((Key(Hash),)) def hlen(self, key: CommandItem) -> int: return len(key.value) @command((Key(Hash), bytes), (bytes,)) def hmget(self, key: CommandItem, *fields: bytes) -> List[bytes]: return [key.value.get(field) for field in fields] @command((Key(Hash), bytes, bytes), (bytes, bytes)) def hmset(self, key: CommandItem, *args: bytes) -> SimpleString: self.hset(key, *args) return OK @command((Key(Hash), Int), (bytes,)) def hscan(self, key: CommandItem, cursor: int, *args: bytes) -> List[Any]: no_values = any(casematch(arg, b"novalues") for arg in args) if no_values: args = [arg for arg in args if not casematch(arg, b"novalues")] cursor, keys = self._scan(key.value, cursor, *args) keys = [key.encode("utf-8") for key in keys if isinstance(key, str)] if no_values: return [cursor, keys] items = [] for k in keys: items.append(k) items.append(key.value[k]) return [cursor, items] @command((Key(Hash), bytes, bytes), (bytes, bytes)) def hset(self, key: CommandItem, *args: bytes) -> int: return self._hset(key, *args) @command((Key(Hash), bytes, bytes)) def hsetnx(self, key: CommandItem, field: bytes, value: bytes) -> int: if field in key.value: return 0 return self._hset(key, field, value) @command((Key(Hash), bytes)) def hstrlen(self, key: CommandItem, field: bytes) -> int: return len(key.value.get(field, b"")) @command((Key(Hash),)) def hvals(self, key: CommandItem) -> List[bytes]: return list(key.value.values()) @command(name="HRANDFIELD", fixed=(Key(Hash),), repeat=(bytes,)) def hrandfield(self, key: CommandItem, *args: bytes) -> Union[List[List[str]], List[str], None]: if len(args) > 2: raise SimpleError(msgs.SYNTAX_ERROR_MSG) if key.value is None or len(key.value) == 0: return None count = min(Int.decode(args[0]) if len(args) >= 1 else 1, len(key.value)) withvalues = casematch(args[1], b"withvalues") if len(args) >= 2 else False if count == 0: return dict() if count < 0: # Allow repetitions res = random.choices(sorted(key.value.items()), k=-count) else: # Unique values from hash res = random.sample(sorted(key.value.items()), count) if withvalues: if self.protocol_version == 2: res = [item for t in res for item in t] else: res = [list(t) for t in res] else: res = [t[0] for t in res] return res def _hexpire(self, key: CommandItem, when_ms: int, *args: bytes) -> List[int]: # Deal with input arguments (nx, xx, gt, lt), left_args = extract_args( args, ("nx", "xx", "gt", "lt"), left_from_first_unexpected=True, error_on_unexpected=False ) if (nx, xx, gt, lt).count(True) > 1: raise SimpleError(msgs.NX_XX_GT_LT_ERROR_MSG) fields = _get_fields(left_args) hash_val: Hash = key.value if hash_val is None: return [-2] * len(fields) # process command res = [] for field in fields: if field not in hash_val: res.append(-2) continue current_expiration = hash_val.get_key_expireat(field) if ( (nx and current_expiration is not None) or (xx and current_expiration is None) or (gt and (current_expiration is None or when_ms <= current_expiration)) or (lt and current_expiration is not None and when_ms >= current_expiration) ): res.append(0) continue res.append(hash_val.set_key_expireat(field, when_ms)) return res def _get_expireat(self, command: bytes, key: CommandItem, *args: bytes) -> List[int]: fields = _get_fields(args) hash_val: Hash = key.value if hash_val is None: return [-2] * len(fields) res = list() for field in fields: if field not in hash_val: res.append(-2) continue when_ms = hash_val.get_key_expireat(field) if when_ms is None: res.append(-1) else: res.append(when_ms) return res @command(name="HEXPIRE", fixed=(Key(Hash), Int), repeat=(bytes,)) def hexpire(self, key: CommandItem, seconds: int, *args: bytes) -> List[int]: when_ms = current_time() + seconds * 1000 return self._hexpire(key, when_ms, *args) @command(name="HPEXPIRE", fixed=(Key(Hash), Int), repeat=(bytes,)) def hpexpire(self, key: CommandItem, milliseconds: int, *args: bytes) -> List[int]: when_ms = current_time() + milliseconds return self._hexpire(key, when_ms, *args) @command(name="HEXPIREAT", fixed=(Key(Hash), Int), repeat=(bytes,)) def hexpireat(self, key: CommandItem, unix_time_seconds: int, *args: bytes) -> List[int]: when_ms = unix_time_seconds * 1000 return self._hexpire(key, when_ms, *args) @command(name="HPEXPIREAT", fixed=(Key(Hash), Int), repeat=(bytes,)) def hpexpireat(self, key: CommandItem, unix_time_ms: int, *args: bytes) -> List[int]: return self._hexpire(key, unix_time_ms, *args) @command(name="HPERSIST", fixed=(Key(Hash),), repeat=(bytes,)) def hpersist(self, key: CommandItem, *args: bytes) -> List[int]: fields = _get_fields(args) hash_val: Hash = key.value res = list() for field in fields: if field not in hash_val: res.append(-2) continue if hash_val.clear_key_expireat(field): res.append(1) else: res.append(-1) return res @command( name="HEXPIRETIME", fixed=(Key(Hash),), repeat=(bytes,), flags=msgs.FLAG_DO_NOT_CREATE, server_types=("redis",) ) def hexpiretime(self, key: CommandItem, *args: bytes) -> List[int]: res = self._get_expireat(b"HEXPIRETIME", key, *args) return [(i // 1000 if i > 0 else i) for i in res] @command(name="HPEXPIRETIME", fixed=(Key(Hash),), repeat=(bytes,), server_types=("redis",)) def hpexpiretime(self, key: CommandItem, *args: bytes) -> List[float]: res = self._get_expireat(b"HPEXPIRETIME", key, *args) return res @command(name="HTTL", fixed=(Key(Hash),), repeat=(bytes,), server_types=("redis",)) def httl(self, key: CommandItem, *args: bytes) -> List[int]: curr_expireat_ms = self._get_expireat(b"HTTL", key, *args) curr_time_ms = current_time() return [((i - curr_time_ms) // 1000) if i > 0 else i for i in curr_expireat_ms] @command(name="HPTTL", fixed=(Key(Hash),), repeat=(bytes,), server_types=("redis",)) def hpttl(self, key: CommandItem, *args: bytes) -> List[int]: curr_expireat_ms = self._get_expireat(b"HPTTL", key, *args) curr_time_ms = current_time() return [(i - curr_time_ms) if i > 0 else i for i in curr_expireat_ms] @command(name="HGETDEL", fixed=(Key(Hash),), repeat=(bytes,), server_types=("redis",)) def hgetdel(self, key: CommandItem, *args: bytes) -> List[Any]: fields = _get_fields(args) hash_val: Hash = key.value res = list() for field in fields: res.append(hash_val.pop(field)) return res @command(name="HGETEX", fixed=(Key(Hash),), repeat=(bytes,), server_types=("redis",)) def hgetex(self, key: CommandItem, *args: bytes) -> Any: (ex, px, exat, pxat, persist), left_args = extract_args( args, ("+ex", "+px", "+exat", "+pxat", "persist"), left_from_first_unexpected=True, error_on_unexpected=False, ) if (ex is not None, px is not None, exat is not None, pxat is not None, persist).count(True) > 1: raise SimpleError("Only one of EX, PX, EXAT, PXAT or PERSIST arguments can be specified") fields = _get_fields(left_args) hash_val: Hash = key.value when_ms = _get_when_ms(ex, px, exat, pxat) res = list() for field in fields: res.append(hash_val.get(field)) if persist: hash_val.clear_key_expireat(field) elif when_ms is not None: hash_val.set_key_expireat(field, when_ms) return res @command(name="HSETEX", fixed=(Key(Hash),), repeat=(bytes,), server_types=("redis",)) def hsetex(self, key: CommandItem, *args: bytes) -> Any: (ex, px, exat, pxat, keepttl, fnx, fxx), left_args = extract_args( args, ("+ex", "+px", "+exat", "+pxat", "keepttl", "fnx", "fxx"), left_from_first_unexpected=True, error_on_unexpected=False, ) if (ex is not None, px is not None, exat is not None, pxat is not None, keepttl).count(True) > 1: raise SimpleError("Only one of EX, PX, EXAT, PXAT or KEEPTTL arguments can be specified") if (fnx, fxx).count(True) > 1: raise SimpleError("Only one of FNX or FXX arguments can be specified") field_vals = _get_fields(left_args, with_values=True) hash_val: Hash = key.value when_ms = _get_when_ms(ex, px, exat, pxat) field_keys = set(field_vals[::2]) if fxx and len(field_keys - hash_val.getall().keys()) > 0: return 0 if fnx and len(field_keys - hash_val.getall().keys()) < len(field_keys): return 0 res = 0 for i in range(0, len(field_vals), 2): field, value = field_vals[i], field_vals[i + 1] hash_val[field] = value res = 1 if not keepttl and when_ms is not None: hash_val.set_key_expireat(field, when_ms) key.updated() return res def _get_fields(args: Sequence[bytes], with_values: bool = False) -> Sequence[bytes]: if len(args) < 3 or not casematch(args[0], b"fields"): raise SimpleError(msgs.WRONG_ARGS_MSG6.format(command)) num_fields = Int.decode(args[1]) if not with_values and num_fields != len(args) - 2: raise SimpleError(msgs.HEXPIRE_NUMFIELDS_DIFFERENT) if with_values and num_fields * 2 != len(args) - 2: raise SimpleError(msgs.HEXPIRE_NUMFIELDS_DIFFERENT) fields = args[2:] return fields def _get_when_ms(ex: Optional[int], px: Optional[int], exat: Optional[int], pxat: Optional[int]) -> Optional[int]: if ex is not None: when_ms = current_time() + ex * 1000 elif px is not None: when_ms = current_time() + px elif exat is not None: when_ms = exat * 1000 elif pxat is not None: when_ms = pxat else: when_ms = None return when_ms fakeredis-2.31.0/fakeredis/commands_mixins/list_mixin.py0000644000000000000000000002541413615410400020336 0ustar00import functools from typing import Callable, List, Optional, Union, Any from fakeredis import _msgs as msgs from fakeredis._command_args_parsing import extract_args from fakeredis._commands import Key, command, Int, CommandItem, Timeout, fix_range from fakeredis._helpers import OK, SimpleError, SimpleString, casematch, Database def _list_pop_count(get_slice, key, count): if not key: return None elif type(key.value) is not list: raise SimpleError(msgs.WRONGTYPE_MSG) slc = get_slice(count) ret = key.value[slc] del key.value[slc] key.updated() return ret def _list_pop(get_slice, key, *args): """Implements lpop and rpop. `get_slice` must take a count and return a slice expression for the range to pop. """ # This implementation is somewhat contorted to match the odd # behaviours described in https://github.com/redis/redis/issues/9680. count = 1 if len(args) > 1: raise SimpleError(msgs.SYNTAX_ERROR_MSG) elif len(args) == 1: count = Int.decode(args[0], msgs.INDEX_NEGATIVE_ERROR_MSG) if count < 0: raise SimpleError(msgs.INDEX_NEGATIVE_ERROR_MSG) ret = _list_pop_count(get_slice, key, count) if ret and not args: ret = ret[0] return ret class ListCommandsMixin: _blocking: Callable[[Optional[Union[float, int]], Callable[[bool], Any]], Any] def __init__(self, *args, **kwargs): super(ListCommandsMixin, self).__init__(*args, **kwargs) self._db: Database def _bpop_pass(self, keys, op, first_pass): for key in keys: item = CommandItem(key, self._db, item=self._db.get(key), default=[]) if not isinstance(item.value, list): if first_pass: raise SimpleError(msgs.WRONGTYPE_MSG) else: continue if item.value: ret = op(item.value) item.updated() item.writeback() return [key, ret] return None def _bpop(self, args, op): keys = args[:-1] timeout = Timeout.decode(args[-1]) return self._blocking(timeout, functools.partial(self._bpop_pass, keys, op)) @command((bytes, bytes), (bytes,), flags=msgs.FLAG_NO_SCRIPT) def blpop(self, *args): return self._bpop(args, lambda lst: lst.pop(0)) @command((bytes, bytes), (bytes,), flags=msgs.FLAG_NO_SCRIPT) def brpop(self, *args): return self._bpop(args, lambda lst: lst.pop()) def _brpoplpush_pass(self, source, destination, first_pass): src = CommandItem(source, self._db, item=self._db.get(source), default=[]) if not isinstance(src.value, list): if first_pass: raise SimpleError(msgs.WRONGTYPE_MSG) else: return None if not src.value: return None # Empty list dst = CommandItem(destination, self._db, item=self._db.get(destination), default=[]) if not isinstance(dst.value, list): raise SimpleError(msgs.WRONGTYPE_MSG) el = src.value.pop() dst.value.insert(0, el) src.updated() src.writeback() if destination != source: # Ensure writeback only happens once dst.updated() dst.writeback() return el @command(name="BRPOPLPUSH", fixed=(bytes, bytes, Timeout), flags=msgs.FLAG_NO_SCRIPT) def brpoplpush(self, source, destination, timeout): return self._blocking(timeout, functools.partial(self._brpoplpush_pass, source, destination)) @command((Key(list, None), Int)) def lindex(self, key, index): try: return key.value[index] except IndexError: return None @command((Key(list), bytes, bytes, bytes)) def linsert(self, key, where, pivot, value): if not casematch(where, b"before") and not casematch(where, b"after"): raise SimpleError(msgs.SYNTAX_ERROR_MSG) if not key: return 0 else: try: index = key.value.index(pivot) except ValueError: return -1 if casematch(where, b"after"): index += 1 key.value.insert(index, value) key.updated() return len(key.value) @command((Key(list),)) def llen(self, key): return len(key.value) def _lmove(self, first_list, second_list, src, dst, first_pass): if (not casematch(src, b"left") and not casematch(src, b"right")) or ( not casematch(dst, b"left") and not casematch(dst, b"right") ): raise SimpleError(msgs.SYNTAX_ERROR_MSG) el = self.rpop(first_list) if casematch(src, b"RIGHT") else self.lpop(first_list) self.lpush(second_list, el) if casematch(dst, b"LEFT") else self.rpush(second_list, el) return el @command((Key(list, None), Key(list), SimpleString, SimpleString)) def lmove(self, first_list, second_list, src, dst): return self._lmove(first_list, second_list, src, dst, False) @command((Key(list, None), Key(list), SimpleString, SimpleString, Timeout)) def blmove(self, first_list, second_list, src, dst, timeout): return self._blocking(timeout, functools.partial(self._lmove, first_list, second_list, src, dst)) @command(fixed=(Key(),), repeat=(bytes,)) def lpop(self, key, *args): return _list_pop(lambda count: slice(None, count), key, *args) def _lmpop(self, keys, count, direction_left, first_pass): if direction_left: op = lambda count: slice(None, count) # noqa:E731 else: op = lambda count: slice(None, -count - 1, -1) # noqa:E731 for key in keys: item = CommandItem(key, self._db, item=self._db.get(key), default=[]) res = _list_pop_count(op, item, count) if res: return [key, res] return None @command(fixed=(Int,), repeat=(bytes,)) def lmpop(self, numkeys, *args): if numkeys <= 0: raise SimpleError(msgs.NUMKEYS_GREATER_THAN_ZERO_MSG) if casematch(args[-2], b"count"): count = Int.decode(args[-1]) args = args[:-2] else: count = 1 if len(args) != numkeys + 1 or (not casematch(args[-1], b"left") and not casematch(args[-1], b"right")): raise SimpleError(msgs.SYNTAX_ERROR_MSG) return self._lmpop(args[:-1], count, casematch(args[-1], b"left"), False) @command(fixed=(Timeout, Int), repeat=(bytes,)) def blmpop(self, timeout, numkeys, *args): if numkeys <= 0: raise SimpleError(msgs.NUMKEYS_GREATER_THAN_ZERO_MSG) if casematch(args[-2], b"count"): count = Int.decode(args[-1]) args = args[:-2] else: count = 1 if len(args) != numkeys + 1 or (not casematch(args[-1], b"left") and not casematch(args[-1], b"right")): raise SimpleError(msgs.SYNTAX_ERROR_MSG) return self._blocking( timeout, functools.partial(self._lmpop, args[:-1], count, casematch(args[-1], b"left")), ) @command((Key(list), bytes), (bytes,)) def lpush(self, key, *values): for value in values: key.value.insert(0, value) key.updated() return len(key.value) @command((Key(list), bytes), (bytes,)) def lpushx(self, key, *values): if not key: return 0 return self.lpush(key, *values) @command((Key(list), Int, Int)) def lrange(self, key, start, stop): start, stop = fix_range(start, stop, len(key.value)) return key.value[start:stop] @command((Key(list), Int, bytes)) def lrem(self, key, count, value): a_list = key.value found = [] for i, el in enumerate(a_list): if el == value: found.append(i) if count > 0: indices_to_remove = found[:count] elif count < 0: indices_to_remove = found[count:] else: indices_to_remove = found # Iterating in reverse order to ensure the indices # remain valid during deletion. for index in reversed(indices_to_remove): del a_list[index] if indices_to_remove: key.updated() return len(indices_to_remove) @command((Key(list), bytes, bytes)) def lset(self, key, index, value): if not key: raise SimpleError(msgs.NO_KEY_MSG) index = Int.decode(index) try: key.value[index] = value key.updated() except IndexError: raise SimpleError(msgs.INDEX_ERROR_MSG) return OK @command((Key(list), Int, Int)) def ltrim(self, key, start, stop): if key: if stop == -1: stop = None else: stop += 1 new_value = key.value[start:stop] # TODO: check if this should actually be conditional if len(new_value) != len(key.value): key.update(new_value) return OK @command(fixed=(Key(),), repeat=(bytes,)) def rpop(self, key, *args): return _list_pop(lambda count: slice(None, -count - 1, -1), key, *args) @command((Key(list, None), Key(list))) def rpoplpush(self, src, dst): el = self.rpop(src) self.lpush(dst, el) return el @command((Key(list), bytes), (bytes,)) def rpush(self, key, *values): for value in values: key.value.append(value) key.updated() return len(key.value) @command((Key(list), bytes), (bytes,)) def rpushx(self, key, *values): if not key: return 0 return self.rpush(key, *values) @command(fixed=(Key(list), bytes), repeat=(bytes,)) def lpos(self, key, elem, *args): (rank, count, maxlen), _ = extract_args( args, ( "+rank", "+count", "+maxlen", ), ) if rank == 0: raise SimpleError(msgs.LPOS_RANK_CAN_NOT_BE_ZERO) rank = rank or 1 ind, direction = (0, 1) if rank > 0 else (len(key.value) - 1, -1) rank = abs(rank) parse_count = len(key.value) if count == 0 else (count or 1) maxlen = maxlen or len(key.value) res: List[int] = [] comparisons = 0 while 0 <= ind <= len(key.value) - 1 and len(res) < parse_count and comparisons < maxlen: comparisons += 1 if key.value[ind] == elem: if rank > 1: rank -= 1 else: res.append(ind) ind += direction if len(res) == 0 and count is None: return None if len(res) == 1 and count is None: return res[0] return res fakeredis-2.31.0/fakeredis/commands_mixins/pubsub_mixin.py0000644000000000000000000001657213615410400020670 0ustar00from typing import Any, Dict, Callable, List, Iterable from fakeredis import _msgs as msgs from fakeredis._commands import command from fakeredis._helpers import NoResponse, compile_pattern, SimpleError from fakeredis.typing import VersionType class PubSubCommandsMixin: put_response: Callable[[Any], None] def __init__(self, *args: Any, **kwargs: Any) -> None: super(PubSubCommandsMixin, self).__init__(*args, **kwargs) self._pubsub = 0 # Count of subscriptions self._server: Any self.version: VersionType def _subscribe(self, channels: Iterable[bytes], subscribers: Dict[bytes, Any], mtype: bytes) -> NoResponse: for channel in channels: subs = subscribers[channel] if self not in subs: subs.add(self) self._pubsub += 1 msg = [mtype, channel, self._pubsub] self.put_response(msg) return NoResponse() def _unsubscribe(self, channels: Iterable[bytes], subscribers: Dict[bytes, Any], mtype: bytes) -> NoResponse: if not channels: channels = [] for channel, subs in subscribers.items(): if self in subs: channels.append(channel) for channel in channels: subs = subscribers.get(channel, set()) if self in subs: subs.remove(self) if not subs: del subscribers[channel] self._pubsub -= 1 msg = [mtype, channel, self._pubsub] self.put_response(msg) return NoResponse() def _numsub(self, subscribers: Dict[bytes, Any], *channels: bytes) -> List[Any]: tuples_list = [(ch, len(subscribers.get(ch, []))) for ch in channels] return [item for sublist in tuples_list for item in sublist] @command((bytes,), (bytes,), flags=msgs.FLAG_NO_SCRIPT) def psubscribe(self, *patterns: bytes) -> NoResponse: return self._subscribe(patterns, self._server.psubscribers, b"psubscribe") @command((bytes,), (bytes,), flags=msgs.FLAG_NO_SCRIPT) def subscribe(self, *channels: bytes) -> NoResponse: return self._subscribe(channels, self._server.subscribers, b"subscribe") @command((bytes,), (bytes,), flags=msgs.FLAG_NO_SCRIPT) def ssubscribe(self, *channels: bytes) -> NoResponse: return self._subscribe(channels, self._server.ssubscribers, b"ssubscribe") @command((), (bytes,), flags=msgs.FLAG_NO_SCRIPT) def punsubscribe(self, *patterns: bytes) -> NoResponse: return self._unsubscribe(patterns, self._server.psubscribers, b"punsubscribe") @command((), (bytes,), flags=msgs.FLAG_NO_SCRIPT) def unsubscribe(self, *channels: bytes) -> NoResponse: return self._unsubscribe(channels, self._server.subscribers, b"unsubscribe") @command(fixed=(), repeat=(bytes,), flags=msgs.FLAG_NO_SCRIPT) def sunsubscribe(self, *channels: bytes) -> NoResponse: return self._unsubscribe(channels, self._server.ssubscribers, b"sunsubscribe") @command((bytes, bytes)) def publish(self, channel: bytes, message: bytes) -> int: receivers = 0 msg = [b"message", channel, message] subs = self._server.subscribers.get(channel, set()) for sock in subs: sock.put_response(msg) receivers += 1 for pattern, socks in self._server.psubscribers.items(): regex = compile_pattern(pattern) if regex.match(channel): msg = [b"pmessage", pattern, channel, message] for sock in socks: sock.put_response(msg) receivers += 1 return receivers @command((bytes, bytes)) def spublish(self, channel: bytes, message: bytes) -> int: receivers = 0 msg = [b"smessage", channel, message] subs = self._server.ssubscribers.get(channel, set()) for sock in subs: sock.put_response(msg) receivers += 1 for pattern, socks in self._server.psubscribers.items(): regex = compile_pattern(pattern) if regex.match(channel): msg = [b"pmessage", pattern, channel, message] for sock in socks: sock.put_response(msg) receivers += 1 return receivers @command(name="PUBSUB NUMPAT", fixed=(), repeat=()) def pubsub_numpat(self, *_: Any) -> int: return len(self._server.psubscribers) def _channels(self, subscribers_dict: Dict[bytes, Any], *patterns: bytes) -> List[bytes]: channels = list(subscribers_dict.keys()) if len(patterns) > 0: regex = compile_pattern(patterns[0]) channels = [ch for ch in channels if regex.match(ch)] return channels @command(name="PUBSUB CHANNELS", fixed=(), repeat=(bytes,)) def pubsub_channels(self, *args: bytes) -> List[bytes]: return self._channels(self._server.subscribers, *args) @command(name="PUBSUB SHARDCHANNELS", fixed=(), repeat=(bytes,)) def pubsub_shardchannels(self, *args: bytes) -> List[bytes]: return self._channels(self._server.ssubscribers, *args) @command(name="PUBSUB NUMSUB", fixed=(), repeat=(bytes,)) def pubsub_numsub(self, *args: bytes) -> List[Any]: return self._numsub(self._server.subscribers, *args) @command(name="PUBSUB SHARDNUMSUB", fixed=(), repeat=(bytes,)) def pubsub_shardnumsub(self, *args: bytes) -> List[Any]: return self._numsub(self._server.ssubscribers, *args) @command(name="PUBSUB", fixed=()) def pubsub(self, *args: Any) -> None: raise SimpleError(msgs.WRONG_ARGS_MSG6.format("pubsub")) @command(name="PUBSUB HELP", fixed=()) def pubsub_help(self, *args: Any) -> List[bytes]: if self.version >= (7,): help_strings = [ "PUBSUB [ [value] [opt] ...]. Subcommands are:", "CHANNELS []", " Return the currently active channels matching a (default: '*').", "NUMPAT", " Return number of subscriptions to patterns.", "NUMSUB [ ...]", " Return the number of subscribers for the specified channels, excluding", " pattern subscriptions(default: no channels).", "SHARDCHANNELS []", " Return the currently active shard level channels matching a (default: '*').", "SHARDNUMSUB [ ...]", " Return the number of subscribers for the specified shard level channel(s)", "HELP", (" Prints this help." if self.version < (7, 1) else " Print this help."), ] else: help_strings = [ "PUBSUB [ [value] [opt] ...]. Subcommands are:", "CHANNELS []", " Return the currently active channels matching a (default: '*').", "NUMPAT", " Return number of subscriptions to patterns.", "NUMSUB [ ...]", " Return the number of subscribers for the specified channels, excluding", " pattern subscriptions(default: no channels).", "HELP", " Prints this help.", ] return [s.encode() for s in help_strings] fakeredis-2.31.0/fakeredis/commands_mixins/scripting_mixin.py0000644000000000000000000003556213615410400021372 0ustar00import functools import hashlib import importlib import itertools import json import logging import os from typing import Callable, AnyStr, Set, Any, Tuple, List, Dict, Optional import lupa from fakeredis import _msgs as msgs from fakeredis._commands import command, Int, Signature, Float from fakeredis._helpers import ( SimpleError, SimpleString, null_terminate, OK, decode_command_bytes, ) from fakeredis.typing import VersionType, ServerType __LUA_RUNTIMES_MAP = { "5.1": "lupa.lua51", "5.2": "lupa.lua52", "5.3": "lupa.lua53", "5.4": "lupa.lua54", } LUA_VERSION = os.getenv("FAKEREDIS_LUA_VERSION", "5.1") with lupa.allow_lua_module_loading(): LUA_MODULE = importlib.import_module(__LUA_RUNTIMES_MAP[LUA_VERSION]) LOGGER = logging.getLogger("fakeredis") REDIS_LOG_LEVELS = { b"LOG_DEBUG": 0, b"LOG_VERBOSE": 1, b"LOG_NOTICE": 2, b"LOG_WARNING": 3, } REDIS_LOG_LEVELS_TO_LOGGING = { 0: logging.DEBUG, 1: logging.INFO, 2: logging.INFO, 3: logging.WARNING, } def _ensure_str(s: AnyStr, encoding: str, replaceerr: str) -> str: if isinstance(s, bytes): res = s.decode(encoding=encoding, errors=replaceerr) else: res = str(s) return res def _check_for_lua_globals(lua_runtime: LUA_MODULE.LuaRuntime, expected_globals: Set[Any]) -> None: unexpected_globals = set(lua_runtime.globals().keys()) - expected_globals if len(unexpected_globals) > 0: unexpected = [_ensure_str(var, "utf-8", "replace") for var in unexpected_globals] raise SimpleError(msgs.GLOBAL_VARIABLE_MSG.format(", ".join(unexpected))) def _lua_redis_log(lua_runtime: LUA_MODULE.LuaRuntime, expected_globals: Set[Any], lvl: int, *args: Any) -> None: _check_for_lua_globals(lua_runtime, expected_globals) if len(args) < 1: raise SimpleError(msgs.REQUIRES_MORE_ARGS_MSG.format("redis.log()", "two")) if lvl not in REDIS_LOG_LEVELS_TO_LOGGING.keys(): raise SimpleError(msgs.LOG_INVALID_DEBUG_LEVEL_MSG) msg = " ".join([x.decode("utf-8") if isinstance(x, bytes) else str(x) for x in args if not isinstance(x, bool)]) LOGGER.log(REDIS_LOG_LEVELS_TO_LOGGING[lvl], msg) _lua_cjson_null = object() # sentinel value def _cjson_python_to_lua(obj: Any) -> Any: """Convert a pure python object obtained after JSON deserialization into a usable object in the lua runtime.""" if obj is None: return _lua_cjson_null if isinstance(obj, str): return obj.encode() if isinstance(obj, list): return [_cjson_python_to_lua(item) for item in obj] if isinstance(obj, dict): return {_cjson_python_to_lua(key): _cjson_python_to_lua(value) for key, value in obj.items()} return obj def _cjson_lua_to_python(obj: Any) -> Any: """Convert a passed lua runtime object obtained before JSON serialization into a pure python object.""" if obj is _lua_cjson_null: return None if isinstance(obj, bytes): return obj.decode() lua_type = LUA_MODULE.lua_type(obj) if lua_type != "table": return obj # Check for array-like structure: integer keys from 1 to len(items) # (this check matches what cjson does, e.g. tables like {"a", "b", c=3} are treated as dicts # with int keys for the array-like parts) keys = list(obj.keys()) is_array = all(isinstance(k, int) for k in keys) and sorted(keys) == list(range(1, len(keys) + 1)) if is_array: return [_cjson_lua_to_python(item) for item in obj.values()] # We're working with a dict d = dict(obj) return {_cjson_lua_to_python(key): _cjson_lua_to_python(value) for key, value in d.items()} def _lua_cjson_encode(lua_runtime: LUA_MODULE.LuaRuntime, expected_globals: Set[Any], value: Any) -> bytes: _check_for_lua_globals(lua_runtime, expected_globals) value = _cjson_lua_to_python(value) return json.dumps(value, separators=(",", ":")).encode() def _lua_cjson_decode(lua_runtime: LUA_MODULE.LuaRuntime, expected_globals: Set[Any], json_str: str) -> Any: _check_for_lua_globals(lua_runtime, expected_globals) json_obj = json.loads(json_str) json_obj = _cjson_python_to_lua(json_obj) if isinstance(json_obj, (dict, list)): json_obj = lua_runtime.table_from(json_obj, recursive=True) return json_obj class ScriptingCommandsMixin: _name_to_func: Callable[[str], Tuple[Optional[Callable[..., Any]], Signature]] _run_command: Callable[[Callable[..., Any], Signature, List[Any], bool], Any] def __init__(self, *args: Any, **kwargs: Any): self.script_cache: Dict[bytes, bytes] = dict() # Maps SHA1 to the script source self.server_type: ServerType self.version: VersionType self.load_lua_modules = set() lua_modules_set: Set[str] = kwargs.pop("lua_modules", None) or set() if len(lua_modules_set) > 0: lua_runtime: LUA_MODULE.LuaRuntime = LUA_MODULE.LuaRuntime(encoding=None, unpack_returned_tuples=True) for module in lua_modules_set: try: lua_runtime.require(module.encode()) self.load_lua_modules.add(module) except LUA_MODULE.LuaError as ex: LOGGER.error(f'Failed to load LUA module "{module}", make sure it is installed: {ex}') super(ScriptingCommandsMixin, self).__init__(*args, **kwargs) def _convert_redis_arg(self, lua_runtime: LUA_MODULE.LuaRuntime, value: Any) -> bytes: # Type checks are exact to avoid issues like bool being a subclass of int. if type(value) is bytes: return value elif type(value) in {int, float}: return "{:.17g}".format(value).encode() else: raise SimpleError(msgs.LUA_COMMAND_ARG_MSG) def _convert_redis_result(self, lua_runtime: LUA_MODULE.LuaRuntime, result: Any) -> Any: if isinstance(result, (bytes, int)): return result if isinstance(result, float): return Float.encode(result, humanfriendly=False) elif isinstance(result, SimpleString): return lua_runtime.table_from({b"ok": result.value}) elif result is None: return False elif isinstance(result, list): converted = [self._convert_redis_result(lua_runtime, item) for item in result] return lua_runtime.table_from(converted) if isinstance(result, dict): result = list(itertools.chain(*result.items())) converted = [self._convert_redis_result(lua_runtime, item) for item in result] return lua_runtime.table_from(converted) elif isinstance(result, SimpleError): if result.value.startswith("ERR wrong number of arguments"): raise SimpleError(msgs.WRONG_ARGS_MSG7) raise result else: raise RuntimeError("Unexpected return type from redis: {}".format(type(result))) def _convert_lua_result(self, result: Any, nested: bool = True) -> Any: if LUA_MODULE.lua_type(result) == "table": for key in (b"ok", b"err"): if key in result: msg = self._convert_lua_result(result[key]) if not isinstance(msg, bytes): raise SimpleError(msgs.LUA_WRONG_NUMBER_ARGS_MSG) if key == b"ok": return SimpleString(msg) elif nested: return SimpleError(msg.decode("utf-8", "replace")) else: raise SimpleError(msg.decode("utf-8", "replace")) # Convert Lua tables into lists, starting from index 1, mimicking the behavior of StrictRedis. result_list = [] for index in itertools.count(1): if index not in result: break item = result[index] result_list.append(self._convert_lua_result(item)) return result_list elif isinstance(result, str): return result.encode() elif isinstance(result, float): return int(result) elif isinstance(result, bool): return 1 if result else None return result def _lua_redis_call( self, lua_runtime: LUA_MODULE.LuaRuntime, expected_globals: Set[Any], op: bytes, *args: Any ) -> Any: # Check if we've set any global variables before making any change. _check_for_lua_globals(lua_runtime, expected_globals) func, sig = self._name_to_func(decode_command_bytes(op)) new_args = [self._convert_redis_arg(lua_runtime, arg) for arg in args] result = self._run_command(func, sig, new_args, True) result = self._convert_redis_result(lua_runtime, result) return result def _lua_redis_pcall( self, lua_runtime: LUA_MODULE.LuaRuntime, expected_globals: Set[Any], op: bytes, *args: Any ) -> Any: try: return self._lua_redis_call(lua_runtime, expected_globals, op, *args) except Exception as ex: return lua_runtime.table_from({b"err": str(ex)}) @command((bytes, Int), (bytes,), flags=msgs.FLAG_NO_SCRIPT) def eval(self, script: bytes, numkeys: int, *keys_and_args: bytes) -> Any: if numkeys > len(keys_and_args): raise SimpleError(msgs.TOO_MANY_KEYS_MSG) if numkeys < 0: raise SimpleError(msgs.NEGATIVE_KEYS_MSG) sha1 = hashlib.sha1(script).hexdigest().encode() self.script_cache[sha1] = script lua_runtime: LUA_MODULE.LuaRuntime = LUA_MODULE.LuaRuntime(encoding=None, unpack_returned_tuples=True) modules_import_str = "\n".join([f"{module} = require('{module}')" for module in self.load_lua_modules]) set_globals = lua_runtime.eval( f""" function(keys, argv, redis_call, redis_pcall, redis_log, redis_log_levels, cjson_encode, cjson_decode, cjson_null) redis = {{}} redis.call = redis_call redis.pcall = redis_pcall redis.log = redis_log for level, pylevel in python.iterex(redis_log_levels.items()) do redis[level] = pylevel end redis.error_reply = function(msg) return {{err=msg}} end redis.status_reply = function(msg) return {{ok=msg}} end cjson = {{}} cjson.encode = cjson_encode cjson.decode = cjson_decode cjson.null = cjson_null KEYS = keys ARGV = argv {modules_import_str} end """ ) expected_globals: Set[Any] = set() set_globals( lua_runtime.table_from(keys_and_args[:numkeys]), lua_runtime.table_from(keys_and_args[numkeys:]), functools.partial(self._lua_redis_call, lua_runtime, expected_globals), functools.partial(self._lua_redis_pcall, lua_runtime, expected_globals), functools.partial(_lua_redis_log, lua_runtime, expected_globals), LUA_MODULE.as_attrgetter(REDIS_LOG_LEVELS), functools.partial(_lua_cjson_encode, lua_runtime, expected_globals), functools.partial(_lua_cjson_decode, lua_runtime, expected_globals), _lua_cjson_null, ) expected_globals.update(lua_runtime.globals().keys()) try: result = lua_runtime.execute(script) except SimpleError as ex: if ex.value == msgs.LUA_COMMAND_ARG_MSG: if self.version < (7,): raise SimpleError(msgs.LUA_COMMAND_ARG_MSG6) elif self.server_type == "valkey": raise SimpleError(msgs.VALKEY_LUA_COMMAND_ARG_MSG.format(sha1.decode())) else: raise SimpleError(msgs.LUA_COMMAND_ARG_MSG) if self.version < (7,): raise SimpleError(msgs.SCRIPT_ERROR_MSG.format(sha1.decode(), ex)) raise SimpleError(ex.value) except LUA_MODULE.LuaError as ex: raise SimpleError(msgs.SCRIPT_ERROR_MSG.format(sha1.decode(), ex)) _check_for_lua_globals(lua_runtime, expected_globals) return self._convert_lua_result(result, nested=False) @command(name="EVALSHA", fixed=(bytes, Int), repeat=(bytes,), flags=msgs.FLAG_NO_SCRIPT) def evalsha(self, sha1: bytes, numkeys: Int, *keys_and_args: bytes) -> Any: try: script = self.script_cache[sha1] except KeyError: raise SimpleError(msgs.NO_MATCHING_SCRIPT_MSG) return self.eval(script, numkeys, *keys_and_args) @command(name="SCRIPT LOAD", fixed=(bytes,), repeat=(bytes,), flags=msgs.FLAG_NO_SCRIPT) def script_load(self, *args: bytes) -> bytes: if len(args) != 1: raise SimpleError(msgs.BAD_SUBCOMMAND_MSG.format("SCRIPT")) script = args[0] sha1 = hashlib.sha1(script).hexdigest().encode() self.script_cache[sha1] = script return sha1 @command(name="SCRIPT EXISTS", fixed=(), repeat=(bytes,), flags=msgs.FLAG_NO_SCRIPT) def script_exists(self, *args: bytes) -> List[int]: if self.version >= (7,) and len(args) == 0: raise SimpleError(msgs.WRONG_ARGS_MSG7) return [int(sha1 in self.script_cache) for sha1 in args] @command(name="SCRIPT FLUSH", fixed=(), repeat=(bytes,), flags=msgs.FLAG_NO_SCRIPT) def script_flush(self, *args: bytes) -> SimpleString: if len(args) > 1 or (len(args) == 1 and null_terminate(args[0]) not in {b"sync", b"async"}): raise SimpleError(msgs.BAD_SUBCOMMAND_MSG.format("SCRIPT")) self.script_cache = {} return OK @command((), flags=msgs.FLAG_NO_SCRIPT) def script(self, *args: bytes) -> None: raise SimpleError(msgs.BAD_SUBCOMMAND_MSG.format("SCRIPT")) @command(name="SCRIPT HELP", fixed=()) def script_help(self, *args: bytes) -> List[bytes]: help_strings = [ "SCRIPT [ [value] [opt] ...]. Subcommands are:", "DEBUG (YES|SYNC|NO)", " Set the debug mode for subsequent scripts executed.", "EXISTS [ ...]", " Return information about the existence of the scripts in the script cache.", "FLUSH [ASYNC|SYNC]", " Flush the Lua scripts cache. Very dangerous on replicas.", " When called without the optional mode argument, the behavior is determined by the", " lazyfree-lazy-user-flush configuration directive. Valid modes are:", " * ASYNC: Asynchronously flush the scripts cache.", " * SYNC: Synchronously flush the scripts cache.", "KILL", " Kill the currently executing Lua script.", "LOAD