|
3 | 3 | import socket
|
4 | 4 | from collections import OrderedDict
|
5 | 5 | from contextlib import suppress
|
6 |
| -from typing import Any, Dict, Iterable, Iterator, List, Optional, Tuple, Union |
| 6 | +from typing import Any, Dict, Iterable, Iterator, List, Optional, Tuple, Union, Set |
7 | 7 |
|
8 | 8 | from django.conf import settings
|
9 | 9 | from django.core.cache.backends.base import DEFAULT_TIMEOUT, BaseCache, get_key_func
|
@@ -778,6 +778,246 @@ def make_pattern(
|
778 | 778 |
|
779 | 779 | return CacheKey(self._backend.key_func(pattern, prefix, version_str))
|
780 | 780 |
|
| 781 | + def sadd( |
| 782 | + self, |
| 783 | + key: Any, |
| 784 | + *values: Any, |
| 785 | + version: Optional[int] = None, |
| 786 | + client: Optional[Redis] = None, |
| 787 | + ) -> int: |
| 788 | + if client is None: |
| 789 | + client = self.get_client(write=True) |
| 790 | + |
| 791 | + key = self.make_key(key, version=version) |
| 792 | + values = [self.encode(value) for value in values] |
| 793 | + return int(client.sadd(key, *values)) |
| 794 | + |
| 795 | + def scard( |
| 796 | + self, |
| 797 | + key: Any, |
| 798 | + version: Optional[int] = None, |
| 799 | + client: Optional[Redis] = None, |
| 800 | + ) -> int: |
| 801 | + if client is None: |
| 802 | + client = self.get_client(write=False) |
| 803 | + |
| 804 | + key = self.make_key(key, version=version) |
| 805 | + return int(client.scard(key)) |
| 806 | + |
| 807 | + def sdiff( |
| 808 | + self, |
| 809 | + *keys, |
| 810 | + version: Optional[int] = None, |
| 811 | + client: Optional[Redis] = None, |
| 812 | + ) -> set: |
| 813 | + if client is None: |
| 814 | + client = self.get_client(write=False) |
| 815 | + |
| 816 | + keys = [self.make_key(key, version=version) for key in keys] |
| 817 | + return {self.decode(value) for value in client.sdiff(*keys)} |
| 818 | + |
| 819 | + def sdiffstore( |
| 820 | + self, |
| 821 | + dest: Any, |
| 822 | + *keys, |
| 823 | + version_dest: Optional[int] = None, |
| 824 | + version_keys: Optional[int] = None, |
| 825 | + client: Optional[Redis] = None, |
| 826 | + ) -> int: |
| 827 | + if client is None: |
| 828 | + client = self.get_client(write=True) |
| 829 | + |
| 830 | + dest = self.make_key(dest, version=version_dest) |
| 831 | + keys = [self.make_key(key, version=version_keys) for key in keys] |
| 832 | + return int(client.sdiffstore(dest, *keys)) |
| 833 | + |
| 834 | + def sinter( |
| 835 | + self, |
| 836 | + *keys, |
| 837 | + version: Optional[int] = None, |
| 838 | + client: Optional[Redis] = None, |
| 839 | + ) -> set: |
| 840 | + if client is None: |
| 841 | + client = self.get_client(write=False) |
| 842 | + |
| 843 | + keys = [self.make_key(key, version=version) for key in keys] |
| 844 | + return {self.decode(value) for value in client.sinter(*keys)} |
| 845 | + |
| 846 | + def sinterstore( |
| 847 | + self, |
| 848 | + dest: Any, |
| 849 | + *keys, |
| 850 | + version: Optional[int] = None, |
| 851 | + client: Optional[Redis] = None, |
| 852 | + ) -> int: |
| 853 | + if client is None: |
| 854 | + client = self.get_client(write=True) |
| 855 | + |
| 856 | + dest = self.make_key(dest, version=version) |
| 857 | + keys = [self.make_key(key, version=version) for key in keys] |
| 858 | + return int(client.sinterstore(dest, *keys)) |
| 859 | + |
| 860 | + def smismember( |
| 861 | + self, |
| 862 | + key: Any, |
| 863 | + *members, |
| 864 | + version: Optional[int] = None, |
| 865 | + client: Optional[Redis] = None, |
| 866 | + ) -> bool: |
| 867 | + if client is None: |
| 868 | + client = self.get_client(write=False) |
| 869 | + |
| 870 | + key = self.make_key(key, version=version) |
| 871 | + encoded_members = [self.encode(member) for member in members] |
| 872 | + |
| 873 | + return [bool(value) for value in client.smismember(key, *encoded_members)] |
| 874 | + |
| 875 | + def sismember( |
| 876 | + self, |
| 877 | + key: Any, |
| 878 | + member: Any, |
| 879 | + version: Optional[int] = None, |
| 880 | + client: Optional[Redis] = None, |
| 881 | + ) -> bool: |
| 882 | + if client is None: |
| 883 | + client = self.get_client(write=False) |
| 884 | + |
| 885 | + key = self.make_key(key, version=version) |
| 886 | + member = self.encode(member) |
| 887 | + return bool(client.sismember(key, member)) |
| 888 | + |
| 889 | + def smembers( |
| 890 | + self, |
| 891 | + key: Any, |
| 892 | + version: Optional[int] = None, |
| 893 | + client: Optional[Redis] = None, |
| 894 | + ) -> set: |
| 895 | + if client is None: |
| 896 | + client = self.get_client(write=False) |
| 897 | + |
| 898 | + key = self.make_key(key, version=version) |
| 899 | + return {self.decode(value) for value in client.smembers(key)} |
| 900 | + |
| 901 | + def smove( |
| 902 | + self, |
| 903 | + source: Any, |
| 904 | + destination: Any, |
| 905 | + member: Any, |
| 906 | + version: Optional[int] = None, |
| 907 | + client: Optional[Redis] = None, |
| 908 | + ) -> bool: |
| 909 | + if client is None: |
| 910 | + client = self.get_client(write=True) |
| 911 | + |
| 912 | + source = self.make_key(source, version=version) |
| 913 | + destination = self.make_key(destination) |
| 914 | + member = self.encode(member) |
| 915 | + return bool(client.smove(source, destination, member)) |
| 916 | + |
| 917 | + def spop( |
| 918 | + self, |
| 919 | + key: Any, |
| 920 | + count: Optional[int] = None, |
| 921 | + version: Optional[int] = None, |
| 922 | + client: Optional[Redis] = None, |
| 923 | + ) -> Union[set, Any]: |
| 924 | + if client is None: |
| 925 | + client = self.get_client(write=True) |
| 926 | + |
| 927 | + key = self.make_key(key, version=version) |
| 928 | + result = client.spop(key, count) |
| 929 | + if type(result) == list: |
| 930 | + return {self.decode(value) for value in result} |
| 931 | + return self.decode(result) |
| 932 | + |
| 933 | + def srandmember( |
| 934 | + self, |
| 935 | + key: Any, |
| 936 | + count: Optional[int] = None, |
| 937 | + version: Optional[int] = None, |
| 938 | + client: Optional[Redis] = None, |
| 939 | + ) -> Union[set, Any]: |
| 940 | + if client is None: |
| 941 | + client = self.get_client(write=False) |
| 942 | + |
| 943 | + key = self.make_key(key, version=version) |
| 944 | + result = client.srandmember(key, count) |
| 945 | + if type(result) == list: |
| 946 | + return {self.decode(value) for value in result} |
| 947 | + return self.decode(result) |
| 948 | + |
| 949 | + def srem( |
| 950 | + self, |
| 951 | + key: Any, |
| 952 | + *members, |
| 953 | + version: Optional[int] = None, |
| 954 | + client: Optional[Redis] = None, |
| 955 | + ) -> int: |
| 956 | + if client is None: |
| 957 | + client = self.get_client(write=True) |
| 958 | + |
| 959 | + key = self.make_key(key, version=version) |
| 960 | + members = [self.decode(member) for member in members] |
| 961 | + return int(client.srem(key, *members)) |
| 962 | + |
| 963 | + def sscan( |
| 964 | + self, |
| 965 | + key: Any, |
| 966 | + match: Optional[str] = None, |
| 967 | + count: Optional[int] = None, |
| 968 | + version: Optional[int] = None, |
| 969 | + client: Optional[Redis] = None, |
| 970 | + ) -> Set[Any]: |
| 971 | + if client is None: |
| 972 | + client = self.get_client(write=False) |
| 973 | + |
| 974 | + key = self.make_key(key, version=version) |
| 975 | + |
| 976 | + cursor, result = client.sscan(key, match=self.encode(match), count=count) |
| 977 | + return {self.decode(value) for value in result} |
| 978 | + |
| 979 | + def sscan_iter( |
| 980 | + self, |
| 981 | + key: Any, |
| 982 | + match: Optional[str] = None, |
| 983 | + count: Optional[int] = None, |
| 984 | + version: Optional[int] = None, |
| 985 | + client: Optional[Redis] = None, |
| 986 | + ) -> Iterator[Any]: |
| 987 | + if client is None: |
| 988 | + client = self.get_client(write=False) |
| 989 | + |
| 990 | + key = self.make_key(key, version=version) |
| 991 | + for value in client.sscan_iter(key, match=match, count=count): |
| 992 | + yield self.decode(value) |
| 993 | + |
| 994 | + |
| 995 | + def sunion( |
| 996 | + self, |
| 997 | + *keys, |
| 998 | + version: Optional[int] = None, |
| 999 | + client: Optional[Redis] = None, |
| 1000 | + ) -> set: |
| 1001 | + if client is None: |
| 1002 | + client = self.get_client(write=False) |
| 1003 | + |
| 1004 | + keys = [self.make_key(key, version=version) for key in keys] |
| 1005 | + return {self.decode(value) for value in client.sunion(*keys)} |
| 1006 | + |
| 1007 | + def sunionstore( |
| 1008 | + self, |
| 1009 | + destination: Any, |
| 1010 | + *keys, |
| 1011 | + version: Optional[int] = None, |
| 1012 | + client: Optional[Redis] = None, |
| 1013 | + ) -> int: |
| 1014 | + if client is None: |
| 1015 | + client = self.get_client(write=True) |
| 1016 | + |
| 1017 | + destination = self.make_key(destination, version=version) |
| 1018 | + keys = [self.make_key(key, version=version) for key in keys] |
| 1019 | + return int(client.sunionstore(destination, *keys)) |
| 1020 | + |
781 | 1021 | def close(self) -> None:
|
782 | 1022 | close_flag = self._options.get(
|
783 | 1023 | "CLOSE_CONNECTION",
|
|
0 commit comments