code: def execute_pubsub(self, command, *channels):
          
          command = command.upper().strip()
          assert command in _PUBSUB_COMMANDS, (
              "Pub/Sub command expected", command)
          if self._reader is None or self._reader.at_eof():
              raise ConnectionClosedError("Connection closed or corrupted")
          if None in set(channels):
              raise TypeError("args must not contain None")
          if not len(channels):
              raise TypeError("No channels/patterns supplied")
          is_pattern = len(command) in (10, 12)
          mkchannel = partial(Channel, is_pattern=is_pattern, loop=self._loop)
          channels = [ch if isinstance(ch, AbcChannel) else mkchannel(ch)
                      for ch in channels]
          if not all(ch.is_pattern == is_pattern for ch in channels):
              raise ValueError("Not all channels {} match command {}"
                               .format(channels, command))
          cmd = encode_command(command, *(ch.name for ch in channels))
          res = []
          for ch in channels:
              fut = self._loop.create_future()
              res.append(fut)
              cb = partial(self._update_pubsub, ch=ch)
              self._waiters.append((fut, None, cb))
          if self._pipeline_buffer is None:
              self._writer.write(cmd)
          else:
              self._pipeline_buffer.extend(cmd)
          return asyncio.gather(*res, loop=self._loop)
docs: Executes redis (p)subscribe/(p)unsubscribe commands.
  
          Returns asyncio.gather coroutine waiting for all channels/patterns
          to receive answers.