Beispiel #1
0
 async def _zaggregate(self, command, dest, keys, aggregate=None):
     pieces = [command, dest, len(keys)]
     if isinstance(keys, dict):
         keys, weights = iterkeys(keys), itervalues(keys)
     else:
         weights = None
     pieces.extend(keys)
     if weights:
         pieces.append(b('WEIGHTS'))
         pieces.extend(weights)
     if aggregate:
         pieces.append(b('AGGREGATE'))
         pieces.append(aggregate)
     return await self.execute_command(*pieces)
Beispiel #2
0
 async def subscribe(self, *args, **kwargs):
     """
     Subscribe to channels. Channels supplied as keyword arguments expect
     a channel name as the key and a callable as the value. A channel's
     callable will be invoked automatically when a message is received on
     that channel rather than producing a message via ``listen()`` or
     ``get_message()``.
     """
     if args:
         args = list_or_args(args[0], args[1:])
     new_channels = {}
     new_channels.update(dict.fromkeys(map(self.encode, args)))
     for channel, handler in iteritems(kwargs):
         new_channels[self.encode(channel)] = handler
     ret_val = await self.execute_command('SUBSCRIBE', *iterkeys(new_channels))
     # update the channels dict AFTER we send the command. we don't want to
     # subscribe twice to these channels, once for the command and again
     # for the reconnection.
     self.channels.update(new_channels)
     return ret_val
Beispiel #3
0
 async def psubscribe(self, *args, **kwargs):
     """
     Subscribes to channel patterns. Patterns supplied as keyword arguments
     expect a pattern name as the key and a callable as the value. A
     pattern's callable will be invoked automatically when a message is
     received on that pattern rather than producing a message via
     ``listen()``.
     """
     if args:
         args = list_or_args(args[0], args[1:])
     new_patterns = {}
     new_patterns.update(dict.fromkeys(map(self.encode, args)))
     for pattern, handler in iteritems(kwargs):
         new_patterns[self.encode(pattern)] = handler
     ret_val = await self.execute_command('PSUBSCRIBE',
                                          *iterkeys(new_patterns))
     # update the patterns dict AFTER we send the command. we don't want to
     # subscribe twice to these patterns, once for the command and again
     # for the reconnection.
     self.patterns.update(new_patterns)
     return ret_val