ng\jV% %SrSSKJr SSKrSSKrSSKrSSKrSSKJrJ r SSK J r SSK J r SSKJr SSKJrJrJrJr SS KJr SS KJr SS KJrJrJr SS KJr \R>"\ 5r!\(aSS KJ"r" \\#\$SSSSSS4r%S\&S'\ S/S4r'"SS5r(S/Sjr)\ "SS55r*"SS5r+"SS5r,"SS5r-"SS5r."SS5r/"S S5r0"S!S"\5r1S0S#jr2S1S$jr3"S%S&\5r4"S'S(\45r5"S)S*\Rl5r7"S+S,\55r8"S-S.\55r9g)2a= Redis Keyspace Notifications support for redis-py. This module provides utilities for subscribing to and parsing Redis keyspace notifications. Keyspace notifications allow clients to receive events when keys are modified in Redis. Note: Keyspace notifications must be enabled on the Redis server via the ``notify-keyspace-events`` configuration option. This is a server-side configuration that should be done by your infrastructure/operations team. See the Redis documentation for details: https://redis.io/docs/latest/develop/pubsub/keyspace-notifications/ Standalone Redis Example: >>> from redis import Redis >>> from redis.keyspace_notifications import ( ... KeyspaceNotifications, ... KeyspaceChannel, ... EventType, ... ) >>> >>> r = Redis() >>> # Server must have notify-keyspace-events configured (e.g., "KEA") >>> ksn = KeyspaceNotifications(r) >>> >>> # Subscribe using Channel class (patterns auto-detected) >>> channel = KeyspaceChannel("user:*") >>> ksn.subscribe(channel) >>> >>> # Or use convenience methods for specific event types >>> ksn.subscribe_keyevent(EventType.SET) >>> >>> for notification in ksn.listen(): ... print(f"Key: {notification.key}, Event: {notification.event_type}") Redis Cluster Example: >>> from redis.cluster import RedisCluster >>> from redis.keyspace_notifications import ( ... ClusterKeyspaceNotifications, ... KeyspaceChannel, ... EventType, ... ) >>> >>> rc = RedisCluster(host="localhost", port=7000) >>> # Server must have notify-keyspace-events configured (e.g., "KEA") >>> ksn = ClusterKeyspaceNotifications(rc) >>> >>> # Subscribe using Channel class (patterns auto-detected) >>> channel = KeyspaceChannel("user:*") >>> ksn.subscribe(channel) >>> >>> # Or use convenience methods for specific event types >>> ksn.subscribe_keyevent(EventType.SET) >>> >>> for notification in ksn.listen(): ... print(f"Key: {notification.key}, Event: {notification.event_type}") ) annotationsN)ABCabstractmethod)Callable) dataclass)Enum) TYPE_CHECKINGAnyClassVarUnion)Redis) RedisCluster)ConnectionError RedisError TimeoutError)safe_str) TypeAliasKeyspaceChannelKeyeventChannelSubkeyspaceChannelSubkeyeventChannelSubkeyspaceitemChannelSubkeyspaceeventChannelrChannelTKeyNotificationc`\rSrSrSrSrSrSrSrSr Sr S r S r S r S rS rSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSrSr Sr!S r"S!r#S"r$S#r%S$r&S%r'S&r(S'r)S(r*S)r+S*r,S+r-S,r.S-r/S.r0S/r1S0r2S1r3S2r4S3r5S4r6S5r7S6r8S7r9S8r:S9r;S:rS=r?S>r@S?rAS@rBSArCSBrDSCrESDrFSErGSFrHSGrISHrJSIrKSJrLSKrMSLrNSMrOSNrPSOrQSPrRSQrSSRrTSSrUSTrVSUrWgV)W EventTypeoz Common Redis keyspace notification event type constants. These are provided for convenience and IDE autocomplete. You can use any string as an event type - new Redis events will work without needing library updates. setsetexsetnxsetrangeincrincrby incrbyfloatdecrdecrbyappenddelunlinkrename rename_from rename_tocopy_tomoverestoreexpireexpireatpexpire pexpireatexpiredpersistevictedlpushrpushlpoprpoplinsertlsetltrimlmoveblpopbrpopblmovesaddsremspopsmove sinterstore sunionstore sdiffstorezaddzincrbyzremzremrangebyrankzremrangebyscorezremrangebylexzpopminzpopmaxbzpopminbzpopmax zinterstore zunionstore zdiffstore zrangestorehsethsetnxhdelhincrby hincrbyfloatxaddxtrimxdelz xgroup-createzxgroup-createconsumerzxgroup-delconsumerzxgroup-destroyz xgroup-setidxsetidxclaim xautoclaim xreadgroupnew sortstoregetexgetdelsetifgtsetifltsetifeqsetifneN)X__name__ __module__ __qualname____firstlineno____doc__SETSETEXSETNXSETRANGEINCRINCRBY INCRBYFLOATDECRDECRBYAPPENDDELUNLINKRENAME RENAME_FROM RENAME_TOCOPY_TOMOVERESTOREEXPIREEXPIREATPEXPIRE PEXPIREATEXPIREDPERSISTEVICTEDLPUSHRPUSHLPOPRPOPLINSERTLSETLTRIMLMOVEBLPOPBRPOPBLMOVESADDSREMSPOPSMOVE SINTERSTORE SUNIONSTORE SDIFFSTOREZADDZINCRBYZREMZREMRANGEBYRANKZREMRANGEBYSCOREZREMRANGEBYLEXZPOPMINZPOPMAXBZPOPMINBZPOPMAX ZINTERSTORE ZUNIONSTORE ZDIFFSTORE ZRANGESTOREHSETHSETNXHDELHINCRBY HINCRBYFLOATXADDXTRIMXDEL XGROUP_CREATEXGROUP_CREATECONSUMERXGROUP_DELCONSUMERXGROUP_DESTROY XGROUP_SETIDXSETIDXCLAIM XAUTOCLAIM XREADGROUPNEW SORTSTOREGETEXGETDELSETIFGTSETIFLTSETIFEQSETIFNE__static_attributes__rlW/home/edenadmin/noVNC/venv/lib/python3.13/site-packages/redis/keyspace_notifications.pyrros C E EH D FK D F F C F FKIG DGFHGIGGG E E D DG D E E E E F D D D EKKJ DG D'O)%NGGHHKKJK D F DG!L D E D#M3-%N!L F FJJ CI E FGGGGrrc/nSnU[U5:ajURSU5n[XU5nUS-nURXXT-5 XT-nU[U5:a XS:XaUS- nU[U5:aMjU$)zParse a length-prefixed subkey list. The wire format is ``:[,:...]``. Returns: A list of subkey strings. r:,)lenindexintr()ssubkeysposcolonlengthstarts r_parse_length_prefixed_subkeysrsG C A,S!Q5\" q01n Q>> message = { ... 'type': 'pmessage', ... 'pattern': '__keyspace@0__:user:*', ... 'channel': '__keyspace@0__:user:123', ... 'data': 'set' ... } >>> notification = KeyNotification.from_message(message) >>> notification.key 'user:123' >>> notification.event_type 'set' Ntype)messagepmessagerr)get try_parse)clsr key_prefixmsg_typerrs r from_messageKeyNotification.from_message+s`B ?;;v& 2 2++i({{6" ?dl}}WJ77rcR[U5n[U5nURXU5$)a Try to parse a channel and data into a KeyNotification. This is a lower-level method that takes the channel and data directly, useful when working with callback-based subscription handlers. Args: channel: The channel name (e.g., "__keyspace@0__:mykey") data: The message data (event type for keyspace, key for keyevent) key_prefix: Optional prefix to filter and strip from keys Returns: A KeyNotification if valid, None otherwise. )r_parse)rrrrs rrKeyNotification.try_parse[s(*7#~zz'44rc U(a [U5OSnURRU5nU(a^UR5upVUS:wa [ U5OSnUnU(a%UR U5(dgU[ U5SnU"UUUUSUS9$URRU5nU(a^UR5upXUS:wa [ U5OSnUnU(a%UR U5(dgU[ U5SnU"UUUUSUS9$URRU5nU(aUR5upVUS:wa [ U5OSnURS5n USU n[X)S-S5n U(a%UR U5(dgU[ U5SnU"UUUUSUU S 9$URRU5nU(aUR5upXUS:wa [ U5OSnURS 5n [ USU 5n U S-n X-X-nX-S-n[X.S5n U(a%UR U5(dgU[ U5SnU"UUUUSUU S 9$URRU5nU(a~UR5up_US:wa [ U5OSnURS 5nUSUnUUS-SnUnU(a%UR U5(dgU[ U5SnU"UUUUSUU/S 9$URRU5nU(aUR5unnUS:wa [ U5OSnURS5n USU nUU S-Sn[U5n U(a%UR U5(dgU[ U5SnU"UUUUSUU S 9$g) zInternal parsing logic.N*T)rrrrrrF|r)rrrrrrrr )rrmatchgroupsr startswithrrrrrrrr)rrrrrdb_strrrrpipe_idxr colon_idxkey_len key_start subkeys_startkey_and_subkey newline_idxsubkey event_and_keys rrKeyNotification._parseus.8Xj)T %%++G4 ,,.KF&,ms6{HJ~~j11#j/+,%!   %%++G4 !& F&,ms6{HC~~j11#j/+,%!!  ((..w7 ,,.KF&,ms6{Hzz#HixJ4TQ,.5IJG~~j11#j/+,%!  ((..w7 !& F&,ms6{H 3I$z *+G!A I9#67C%/!3M4T.5IJG~~j11#j/+,%!! ,,227; %*\\^ "F&,ms6{H(..t4K +.C#K!O$56FJ~~j11#j/+,%!  --33G< $)LLN !FM&,ms6{H$**3/H&y1J1 /C4T:G~~j11#j/+,%!! rcN[U5nURRU5$)z.Check if the key starts with the given prefix.)rrr)rprefixs rkey_starts_withKeyNotification.key_starts_withs!&!xx""6**rrr)rzdict[str, Any] | Nonerstr | bytes | NonereturnKeyNotification | None)r str | bytesrrrrrr)rrrrrrrr)rrrr)rmrnrorprqrecompiler__annotations__rrrDOTALLrrrr classmethodrrrrrrlrrrrs,/1jj'/+/1jj'/+24*2.24*2.68ZZ. 6279jj/73 HOM L IGY*.-8&-8'-8 -8-8^ *. 555' 5 552 *. aaa' a aaF+rc|\rSrSr%SrSrS\S'SSSjjrSSjr\ SSj5r SS jr SS jr SS jr SS jrS rg)ri$a Represents a keyspace notification channel for subscribing to events on keys. Keyspace notifications publish the event type (e.g., "set", "del") as the message when a key matching the pattern is modified. This class can be used directly with subscribe()/psubscribe() as it implements __str__ to return the channel string. Attributes: key_or_pattern: The key or pattern to monitor (use '*' for wildcards) db: The database number (defaults to 0, the only database in Redis Cluster) is_pattern: Whether this channel contains wildcards Examples: >>> channel = KeyspaceChannel("user:123", db=0) >>> str(channel) '__keyspace@0__:user:123' >>> # Pattern subscription (wildcards are auto-detected) >>> channel = KeyspaceChannel("user:*", db=0) >>> str(channel) '__keyspace@0__:user:*' >>> # Use with KeyspaceNotifications >>> notifications = KeyspaceNotifications(redis_client) >>> notifications.subscribe(channel) z __keyspace@ ClassVar[str]PREFIXcFXlX lUR5Ulg)z Create a keyspace notification channel. Args: key_or_pattern: The key or pattern to monitor. Use '*' for wildcards. db: The database number. Defaults to 0 (the only database in Redis Cluster). Nkey_or_patterndb_build_channel_string _channel_strrr r!s r__init__KeyspaceChannel.__init__Ds - 668rcPURURSUR3$N__:rr!r rs rr"%KeyspaceChannel._build_channel_stringP&++twwis4+>+>*?@@rc,[UR5$zCCheck if this channel contains wildcards and should use psubscribe. _is_patternr rs r is_patternKeyspaceChannel.is_patternSs4..//rcUR$rr#rs r__str__KeyspaceChannel.__str__X   rc>SUR<SURS3$)NzKeyspaceChannel(, db=)r r!rs r__repr__KeyspaceChannel.__repr__[s"!$"5"5!8dggYaHHrc[U[5(aURUR:H$[U[5(aURU:H$[$r) isinstancerr#rNotImplementedrothers r__eq__KeyspaceChannel.__eq__^J e_ - -$$(:(:: : eS ! !$$- -rc,[UR5$rhashr#rs r__hash__KeyspaceChannel.__hash__eD%%&&rr#r!r Nrr rr!rrrrrrBobjectrrrrrmrnrorprqrrr%r"propertyr1r5r<rCrIrrlrrrr$sG:*FM) 9A00!I'rc\rSrSr%SrSrS\S'SSSjjrSSjr\ SSj5r \ SSS jj5r SS jr SS jrSS jrSS jrSrg)riiaH Represents a keyevent notification channel for subscribing to event types. Keyevent notifications publish the key name as the message when the specified event type occurs on any key. This class can be used directly with subscribe()/psubscribe() as it implements __str__ to return the channel string. Attributes: event: The event type to monitor db: The database number (defaults to 0, the only database in Redis Cluster) is_pattern: Whether this channel contains wildcards Examples: >>> channel = KeyeventChannel(EventType.SET, db=0) >>> str(channel) '__keyevent@0__:set' >>> channel = KeyeventChannel.all_events(db=0) >>> str(channel) '__keyevent@0__:*' >>> # Use with KeyspaceNotifications >>> notifications = KeyspaceNotifications(redis_client) >>> notifications.subscribe(channel) z __keyevent@rrcFXlX lUR5Ulg)z Create a keyevent notification channel. Args: event: The event type to monitor (e.g., EventType.SET or "set") db: The database number. Defaults to 0 (the only database in Redis Cluster). Neventr!r"r#rrYr!s rr%KeyeventChannel.__init__s  668rcPURURSUR3$r(rr!rYrs rr"%KeyeventChannel._build_channel_string#++twwis4::,77rc,[UR5$r.r0rYrs rr1KeyeventChannel.is_patterns4::&&rcU"SUS9$)al Create a keyevent pattern for subscribing to all event types. This is equivalent to KeyeventChannel("*"). Args: db: The database number. Defaults to 0 (the only database in Redis Cluster). Returns: A KeyeventChannel configured to receive all events. Examples: >>> channel = KeyeventChannel.all_events() >>> str(channel) '__keyevent@0__:*' rr!rlrr!s r all_eventsKeyeventChannel.all_eventss$32rcUR$rr4rs rr5KeyeventChannel.__str__r7rc>SUR<SURS3$)NzKeyeventChannel(r9r:rYr!rs rr<KeyeventChannel.__repr__s!$**uTWWIQ??rc[U[5(aURUR:H$[U[5(aURU:H$[$r)r?rr#rr@rAs rrCKeyeventChannel.__eq__rErc,[UR5$rrGrs rrIKeyeventChannel.__hash__rKrr#r!rYNrMrYrr!rrOrP)r!rrz'KeyeventChannel'rQrSrmrnrorprqrrr%r"rUr1rrfr5r<rCrIrrlrrrrisZ8*FM) 98''&!@'rc|\rSrSr%SrSrS\S'SSSjjrSSjr\ SSj5r SS jr SS jr SS jr SS jrS rg)riae Represents a subkeyspace notification channel for subscribing to subkey-level events on keys (e.g., hash field changes). The channel format is ``__subkeyspace@__:``. The message payload is ``|:[,...]``. Examples: >>> channel = SubkeyspaceChannel("myhash", db=0) >>> str(channel) '__subkeyspace@0__:myhash' z__subkeyspace@rrcFXlX lUR5Ulgrrr$s rr%SubkeyspaceChannel.__init__s, 668rcPURURSUR3$r(r*rs rr"(SubkeyspaceChannel._build_channel_stringr,rc,[UR5$rr/rs rr1SubkeyspaceChannel.is_patterns4..//rcUR$rr4rs rr5SubkeyspaceChannel.__str__r7rc>SUR<SURS3$)NzSubkeyspaceChannel(r9r:r;rs rr<SubkeyspaceChannel.__repr__s"$T%8%8$;5 KKrc[U[5(aURUR:H$[U[5(aURU:H$[$r)r?rr#rr@rAs rrCSubkeyspaceChannel.__eq__K e/ 0 0$$(:(:: : eS ! !$$- -rc,[UR5$rrGrs rrISubkeyspaceChannel.__hash__rKrrLNrMrNrOrPrQrSrTrlrrrrsG -FM,9 A00!L'rc\rSrSr%SrSrS\S'SSSjjrSSjr\ SSj5r \ SSS jj5r SS jr SS jrSS jrSS jrSrg)riab Represents a subkeyevent notification channel for subscribing to specific event types with subkey-level detail. The channel format is ``__subkeyevent@__:``. The message payload is ``:|:[,...]``. Examples: >>> channel = SubkeyeventChannel("hdel", db=0) >>> str(channel) '__subkeyevent@0__:hdel' z__subkeyevent@rrcFXlX lUR5UlgrrXrZs rr%SubkeyeventChannel.__init__s  668rcPURURSUR3$r(r]rs rr"(SubkeyeventChannel._build_channel_stringr_rc,[UR5$rrars rr1SubkeyeventChannel.is_patterns4::&&rcU"SUS9$)z+Create a channel for all subkeyevent types.rrdrlres rrfSubkeyeventChannel.all_events s32rcUR$rr4rs rr5SubkeyeventChannel.__str__r7rc>SUR<SURS3$)NzSubkeyeventChannel(r9r:rkrs rr<SubkeyeventChannel.__repr__s$TZZN%yBBrc[U[5(aURUR:H$[U[5(aURU:H$[$r)r?rr#rr@rAs rrCSubkeyeventChannel.__eq__rrc,[UR5$rrGrs rrISubkeyeventChannel.__hash__rKrrqNrMrrrOrP)r!rrrrQrSrsrlrrrrsZ -FM,9 8''!C'rc|\rSrSr%SrSrS\S'SSSjjrSSjr\ SSj5r SS jr SS jr SS jr SS jrS rg)ri a Represents a subkeyspaceitem notification channel for subscribing to events on a specific subkey (field) of a specific key. The channel format is ``__subkeyspaceitem@__:\n``. The message payload is the event type (e.g., ``"hset"``). Note: The server only emits this notification when the key does not contain a newline character. Examples: >>> channel = SubkeyspaceitemChannel("myhash", "myfield", db=0) >>> str(channel) '__subkeyspaceitem@0__:myhash\nmyfield' z__subkeyspaceitem@rrcRXlX lX0lUR5Ulgr)r subkey_or_patternr!r"r#)rr rr!s rr%SubkeyspaceitemChannel.__init__4s$,!2 668rcjURURSURSUR3$)Nr)r)rr!r rrs rr",SubkeyspaceitemChannel._build_channel_string:s5{{mDGG9C(;(;'V W rcd[UR5=(d [UR5$r)r0r rrs rr1!SubkeyspaceitemChannel.is_pattern?s#4../V;t?U?U3VVrcUR$rr4rs rr5SubkeyspaceitemChannel.__str__Cr7rcZSUR<SUR<SURS3$)NzSubkeyspaceitemChannel(, r9r:)r rr!rs rr<SubkeyspaceitemChannel.__repr__Fs4%d&9&9%__:|``. The message payload is a length-prefixed subkey list. Examples: >>> channel = SubkeyspaceeventChannel("hset", "myhash", db=0) >>> str(channel) '__subkeyspaceevent@0__:hset|myhash' z__subkeyspaceevent@rrcRXlX lX0lUR5Ulgr)rYr r!r"r#)rrYr r!s rr% SubkeyspaceeventChannel.__init__gs# , 668rcjURURSURSUR3$)Nr)r)rr!rYr rs rr"-SubkeyspaceeventChannel._build_channel_stringms0++twwis4::,a8K8K7LMMrcd[UR5=(d [UR5$r)r0rYr rs rr1"SubkeyspaceeventChannel.is_patternps!4::&J+d6I6I*JJrcUR$rr4rs rr5SubkeyspaceeventChannel.__str__tr7rcZSUR<SUR<SURS3$)NzSubkeyspaceeventChannel(rr9r:)rYr r!rs rr< SubkeyspaceeventChannel.__repr__ws1&tzznB""%U477)1 6 rc[U[5(aURUR:H$[U[5(aURU:H$[$r)r?rr#rr@rAs rrCSubkeyspaceeventChannel.__eq__}sK e4 5 5$$(:(:: : eS ! !$$- -rc,[UR5$rrGrs rrI SubkeyspaceeventChannel.__hash__rKr)r#r!rYr NrM)rYrr rr!rrOrPrQrSrTrlrrrrWsH 2FM19 NKK! 'rc0\rSrSrSrSrSrSrSrSr Sr S r g ) ChannelTypeiu Enum representing the type of a Redis keyspace notification channel. Redis provides two types of keyspace notifications and four subkey notification types: - KEYSPACE: ``__keyspace@{db}__:{key}`` — data is the event type. - KEYEVENT: ``__keyevent@{db}__:{event}`` — data is the key name. - SUBKEYSPACE: ``__subkeyspace@{db}__:{key}`` — data is event + subkeys. - SUBKEYEVENT: ``__subkeyevent@{db}__:{event}`` — data is key + subkeys. - SUBKEYSPACEITEM: ``__subkeyspaceitem@{db}__:{key}\n{subkey}`` — data is the event type. - SUBKEYSPACEEVENT: ``__subkeyspaceevent@{db}__:{event}|{key}`` — data is a subkey list. Examples: >>> get_channel_type("__keyspace@0__:mykey") ChannelType.KEYSPACE >>> get_channel_type("__subkeyspace@0__:myhash") ChannelType.SUBKEYSPACE keyspacekeyevent subkeyspace subkeyeventsubkeyspaceitemsubkeyspaceeventrlN) rmrnrorprqKEYSPACEKEYEVENT SUBKEYSPACE SUBKEYEVENTSUBKEYSPACEITEMSUBKEYSPACEEVENTrrlrrrrs(,HHKK'O)rrc[U5nUR[R5(a[R $UR[ R5(a[R$UR[R5(a[R$UR[R5(a[R$UR[R5(a[R$UR[R5(a[R$g)ah Determine the type of a Redis keyspace notification channel. Args: channel: The channel name to check (string or bytes). Returns: ChannelType.KEYSPACE if it's a keyspace notification channel, ChannelType.KEYEVENT if it's a keyevent notification channel, None if it's not a keyspace notification channel. Examples: >>> get_channel_type("__keyspace@0__:mykey") ChannelType.KEYSPACE >>> get_channel_type("__keyevent@0__:set") ChannelType.KEYEVENT >>> get_channel_type("regular_channel") is None True >>> get_channel_type(b"__keyspace@0__:mykey") ChannelType.KEYSPACE N)rrrrrrrrrrrrrrrr)r channel_strs rget_channel_typers,7#K4;;<<***5<<==+++07788&&&07788&&&o4455###o4455### rcb[US5(a URn[U5nSnU[U5:avXnUS:XaUS- nM US;agUS:XaBUS-nU[U5:a.XS:XaUS- nMXS :XagUS- nU[U5:aM.US- nU[U5:aMvg ) a Check if a channel string contains glob-style pattern characters. Redis uses glob-style patterns for psubscribe: - * matches any sequence of characters - ? matches any single character - [...] matches any character in the brackets Args: channel: The channel string to check. Can be a string, bytes, or a KeyspaceChannel/KeyeventChannel object. Returns: True if the channel contains pattern characters, False otherwise. r#r\)r?T[r]F)hasattrr#rr)richarjs rr0r0s(w''&&wG A c'l z 4< FA  :  3;AAc'l":%FA:$Q c'l" Q' c'l ( rc\rSrSrSr\SS.SSjj5r\SSj5r\SSSjj5r\SSSjj5r \SSS jj5r \SSS jj5r \SSS jj5r \SSS jj5r \SSS jj5r\S5r\S5r\S5r\S5r\\SSj55r\SS Sjj5rSrg)!KeyspaceNotificationsInterfaceia Interface for keyspace notification managers. This interface provides a consistent API for both standalone (KeyspaceNotifications) and cluster (ClusterKeyspaceNotifications) implementations, allowing the same code patterns to work with both standalone and cluster Redis deployments. Nhandlercg)z,Subscribe to keyspace notification channels.Nrl)rrchannelss r subscribe(KeyspaceNotificationsInterface.subscribe rcg)z0Unsubscribe from keyspace notification channels.Nrl)rrs r unsubscribe*KeyspaceNotificationsInterface.unsubscribe rcg)z6Subscribe to keyspace notifications for specific keys.Nrlrr r!rs rsubscribe_keyspace1KeyspaceNotificationsInterface.subscribe_keyspace rcg)z=Subscribe to keyevent notifications for specific event types.NrlrrYr!rs rsubscribe_keyevent1KeyspaceNotificationsInterface.subscribe_keyevent(rrcg)z9Subscribe to subkeyspace notifications for specific keys.Nrlrs rsubscribe_subkeyspace4KeyspaceNotificationsInterface.subscribe_subkeyspace2rrcg)z@Subscribe to subkeyevent notifications for specific event types.Nrlrs rsubscribe_subkeyevent4KeyspaceNotificationsInterface.subscribe_subkeyevent<rrcg)zASubscribe to subkeyspaceitem notifications for a specific subkey.Nrl)rr rr!rs rsubscribe_subkeyspaceitem8KeyspaceNotificationsInterface.subscribe_subkeyspaceitemF rcg)zBSubscribe to subkeyspaceevent notifications for an event on a key.Nrl)rrYr r!rs rsubscribe_subkeyspaceevent9KeyspaceNotificationsInterface.subscribe_subkeyspaceeventQrrcg)z7Get the next keyspace notification if one is available.Nrl)rignore_subscribe_messagestimeouts r get_message*KeyspaceNotificationsInterface.get_message\rrcg)z"Listen for keyspace notifications.Nrlrs rlisten%KeyspaceNotificationsInterface.listenerrcg)z6Close the notification manager and clean up resources.Nrlrs rclose$KeyspaceNotificationsInterface.closejrrcgrrlrs r __enter__(KeyspaceNotificationsInterface.__enter__o rcgrrlr _exc_type_exc_val_exc_tbs r__exit__'KeyspaceNotificationsInterface.__exit__srrcg);Check if there are any active subscriptions and not closed.Nrlrs r subscribed)KeyspaceNotificationsInterface.subscribedws rcg)z7Start a background thread that polls for notifications.Nrl)r poll_timeoutdaemonexception_handlers r run_in_thread,KeyspaceNotificationsInterface.run_in_thread}s rrlrrrSyncHandlerT | NonerrrNr rr!rrrrYrr!rrrr rrrr!rrrrYrr rr!rrrNrz bool | NonerfloatrrrPrFNrrrrr\Callable[[BaseException, KeyspaceNotificationsInterface, KeyspaceWorkerThread], None] | NonerKeyspaceWorkerThread)rmrnrorprqrrrrrrrrrrrrrrrUr rrrlrrrrs(,  %    '+     %   '+     %   '+     %   '+     %    '+       %    '+       %   26 #.               "        rrc\rSrSrSrSSSjjrSS.SSjjr\SSj5rSSjr \SS j5r SS jr SS jr SSS jjr SSS jjrSSSjjrSSSjjrSS SjjrSS!SjjrSrSrS"S#Sjjr\S$Sj5rSrg)%AbstractKeyspaceNotificationsiap Abstract base class for keyspace notification managers. Provides shared implementation for subscribe/unsubscribe logic. Subclasses must implement: - _execute_subscribe: Execute the subscribe operation - _execute_unsubscribe: Execute the unsubscribe operation - get_message: Get the next notification - listen: Generator for notifications - close: Clean up resources Nc*XlX lSUlg)a Initialize the base keyspace notification manager. Args: key_prefix: Optional prefix to filter and strip from keys in notifications ignore_subscribe_messages: If True, subscribe/unsubscribe confirmations are not returned by get_message/listen FN)rr_closed)rrrs rr%&AbstractKeyspaceNotifications.__init__s%)B& rrc^^ SnTbURm UU 4SjnUn0n0nUHEn[US5(a [U5nO [U5n[ U5(aX5U'MAX6U'MG UR XV5 UR XV5 g)aG Subscribe to keyspace notification channels. Automatically detects whether each channel is a pattern (contains wildcards like *, ?, [) or an exact channel name and uses the appropriate Redis subscribe command internally. Args: *channels: Channels to subscribe to. Can be strings, KeyspaceChannel, or KeyeventChannel objects. Patterns are auto-detected. handler: Optional callback function that receives KeyNotification objects. If provided, notifications are passed to the handler instead of being returned by get_message()/listen(). NcF>[RUTS9nUb T"U5 gg)Nr)rr)r notificationrrs r _wrap_handler>AbstractKeyspaceNotifications.subscribe.._wrap_handlers2.;;  <   +L),rr#)rrrrr0_execute_subscribe_track_subscribe) rrrwrapped_handlerr,patternsexact_channelsrrrs ` @rr'AbstractKeyspaceNotifications.subscribes(,0  J *,OGw//!'l &w/ 7##(7%.={+  9 h7rcg)z Execute the subscribe operation. Args: patterns: Dict mapping pattern strings to handlers (for psubscribe) exact_channels: Dict mapping channel strings to handlers (for subscribe) Nrlrr1r2s rr.0AbstractKeyspaceNotifications._execute_subscribe rc/n/nUH_n[US5(a [U5nO [U5n[U5(aUR U5 MNUR U5 Ma UR X#5 UR X#5 g)z Unsubscribe from keyspace notification channels. Automatically detects whether each channel is a pattern or exact channel and uses the appropriate Redis unsubscribe command. Args: *channels: Channels to unsubscribe from. r#N)rrrr0r(_execute_unsubscribe_untrack_subscribe)rrr1r2rrs rr)AbstractKeyspaceNotifications.unsubscribes{Gw//!'l &w/ 7## ,%%k2 !!(; 9rcg)z Execute the unsubscribe operation. Args: patterns: List of pattern strings to punsubscribe from exact_channels: List of channel strings to unsubscribe from Nrlr5s rr92AbstractKeyspaceNotifications._execute_unsubscriber7rcg)a3Track newly subscribed patterns/channels. Override in subclasses that need to maintain their own subscription registry (e.g. cluster implementations that must re-subscribe new/failed-over nodes). The default is a no-op because standalone implementations delegate tracking to the underlying PubSub object. Nrlr5s rr/.AbstractKeyspaceNotifications._track_subscribercg)zRemove patterns/channels from the subscription registry. Override in subclasses that maintain their own subscription registry. The default is a no-op. Nrlr5s rr:0AbstractKeyspaceNotifications._untrack_subscribe)r@rc4[XS9nURXCS9 g)aN Subscribe to keyspace notifications for specific keys. Args: key_or_pattern: The key or pattern to monitor. Use '*' for wildcards. db: The database number (default 0). handler: Optional callback for notifications. Example: >>> ksn.subscribe_keyspace("user:123", db=0) >>> ksn.subscribe_keyspace("user:*", db=0) rdrN)rrrr r!rrs rr0AbstractKeyspaceNotifications.subscribe_keyspace2s$".8 w0rc4[XS9nURXCS9 g)ac Subscribe to keyevent notifications for specific event types. Args: event: The event type to monitor (e.g., EventType.SET or "set") db: The database number (default 0). handler: Optional callback for notifications. Example: >>> ksn.subscribe_keyevent(EventType.SET) >>> ksn.subscribe_keyevent(EventType.EXPIRED, handler=my_handler) rdrN)rrrrYr!rrs rr0AbstractKeyspaceNotifications.subscribe_keyeventGs$"%/ w0rc4[XS9nURXCS9 g)a Subscribe to subkeyspace notifications for specific keys. Receives events with affected subkeys (fields) for the given key. Args: key_or_pattern: The key or pattern to monitor. db: The database number (default 0). handler: Optional callback for notifications. rdrN)rrrDs rr3AbstractKeyspaceNotifications.subscribe_subkeyspace\s %^; w0rc4[XS9nURXCS9 g)a% Subscribe to subkeyevent notifications for specific event types. Receives the affected key and subkeys when the given event occurs. Args: event: The event type to monitor (e.g., "hset", "hdel"). db: The database number (default 0). handler: Optional callback for notifications. rdrN)rrrGs rr3AbstractKeyspaceNotifications.subscribe_subkeyeventos %U2 w0rc6[XUS9nURXTS9 g)af Subscribe to subkeyspaceitem notifications for a specific subkey. Receives the event type when the given subkey of the given key is modified. Args: key_or_pattern: The key or pattern to monitor. subkey_or_pattern: The subkey (field) or pattern to monitor. db: The database number (default 0). handler: Optional callback for notifications. rdrN)rr)rr rr!rrs rr7AbstractKeyspaceNotifications.subscribe_subkeyspaceitems&)rR w0rc6[XUS9nURXTS9 g)aL Subscribe to subkeyspaceevent notifications for an event on a key. Receives the affected subkeys when the given event occurs on the given key. Args: event: The event type to monitor. key_or_pattern: The key or pattern to monitor. db: The database number (default 0). handler: Optional callback for notifications. rdrN)rr)rrYr r!rrs rr8AbstractKeyspaceNotifications.subscribe_subkeyspaceevents&*%BG w0rcU$rrlrs rr'AbstractKeyspaceNotifications.__enter__s rc$UR5 g)NF)rrs rr&AbstractKeyspaceNotifications.__exit__s rc^UR5 [UUUUS9nUR5 U$)a Start a background thread that polls for notifications and triggers handlers. This method spawns a thread that continuously calls get_message() to process incoming notifications. When a notification arrives, any registered handler for that channel/pattern is invoked automatically. All subscriptions must have handlers registered before calling this method. Args: poll_timeout: Timeout in seconds for get_message() calls. When no message is available, the thread waits up to this long before checking again. Default 0.0 (non-blocking). WARNING: the default causes a CPU spin-loop. It is preferred to pass a positive value (e.g. 0.1 or 1.0). daemon: If True, the thread will be a daemon thread and will be terminated when the main program exits. Default False. exception_handler: Optional callback invoked when an exception occurs in the worker thread. Receives (exception, notifications, thread) as arguments. If None, exceptions are raised. Returns: KeyspaceWorkerThread: The started worker thread. Call stop() on it to stop the thread and close the notifications. Raises: RedisError: If any subscription doesn't have a handler registered. Example: >>> def my_handler(notification): ... print(f"Got: {notification.key} - {notification.event_type}") >>> >>> notifications.subscribe(KeyspaceChannel("user:*"), handler=my_handler) >>> thread = notifications.run_in_thread(poll_timeout=0.1, daemon=True) >>> # ... handlers are called automatically ... >>> thread.stop() )rr)_validate_all_handlersr"r)rrrrthreads rr+AbstractKeyspaceNotifications.run_in_threads7f ##%%  /     rcg)zRaise :class:`~redis.RedisError` if any subscription lacks a handler. Subclasses inspect their own subscription state to perform the validation. Nrlrs rrV4AbstractKeyspaceNotifications._validate_all_handlersrr)r&rrNT)rrrrrr1dict[str, Any]r2r]rNonerr1rr2rrr^rrrrrrr rr^)rmrnrorprqr%rrr.rr9r/r:rrrrrrrrrrVrrlrrr$r$s< *.*.&$(((,4848%48l  &  8F      :@  !  3<        &  8F     ! 3<  '+ 11 1% 10'+ 11 1% 10'+ 11 1% 1,'+ 11 1% 1.'+ 111  1 % 14'+ 111  1 % 1, "<<< < <|  rr$cZ^\rSrSrSrSSU4SjjjrS SjrS SjrSrU=r $) r"iax Background thread for processing keyspace notifications. This thread continuously polls for notifications and invokes registered handlers. It works with both KeyspaceNotifications (standalone) and ClusterKeyspaceNotifications. Example: >>> thread = notifications.run_in_thread(poll_timeout=0.1) >>> # ... handlers are called automatically ... >>> thread.stop() c>[TU]5 X0lXlX lX@l[ R"5Ulgr) superr%r notificationsrr threadingEvent_running)rrdrrr __class__s rr%KeyspaceWorkerThread.__init__ s5  *(!2!) rcURR5(agURR5 URnURnURR5(a2UR SUS9 URR5(aM2UR5 g![ a*nURceURX1U5 SnANaSnAff=f)z=Main loop that polls for notifications and triggers handlers.NTrr) rgis_setrrdrr BaseExceptionrr)rrdres rrunKeyspaceWorkerThread.run!s ==   ! !  ** (( mm""$$ ?)).2L*mm""$$  ! ?))1&&q>> ?s3B55 C)? C$$C)c8URR5 g)z Stop the worker thread. This signals the thread to exit its run loop. The thread will close the notifications object before terminating. N)rgclearrs rstopKeyspaceWorkerThread.stop3s r)rgrrrdr)FN)rdrrrrrrr!r`) rmrnrorprqr%rorsr __classcell__rhs@rr"r"sQ "*5** *  **,$rr"c^\rSrSrSrS S U4SjjjrSSjrSSjrSSSjjrSr \ SSj5r SS jr S r S rU=r$)KeyspaceNotificationsiBa Manages keyspace notification subscriptions for standalone Redis. For standalone Redis, keyspace notifications work with a single PubSub connection. This class wraps that connection and provides: - Automatic pattern vs exact channel detection - KeyNotification parsing with optional key_prefix filtering - Convenience methods for keyspace and keyevent subscriptions - Context manager and run_in_thread support cX>[TU]X#5 XlURSS9Ulg)a& Initialize the standalone keyspace notification manager. Note: Keyspace notifications must be enabled on the Redis server via the ``notify-keyspace-events`` configuration option. This is a server-side configuration that should be done by your infrastructure/operations team. Args: redis_client: A Redis client instance key_prefix: Optional prefix to filter and strip from keys in notifications ignore_subscribe_messages: If True, subscribe/unsubscribe confirmations are not returned by get_message/listen FrN)rcr%redispubsub_pubsub)r redis_clientrrrhs rr%KeyspaceNotifications.__init__Ns.& ?! $**U*K rcU(aURR"S0UD6 U(aURR"S0UD6 gg)z2Execute subscribe on the single pubsub connection.Nrl)r} psubscriberr5s rr.(KeyspaceNotifications._execute_subscribehs9  LL # # /h /  LL " " 4^ 4 rcU(aURR"U6 U(aURR"U6 gg)z4Execute unsubscribe on the single pubsub connection.N)r} punsubscriberr5s rr9*KeyspaceNotifications._execute_unsubscribeqs3  LL % %x 0  LL $ $n 5 rcUc URnUR(agURRUUS9nUb[R X0R S9$g)a  Get the next keyspace notification if one is available. Note: If a handler was registered for the channel, pubsub will call the handler directly and this method returns None for that message. Args: ignore_subscribe_messages: If True, skip subscribe/unsubscribe messages. Defaults to the value set in __init__ (True). timeout: Time to wait for a message. Returns: A KeyNotification if a notification is available and no handler was registered for the channel, None otherwise. Nrkr*)rr&r}rrrr)rrrrs rr!KeyspaceNotifications.get_messagezsd( % ,(,(F(F % << ,,**&?+   "//OO/T Trc## UR(a*URSS9nUbUv UR(aM)gg7f)a_ Listen for keyspace notifications. This is a generator that yields KeyNotification objects as they arrive. It blocks until a notification is received. Yields: KeyNotification objects for each keyspace/keyevent notification. Example: >>> for notification in ksn.listen(): ... print(f"{notification.key}: {notification.event_type}") ?rNr rrr+s rrKeyspaceNotifications.listen8oo++C+8L'""ooo9??c^UR(+=(a URR$r )r&r}r rs rr  KeyspaceNotifications.subscribeds <<;DLL$;$;;rcURRR5HupUbM [SUS35e URRR5Hup2UbM [SUS35e g)zCRaise if any subscription in the underlying PubSub lacks a handler.N Channel '' has no handler registered Pattern ')r}ritemsrr1rrrpatterns rrV,KeyspaceNotifications._validate_all_handlerssx $ 5 5 ; ; = G 9WI5P!QRR!>!% 5 5 ; ; = G 9WI5P!QRR!>rchSUlURR5 g![a gf=f)z3Close the pubsub connection and clean up resources.TN)r&r}r Exceptionrs rrKeyspaceNotifications.closes0   LL      s $ 11)r&r}r{r[)r~r rrrrr\r_rrrPr`)rmrnrorprqr%r.r9rrrUr rVrrrurvs@rrxrxBs *.*. LL'L$( LL45&58F5 56!63<6 626%#.%% %N#&<<Srrxc,^\rSrSrSrSSU4Sjjjr\SSj5rSSjrSSjr SSjr Sr SS jr SS jr SS jrSS jrSS jrSS SjjrS!SjrSrSrSSjrSrSrSrU=r$)"ClusterKeyspaceNotificationsia8 Manages keyspace notification subscriptions across all nodes in a Redis Cluster. In Redis Cluster, keyspace notifications are NOT broadcast between nodes. Each node only emits notifications for keys it owns. This class automatically subscribes to all primary nodes in the cluster and handles topology changes. c>[TU]X#5 Xl0Ul0Ul0Ul[ R"5UlSUl g)a+ Initialize the cluster keyspace notification manager. Note: Keyspace notifications must be enabled on all Redis cluster nodes via the ``notify-keyspace-events`` configuration option. This is a server-side configuration that should be done by your infrastructure/operations team. Args: redis_cluster: A RedisCluster instance key_prefix: Optional prefix to filter and strip from keys in notifications ignore_subscribe_messages: If True, subscribe/unsubscribe confirmations are not returned by get_message/listen rN) rcr%cluster_subscribed_patterns_subscribed_channels _node_pubsubsreLock _refresh_lock _poll_index)r redis_clusterrrrhs rr%%ClusterKeyspaceNotifications.__init__sN& ?$ 57!46!.0'^^-rcUR(+=(a( [UR=(d UR5$r)r&rrrrs rr 'ClusterKeyspaceNotifications.subscribeds3<< D  % % B)B)B%  rcU(aURRU5 U(aURRU5 gg)zATrack newly subscribed patterns/channels in the cluster registry.N)rupdaterr5s rr/-ClusterKeyspaceNotifications._track_subscribes7   % % , ,X 6   % % , ,^ < rcUHnURRUS5 M! UHnURRUS5 M! g)z3Remove patterns/channels from the cluster registry.N)rpopr)rr1r2pcs rr:/ClusterKeyspaceNotifications._untrack_subscribesDA  % % ) )!T 2A  % % ) )!T 2 rcURR5HupUbM [SUS35e URR5Hup2UbM [SUS35e g)zBRaise if any subscription in the cluster registry lacks a handler.Nrrr)rrrrrs rrV3ClusterKeyspaceNotifications._validate_all_handlerssr $ 9 9 ? ? A G 9WI5P!QRR!B!% 9 9 ? ? A G 9WI5P!QRR!Brc6URR5$)z%Get all primary nodes in the cluster.)r get_primariesrs r_get_all_primary_nodes3ClusterKeyspaceNotifications._get_all_primary_nodes!s||))++rcURRUS5nU(aUR5 gg![a gf=f)zRemove and close a node's PubSub. Closing the ``PubSub`` disconnects its connection so it is not left in a subscribed state inside the connection pool. N)rrrr)r node_namer|s r _cleanup_node*ClusterKeyspaceNotifications._cleanup_node%sF ##'' 48      s7 AAcURUR;aBURRU5nUR SS9nX0RUR'URUR$)z+Get or create a PubSub instance for a node.Frz)namerrget_redis_connectionr|)rnode redis_connr|s r_ensure_node_pubsub0ClusterKeyspaceNotifications._ensure_node_pubsub2sd 99D.. .::4@J &&&GF,2  tyy )!!$)),,rcU(dU(dg/nUR5HnURUR;nURU5nU(aZUR(aUR "S0URD6 UR (aUR"S0UR D6 U(aUR "S0UD6 U(aUR"S0UD6 MM U(a&[RSSRU55 gg![a; URUR5 URUR5 GM9f=f)aGExecute subscribe on all cluster nodes. Patterns and exact channels are subscribed in a single pass over nodes so that a mid-batch node failure cannot create a partially-caught-up replacement. If a node fails during this call it is removed from ``_node_pubsubs`` and will be fully re-subscribed on the next ``refresh_subscriptions`` cycle. If a newly discovered node is encountered (not yet in ``_node_pubsubs``), it is also subscribed to all *previously* tracked patterns/channels so it doesn't miss notifications for subscriptions that were established before this node joined. Nz`Failed to subscribe on cluster nodes: %s. These nodes will be retried on the next refresh cycle.rrl)rrrrrrrrrrr(loggerwarningjoin)rr1r2 failed_nodesr is_new_noder|s rr./ClusterKeyspaceNotifications._execute_subscribe=s!  "$ //1D))4+=+==K--d3F /00))FD,E,EF00((E4+D+DE%%11!$$6~6"2,  NNI ,'    /""499-##DII..  /sBDAEEcbU(aURUSS9 U(aURUSS9 gg)z)Execute unsubscribe on all cluster nodes.T)use_punsubscribeFN)_unsubscribe_from_all_nodesr5s rr91ClusterKeyspaceNotifications._execute_unsubscribens5   , ,X , M   , ,^e , T rcp/n[URR55H-upEU(aUR"U6 MUR"U6 M/ U(a&[RSSRU55 gg![ a& UR U5 URU5 Mf=f)a]Unsubscribe from patterns/channels on all nodes. Best-effort: tries every node so that a single broken connection does not prevent the remaining nodes from being unsubscribed. Broken pubsubs are cleaned up; the tracking state is still removed by the caller, so ``refresh_subscriptions`` will *not* re-subscribe these channels on replacement nodes. zeFailed to unsubscribe on cluster nodes: %s. These nodes will be re-created on the next refresh cycle.rN) listrrrrrrr(rrr)rrrrrr|s rr8ClusterKeyspaceNotifications._unsubscribe_from_all_nodesws#% !%d&8&8&>&>&@!A I /#''2&&1 "B  NNL ,'    /""9-##I. /sBB,B54B5cUR(ag[UR5nUS:XaUS:a[R"U5 gUc UR nUS:XaUR U5$[SU[US5- 5n[R"5nXR-n[R"5U:ag[URR55nU(dgUR[U5-Ul XpRnU=RS- sl URUUS9n U b"[$R'XR(S9n U bU $M![[[ 4a UR#5 Mf=f)a. Get the next keyspace notification if one is available. This method polls all node pubsubs in round-robin fashion until a message is received or the timeout expires. If a connection error occurs, subscriptions are automatically refreshed. Args: ignore_subscribe_messages: If True, skip subscribe/unsubscribe messages. Defaults to the value set in __init__ (True). timeout: Total time to wait for a message (distributed across all nodes) Returns: A KeyNotification if a notification is available, None otherwise. Nrrg?rrkr*)r&rrtimesleepr_poll_all_nodes_onceminmax monotonicrvaluesrrrrr_refresh_subscriptions_on_errorrrr) rrr total_nodesper_node_timeout start_timeend_timepubsubsr|rr+s rr(ClusterKeyspaceNotifications.get_messages( <<$,,- ! { 7# % ,(,(F(F % c>,,-FG GsGc+q.A$AB^^% '~~8+4--4467G $//#g,>D --.F    !   ,,.G,-" /;; <   +''?&$\:> 446 s*E!!%F  F chSn[URR55HTnURUSS9nUcM[RX@RS9nUcM;U(aUR5 Us $ U(aUR5 g![[ [ 4a SnMf=f)a Perform a single non-blocking poll over all node pubsubs. This is used when timeout=0 to match the expected semantics of PubSub.get_message(timeout=0) - a non-blocking check for messages. Returns: A KeyNotification if one is available, None otherwise. FrrkTNr*) rrrrrrrrrrr)rr had_errorr|rr+s rr1ClusterKeyspaceNotifications._poll_all_nodes_onces 4--4467F  ,,.G-" /;; <   +!<<>''/84   0 0 2-$\:> !   sBB10B1c## UR(a*URSS9nUbUv UR(aM)gg7f)av Listen for keyspace notifications from all cluster nodes. This is a generator that yields KeyNotification objects as they arrive. It blocks until a notification is received. Yields: KeyNotification objects for each keyspace/keyevent notification. Example: >>> for notification in ksn.listen(): ... print(f"{notification.key}: {notification.event_type}") rrNrrs rr#ClusterKeyspaceNotifications.listenrrc|SUlUR5 g![a [R SSS9 gf=f)z Refresh subscriptions after a connection error. This is called automatically when a connection error occurs during get_message(). It checks if nodes changed before refreshing. rzAFailed to refresh cluster subscriptions, will retry on next errorT)exc_infoN)rrefresh_subscriptionsrrrrs rrM+ ""9-+ !!3!3!8!8!:;c!&&(?N, ++// :6$";";F"C"C&&y1 ,-2245DH??I IcSUl[URR55HnUR U5 M UR R 5 URR 5 g)z4Close all pubsub connections and clean up resources.TN)r&rrrrrrrr)rrs rr"ClusterKeyspaceNotifications.closexsY d005578I   y )9 !!'') !!'')r)r&rrrrrrr[)rrrrrrrPr\r_r`)rrrr^)rr )rrrrrr)rrrr)rmrnrorprqr%rUr r/r:rVrrrr.r9rrrrrrrrrrurvs@rrrsA*.*. $#$'$$( $$L  =&=8F= =3!33<3 3S,  -/&/8F/ /bU!U3<U U:26O(#.O(O( O(d))-) )V#&"9v**rr)rrrr)rrrzChannelType | None)rz/str | bytes | KeyspaceChannel | KeyeventChannelrr):rq __future__rloggingrrerabcrrcollections.abcr dataclassesrenumrtypingr r r r redis.clientr redis.clusterrredis.exceptionsrrr redis.utilsr getLoggerrmrrrbytesrr SyncHandlerTrrrrrrrrrrrr0rr$Threadr"rxrrlrrr s8t#  #$!66& !   8 $   ) *+T12 mm`* g+g+ g+^ B'B'JU'U'p*'*'Z/'/'d4'4'n.'.'b*$*>$N1 <1 1rF SF Rj $Bj Z =9++=JF9F\n*#@n*r