Answer the phone call.        
        :return: self (for chaining method calls)
973687
def answer(self):
        
        if self.ringing:
            self._gsmModem.write('ATA')
            self.ringing = False
            self.answered = True
        return self
887468
def call_list(self):
        """"""
        vals = []
        thing = self
        while thing is not None:
            if thing.from_kall:
                vals.append(thing)
            thing = thing.parent
        return _CallList(reversed(vals))
107787
def ask(self, choices, **options):
        
# # **Sun May 15 21:21:29 2011** -- egilchri

        # Settng the voice in this method call has priority.
	# Otherwise, we can pick up the voice from the Tropo object,
	# if it is set there.
        if hasattr (self, 'voice'):
            if (not 'voice' in options):
                options['voice'] = self.voice
        
# # **Sun May 15 21:21:29 2011** -- egilchri

        self._steps.append(Ask(choices, **options).obj)
910274
function dummy(caller) {
    return function() {
      queue.call({caller: caller}, slice.call(arguments, 0));
      return self;
    }
  }
331207
def getCallSet(self, id_):
        
        if id_ not in self._callSetIdMap:
            raise exceptions.CallSetNotFoundException(id_)
        return self._callSetIdMap[id_]
1222846
def set_caller(self, caller):
        
        self.caller = caller.__name__
        self.module = inspect.getmodule(caller).__name__
        self.load()
827013
def on_call(receiver, dot, method)
      if rcv = resolve_receiver(receiver)
        method_call(method, [rcv])
      end
       
      keep_walking(receiver)
    end
1132622
def from_call(cls, call_node):
        """"""
        callcontext = contextmod.CallContext(call_node.args, call_node.keywords)
        return cls(callcontext)
40455
def create_callback(self):
        
        def __callback(question_posed):
            logger.debug("%s: asked to choose between: %s" % (self._name, self._qstr(question_posed)))
            if self._upto == len(self._data):
                logger.error("%s: out of automation data, requested to pick between %s" % (self._name, self._qstr(question_posed)))
                raise AutomationException("out of automation data")
            question_archived, answer = self._data[self._upto]
            if question_archived != question_posed:
                logger.error("%s: automation data mismatch, expected question `%s', got question `%s'" % (self._name, self._qstr(question_archived), self._qstr(question_posed)))
            resp = question_posed.index(answer)
            self._upto += 1
            return resp
        return __callback
1126132
def call(self, input_data=None, *args, **kwargs):
        
        self.build_request(input_data)
        self.caller = RequestCall(self.request)
        self.exception = None

        try:
            self.caller.call()
            self.response = self.caller.response
            self.decrypt_result()
            return self.decrypted

        except Exception as e:
            self.exception = e
            logger.info("Exception throw %s", e)
        pass
934926
async def answerCallbackQuery(self, callback_query_id,
                                  text=None,
                                  show_alert=None,
                                  url=None,
                                  cache_time=None):
        
        p = _strip(locals())
        return await self._api_request('answerCallbackQuery', _rectify(p))
771241
def and_before_calling_original
      self.and_wrap_original do |m, *args, &block|
        yield *args
        m.call(*args, &block)
      end
    end
714153
def assert_called(_mock_self):
        
        self = _mock_self
        if self.call_count == 0:
            msg = ("Expected '%s' to have been called." %
                   self._mock_name or 'mock')
            raise AssertionError(msg)
631985
def send_answer(opts = {})
      opts[:retrans] ||= DEFAULT_RETRANS
      msg = <<-MSG

SIP/2.0 200 Ok
[last_Via:]
From: <sip:[$remote_addr]>;tag=[$remote_tag]
To: <sip:[$local_addr]>;tag=[call_number]
[last_Call-ID:]
[last_CSeq:]
Server: #{USER_AGENT}
Contact: <sip:[$local_addr];transport=[transport]>
Content-Type: application/sdp
[routes]
Content-Length: [len]

v=0
o=user1 53655765 2353687637 IN IP[local_ip_type] #{@adv_ip}
s=-
c=IN IP[media_ip_type] [media_ip]
t=0 0
m=audio [media_port] RTP/AVP 0
a=rtpmap:0 PCMU/8000
      MSG
      start_media
      send msg, opts
    end
512158
def call(self, method, **params):
        
        url = self.api_url % method
        request = self._get_request(url, self.METHODS[method], **params)
        try:
            response = urlopen(request)
        except URLError:
            raise
        else:
            response_json = json.loads(response.read())
            if not response_json['succeeded']:
                raise DisqusException(response_json['message'])
            return response_json['message']
930826
def phone():
        
        result = ""
        result += "(" + str(RandomInteger.next_integer(111, 999)) + ") "
        result += str(RandomInteger.next_integer(111, 999))
        result += "-" + str(RandomInteger.next_integer(0, 9999))
        return result
546356
def batch_call(self, calls):
        """"""
        req = self.protocol.create_batch_request()

        for call_args in calls:
            req.append(self.protocol.create_request(*call_args))

        return self._send_and_handle_reply(req)