Sends a group message.
977405
void doGroupSend(String group, Object value) {
    checkOpen();
    JsonObject message = createMessage(value)
        .putString("action", "group")
        .putString("group", group);
    if (open && !paused) {
      if (log.isDebugEnabled()) {
        log.debug(String.format("%s - Group send: Group[group=%s, id=%d, message=%s", this, group, message.getLong("id"), value));
      }
      eventBus.send(inAddress, message);
    }
    for (OutputHook hook : hooks) {
      hook.handleSend(value);
    }
    checkFull();
  }
935167
def send(self, data):
        """"""
        # send message
        _LOGGER.debug("send: " + data)
        self.socket.send(data.encode('ascii'))
        # sleep needed to prevent flooding the GC100 with sends
        sleep(.01)
132499
def send(self, message_data, delivery_mode=None):
        """"""
        self.publisher.send(message_data, delivery_mode=delivery_mode)
1307392
private void sendMessage(Message message) throws IOException {
        logger.debug("Sending> {}", message);
        int totalSize = 0;
        for (Field field : message.fields) {
            totalSize += field.getBytes().remaining();
        }
        ByteBuffer combined = ByteBuffer.allocate(totalSize);
        for (Field field : message.fields) {
            logger.debug("..sending> {}", field);
            combined.put(field.getBytes());
        }
        combined.flip();
        Util.writeFully(combined, channel);
    }
985997
def shout(self, group, msg_p):
        
        return lib.zyre_shout(self._as_parameter_, group, byref(czmq.zmsg_p.from_param(msg_p)))
938990
def _send(self, messages):
        """"""
        if len(messages) == 1:
            to_send = self._build_message(messages[0])
            if to_send is False:
                # The message was missing recipients.
                # Bail.
                return False
        else:
            pm_messages = list(map(self._build_message, messages))
            pm_messages = [m for m in pm_messages if m]
            if len(pm_messages) == 0:
                # If after filtering, there aren't any messages
                # to send, bail.
                return False
            to_send = PMBatchMail(messages=pm_messages)
        try:
            to_send.send(test=self.test_mode)
        except:
            if self.fail_silently:
                return False
            raise
        return True
83909
def send_acks(self, message):
        
        if isinstance(message, EventHub_pb2.Message):
            ack = EventHub_pb2.Ack(partition=message.partition, offset=message.offset)
            self.grpc_manager.send_message(EventHub_pb2.SubscriptionResponse(ack=ack))

        elif isinstance(message, EventHub_pb2.SubscriptionMessage):
            acks = []
            for m in message.messages:
                acks.append(EventHub_pb2.Ack(parition=m.partition, offset=m.offset))
            self.grpc_manager.send_message(EventHub_pb2.SubscriptionAcks(ack=acks))
1032704
def SendVerack(self):
        """"""
        m = Message('verack')
        self.SendSerializedMessage(m)
        self.expect_verack_next = True
866043
def _send(self, msg):
        """"""
        if isinstance(msg, six.binary_type):
            method = uwsgi.websocket_send_binary
        else:
            method = uwsgi.websocket_send
        if self._req_ctx is not None:
            method(msg, request_context=self._req_ctx)
        else:
            method(msg)
579726
def send(self, msg):
        """"""
        if self._req_ctx is not None:
            self._send(msg)
        else:
            self._send_queue.put(msg)
            self._event.set()
800025
def _send_to_group(self, group, **kwargs):
        
        retries = kwargs.get("retries", self.repeat_commands)
        for _ in range(retries):
            if kwargs.get("send_on", True):
                self.on(group)
            if group is None or group == 0:
                self._send_to_all_groups(**kwargs)
                continue

            if group < 1 or group > 4:
                raise AttributeError("Group must be between 1 and 4 (was %s)" % group)

            if kwargs.get("per_group"):
                self._send_command(kwargs.get("%s_cmd" % self.get_group_type(group), [None, None, None, None])[group - 1])
                continue
            if self.get_group_type(group) == "white":
                command = self.WHITE_COMMANDS.get(kwargs["command"])
            elif self.get_group_type(group) == "rgbw":
                if kwargs["command"] == "color_by_int":
                    command = (self.RGBW_COMMANDS["color_by_int"], struct.pack("B", kwargs["color"]))
                else:
                    command = self.RGBW_COMMANDS.get(kwargs["command"])
            self._send_command(command)
906171
private void doGroupEnd(final JsonObject message) {
    String groupID = message.getString("group");
    DefaultConnectionInputGroup group = groups.remove(groupID);
    if (group != null) {
      Object args = deserializer.deserialize(message);
      if (log.isDebugEnabled()) {
        log.debug(String.format("%s - Group ended: Group[group=%s, args=%s]", this, group.id(), args));
      }
      group.handleEnd(args);
    }
  }
751643
def send(self, message, level=Level.NOTICE):
    ""
    data = "<%d>%s" % (level + self.facility*8, message)
    if self.protocol == 'UDP':
        self.socket.sendto(data.encode('utf-8'), (self.host, self.port))
    else:
        self.socket.send(data.encode('utf-8'))
1188347
def send_msg(self, chat_id, msg_type, **kwargs):
        
        return self.send(chat_id, msg_type, **kwargs)
725320
def _sendMessage(self, msg):
        
        if not msg:
            return
        msg = self._collapseMsg(msg)
        self.sendStatus(msg)
822639
def send(self, group_id=None, message_dict=None):
        
        if self.group is not None and self.group.id is not None:
            group_id = self.group.id

        path = 'message/%s' % group_id

        if message_dict is not None:
            request_data = {
                'message': message_dict,
            }
        else:
            subject = self.subject
            text = self.text
            markdown = self.markdown

            request_data = {
                'message': {},
            }
            if subject:
                request_data['message']['subject'] = subject
            if text:
                request_data['message']['text'] = text
            if markdown:
                request_data['message']['markdown'] = markdown

        response_data = self.api.request(path, request_data)

        self.id = response_data['message_id']
        self.thread_id = response_data['thread_id']
        self.sent_message = FiestaMessage(self.api, response_data['message'])
1116494
def send_group_image(self, sender, receiver, media_id):
        
        return self.send_image(sender, 'group', receiver, media_id)