See :meth:`CallChain.call_no_reply`.
199534
def call_no_reply(self, fn, *args, **kwargs):
        
        self.default_call_chain.call_no_reply(fn, *args, **kwargs)
1292962
def responds(self):
        
        contacted_text = self._contacted_xpb.\
                         get_text_(self.profile_tree).lower()
        if 'contacted' not in contacted_text:
            return contacted_text.strip().replace('replies ', '')
1294536
def _do_fail_callback(
            self, reason, msg, reply_cb, inform_cb, user_data, timeout_handle):
        """"""
        # this may also result in reply_cb being None if no
        # reply_cb was passed to the request method

        if reply_cb is None:
            # this happens if no reply_cb was passed in to the request
            return

        reason_msg = Message.reply(msg.name, "fail", reason, mid=msg.mid)

        try:
            if user_data is None:
                reply_cb(reason_msg)
            else:
                reply_cb(reason_msg, *user_data)
        except Exception:
            e_type, e_value, trace = sys.exc_info()
            exc_reason = "\n".join(traceback.format_exception(
                e_type, e_value, trace, self._tb_limit))
            self._logger.error("Callback reply during failure %s, %s FAIL: %s" %
                               (reason, msg.name, exc_reason))
1107971
def _process_response(self, reply):
        """"""
        self._advance_cluster_time(reply.get('$clusterTime'))
        self._advance_operation_time(reply.get('operationTime'))
        if self._in_transaction and self._transaction.sharded:
            recovery_token = reply.get('recoveryToken')
            if recovery_token:
                self._transaction.recovery_token = recovery_token
555851
def neverCalledWithMatch(cls, spy, *args, **kwargs): #pylint: disable=invalid-name
        
        cls.__is_spy(spy)
        if not (spy.neverCalledWithMatch(*args, **kwargs)):
            raise cls.failException(cls.message)
1116928
public static void assertNotAnswered(String msg, SipCall call) {
    assertNotNull("Null assert object passed in", call);
    assertFalse(msg, call.isCallAnswered());
  }
800444
def reply_to(self) -> Optional[Sequence[AddressHeader]]:
        """"""
        try:
            return cast(Sequence[AddressHeader], self[b'reply-to'])
        except KeyError:
            return None
724040
def close(self, reply_code=0, reply_text='', class_id=0, method_id=0):
        '''
        
        '''
        # In the off chance that we call this twice. A good example is if
        # there's an error in close listeners and so we're still inside a
        # single call to process_frames, which will try to close this channel
        # if there's an exception.
        if hasattr(self, 'channel'):
            self.channel.close(reply_code, reply_text, class_id, method_id)
1248749
def get_replies_to(self, msg):
        
        mid = msg.get_message_id()
        msg_hash = self.get_messages()
        for m in msg_hash.keys():
            if m.get_message_id() == mid:
                return msg_hash[m]
        return None
473794
def handle_reply(self, msg):
        
        method = self.__class__.unhandled_reply
        if msg.name in self._reply_handlers:
            method = self._reply_handlers[msg.name]

        try:
            return method(self, msg)
        except Exception:
            e_type, e_value, trace = sys.exc_info()
            reason = "\n".join(traceback.format_exception(
                e_type, e_value, trace, self._tb_limit))
            self._logger.error("Reply %s FAIL: %s" % (msg.name, reason))
1224117
def callback(request):
    """"""
    message_id = request.GET.get('messageId')
    status_id = request.GET.get('status')
    status_msg = NEXMO_STATUSES.get(status_id, UNKNOWN_STATUS)
    error_id = int(request.GET.get('err-code'))
    error_msg = NEXMO_MESSAGES.get(error_id, UNKNOWN_MESSAGE)

    logger.info(u'Nexmo callback: Sms = %s, Status = %s, message = %s' % (
        message_id,
        status_msg,
        error_msg
    ))

    # Nexmo expects a 200 response code
    return HttpResponse('')
745770
def callRemoteMessage(self, mcall, timeout=None):
        
        assert isinstance(mcall, message.MethodCallMessage)

        if mcall.expectReply:
            d = defer.Deferred()

            if timeout:
                timeout = reactor.callLater(
                    timeout, self._onMethodTimeout, mcall.serial, d)

            self._pendingCalls[mcall.serial] = (d, timeout)

            self.sendMessage(mcall)

            return d
        else:
            self.sendMessage(mcall)

            return defer.succeed(None)
591604
def _replies(self, *args, **kwargs):
        """"""
        reply_msg = make_reply(*args, **kwargs)
        if self._server:
            self._server._log('\t%d\t<-- %r' % (self.client_port, reply_msg))
        reply_bytes = reply_msg.reply_bytes(self)
        self._client.sendall(reply_bytes)
1015221
def terminate_conversation_and_all_call_legs(trace_only = false)

      if self.conversation

        Rails.logger.info "zestphone: ** Terminating all linked calls and conversation **"
        Rails.logger.info "zestphone: conversation - (pre) state:   #{self.conversation.state}"
        Rails.logger.info "zestphone: conversation - (pre) details: #{self.conversation.inspect}"
        Rails.logger.info "zestphone: calls - (pre) states:  #{self.conversation.calls.map(&:state)}"
        Rails.logger.info "zestphone: calls - (pre) details: #{self.conversation.calls.map(&:inspect)}"

        unless trace_only
          self.conversation.calls.each do |c|
            c.terminate
          end
          self.conversation.terminate
        end
      else
        #  Conversation not found - terminate the current call anyway
        Rails.logger.info "zestphone: call - details: #{self.inspect}"
        self.terminate unless trace_only
      end
    end
1038577
def respond_to_missing?(method_name, include_private = false)
      *_, callback_name = *method_name.to_s.match(/^(\w*?on_\w+?)_(\w+)$/)
      callback_name && callback_names.include?(:"#{callback_name}")
    end
1104768
def silent(cmd, **kwargs):
    
    return call(cmd, shell=True, stdout=NULL, stderr=NULL, **kwargs)
1215251
async def call(self,
                   method: Text,
                   _ignore: Set[Text] = None,
                   **params: Any):
        

        logger.debug('Calling Telegram %s(%s)', method, params)

        url = self.make_url(method)

        headers = {
            'content-type': 'application/json',
        }

        post = self.session.post(
            url,
            data=ujson.dumps(params),
            headers=headers,
        )

        async with post as r:
            out = await self._handle_telegram_response(r, _ignore)
            logger.debug('Telegram replied: %s', out)
            return out