Start a conversation
164070
def start_conversation(to, channelId, params={})
      Conversation.new(conversation_request(
        :post,
        'conversations/start',
        params.merge({
          :to => to,
          :channelId => channelId,
        })))
    end
719656
def start(self):
        
        if not self.valid:
            err = ("\nMessengers and listeners that still need set:\n\n"
                   "messengers : %s\n\n"
                   "listeners : %s\n") 
            raise InvalidApplication(err % (self.needed_messengers,
                                            self.needed_listeners))
        self.dispatcher.start()
1191130
function sayHello(call, callback) {
  var reply = new messages.HelloReply();
  reply.setMessage('Hello ' + call.request.getName());
  callback(null, reply);
}
1206513
def __send_hello(self):
        """"""

        _logger.debug("Saying hello: [%s]", self)

        self.__c.send(nsq.config.protocol.MAGIC_IDENTIFIER)
126509
function start (inp) {
    var res = parseArgumentList(inp.skipWs());
  
    // If there is any leftover, we have input that did not match our grammar,
    // so throw a generic syntax error.
    if (inp.skipWs().buffer) syntaxError(inp);
    return res;
  }
191259
public void begin() throws SIIncorrectCallException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "begin");

        // Are we currently in use? do we have work
        // we still need to commit?
        if (_state == TransactionState.STATE_ACTIVE && _workList != null)
        {
          SIIncorrectCallException ice = new SIIncorrectCallException(nls.getFormattedMessage("TRAN_PROTOCOL_ERROR_SIMS1001", null, "TRAN_PROTOCOL_ERROR_SIMS1001"));
            if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) SibTr.event(this, tc, "Cannot begin new LocalTran. Existing work needs completing first!", ice);
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "begin");
            throw ice;
        }

        synchronized(this)
        {
          _ptid     = null;
        }
        _workList = null;
        _size     = 0;

        _callbacks.clear();

        _state = TransactionState.STATE_ACTIVE;


        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "begin");
    }
1295782
function(params, callback) {
                chatSendQueue.push(params);
                putInChatWaitQueue(params.message, function() {
                    callback && callback();
                });
            }
541070
public static function jump(): void
    {
        /** @var Manager $conversation */
        $conversation = resolve(Manager::class);
        $conversation->converse(resolve(static::class));
        $conversation->markAsTransitioned();
    }
1340882
def start(self):
        """"""
        if self._index is None:
            self._index = ctypes.c_uint32()
            _canlib.canSchedulerAddMessage(self._scheduler,
                                           self._msg,
                                           self._index)
        _canlib.canSchedulerStartMessage(self._scheduler,
                                         self._index,
                                         self._count)
1171048
def _start(self):
        '''

        '''
        if self.whoami is None:
            me = self.get_me()
            if me.get('ok', False):
                self.whoami = me['result']
            else:
                raise ValueError('Bot Cannot request information, check '
                                 'api_key')
797058
def start(self):
        
        super().start()
        comments_thread = BotThread(name='{}-comments-stream-thread'.format(self._name),
                                    target=self._listen_comments)
        comments_thread.start()
        self._threads.append(comments_thread)
        self.log.info('Starting comments stream ...')
894352
function start(next) {

        if (!name) {
            throw new Error("Please provide a name for your service if you are using .start(). No spaces.");
        }

        mode = "broadcast";

        log("Starting %s[%s] in %s mode", name, id, mode);
        if (status == "inactive") {
            status = "starting";
            listen(function(err) {
                if (err) {
                    if (typeof next == "function") {
                        next(err);
                    }
                    return;
                }
                log("Listening socket for %s[%s] initiated with port %s", name, id, self.port);
                broadcast(function(err) {
                    status = "broadcasting";
                    log("Broadcast for %s[%s] initiated", name, id);
                    if (typeof next == "function") {
                        next(err);
                    }
                });
            });
        }
        else {
            if (typeof next == "function") {
                next();
            }
        }

    }
1351346
def conversations(self, max_id=None, min_id=None, since_id=None, limit=None):
        
        if max_id != None:
            max_id = self.__unpack_id(max_id)
        
        if min_id != None:
            min_id = self.__unpack_id(min_id)
            
        if since_id != None:
            since_id = self.__unpack_id(since_id)            
        
        params = self.__generate_params(locals())
        return self.__api_request('GET', "/api/v1/conversations/", params)
748929
public function touchCurrentConversation()
    {
        if (! is_null($this->currentConversationData)) {
            $touched = $this->currentConversationData;
            $touched['time'] = microtime();

            $this->cache->put($this->message->getConversationIdentifier(), $touched, $this->config['config']['conversation_cache_time'] ?? 30);
        }
    }
502626
public void startChatActivity(Context context, Peer peer, boolean compose) {
        Bundle b = new Bundle();
        b.putLong(Intents.EXTRA_CHAT_PEER, peer.getUnuqueId());
        b.putBoolean(Intents.EXTRA_CHAT_COMPOSE, compose);
        if (!startDelegateActivity(context, delegate.getChatIntent(peer, compose), b, new int[]{Intent.FLAG_ACTIVITY_SINGLE_TOP})) {
            startActivity(context, b, ChatActivity.class);
        }
    }
775119
def start(self):
        """"""
        if not self.writeThread.isAlive() and not self.readThread.isAlive():
            self.client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.client.connect(self.ADDR)
            self.running = True
            self.writeThread.start()
            self.readThread.start()
946531
def start (self):
        '''
        

        '''
        self.sub = rospy.Subscriber(self.topic, BumperEvent, self.__callback)