Create a new StreamMessageInstance

        :param dict data: Stream Message body.

        :returns: Newly created StreamMessageInstance
        :rtype: twilio.rest.sync.v1.service.sync_stream.stream_message.StreamMessageInstance
321286
def create(self, data):
        
        data = values.of({'Data': serialize.object(data), })

        payload = self._version.create(
            'POST',
            self._uri,
            data=data,
        )

        return StreamMessageInstance(
            self._version,
            payload,
            service_sid=self._solution['service_sid'],
            stream_sid=self._solution['stream_sid'],
        )
734220
def dataReceived(self, data):
        
        self.stompBuffer.appendData(data)

        while True:
           msg = self.stompBuffer.getOneMessage()
           if msg is None:
               break

           returned = self.react(msg)
           if returned:
               self.transport.write(returned)
228876
def create(self, data):
				
		q = self.history.insert_one(data).inserted_id
		logging.debug(self.history.find_one({"_id":q}))
901726
def update(self, body):
        
        data = values.of({'Body': body, })

        payload = self._version.update(
            'POST',
            self._uri,
            data=data,
        )

        return MessageInstance(
            self._version,
            payload,
            account_sid=self._solution['account_sid'],
            sid=self._solution['sid'],
        )
914616
def onBinaryMessage(self, msg, fromClient):
		data = bytearray()
		data.extend(msg)

		

		try:
			self.queue.put_nowait(data)
		except asyncio.QueueFull:
			pass
1056049
def create_model_instance(self, data):
        
        return self.model(
            session_key=self._get_or_create_session_key(),
            session_data=self.encode(data),
            expire_date=self.get_expiry_date(),
        )
1012025
def sendMessage(self, data):
      
      opcode = BINARY
      if isinstance(data, unicode):
         opcode = TEXT
      self._sendMessage(False, opcode, data)
1361896
def create_event(msg: EventMsgDict) -> Event:
    
    proto = msg.get('proto', '')
    cls = proto_dict.get(proto, Event)
    e = cls(msg['type'], msg)
    return e
1117531
@Override
    public IQueueMessage<ID, DATA> createMessage(DATA content) {
        return messageFactory.createMessage(content);
    }
941491
def create(self, data):
        
        try:
            floyd_logger.info("Making create request to server...")
            post_body = data.to_dict()
            post_body["resumable"] = True
            response = self.request("POST", self.url, json=post_body)
            return response.json()
        except BadRequestException as e:
            if 'Dataset not found, ID' in e.message:
                floyd_logger.error(
                    'Data create: ERROR! Please run "floyd data init DATASET_NAME" before upload.')
            else:
                floyd_logger.error('Data create: ERROR! %s', e.message)
            return None
        except FloydException as e:
            floyd_logger.error("Data create: ERROR! %s", e.message)
            return None
269602
def append(self, data):
        
        if isinstance(data, six.text_type):
            self._message.add_body_data(data.encode(self._encoding))
        elif isinstance(data, six.binary_type):
            self._message.add_body_data(data)
773490
def create(self, msgtype, *args, **kwargs):
        ''' 

        '''
        if msgtype not in self._messages:
            raise ProtocolError("Unknown message type %r for protocol version %s" % (msgtype, self._version))
        return self._messages[msgtype].create(*args, **kwargs)
250109
public Message createObjectMessage(Serializable messageData, String sender, String recipients) {
        try {
            return decorateMessage(getSession().createObjectMessage(messageData), sender, recipients);
        } catch (JMSException e) {
            throw MiscUtil.toUnchecked(e);
        }
    }
1196506
def create(**data):
        
        http_client = HttpClient()
        response, _ = http_client.post(routes.url(routes.CUSTOMER_RESOURCE), data)
        return resources.Customer(**response)
193622
def create_message(self, channel_id, text):
        

        baseurl = self.rest_baseurl + \
            '/channels/{}/messages'.format(channel_id)
        requests.post(baseurl,
                      headers=self.headers,
                      data=json.dumps({'content': text}))
998002
def new_message(self, body=''):
        
        m = self.message_class(self, body)
        m.queue = self
        return m
883945
def new(cls, data=None):
		
		obj = cls()
		if data is not None:
			obj.update(data)
		return obj