Fetch all the calls
from a bridge

@return: list of calls
333293
public function fetchCalls()
    {
      $url = URIResource::Make($this->path, array($this->id, "calls"));
      $res = $this->client->get($url);	
      $this->calls = new CallCollection(new DataPacketCollection($res));

      return $this->calls;
    }
24169
def visit_Call(self, node):
        
        args = [self.visit(arg) for arg in node.args]
        func = self.visit(node.func)
        params = args + [func or []]
        return list({frozenset.union(*p) for p in itertools.product(*params)})
903816
def all_functions_called(self):
        '''
            
        '''
        all_calls = [f.all_internal_calls() for f in self.functions + self.modifiers] + [self.functions + self.modifiers]
        all_calls = [item for sublist in all_calls for item in sublist] + self.functions
        all_calls = list(set(all_calls))

        all_constructors = [c.constructor for c in self.inheritance]
        all_constructors = list(set([c for c in all_constructors if c]))

        all_calls = set(all_calls+all_constructors)

        return [c for c in all_calls if isinstance(c, Function)]
1367080
public function getCalls()
    {
        if (null == $this->calls) {
            $this->calls = $this->extractCalls();
        }

        return $this->calls;
    }
328620
def all_low_level_calls(self):
        
        if self._all_low_level_calls is None:
            self._all_low_level_calls = self._explore_functions(lambda x: x.low_level_calls)
        return self._all_low_level_calls
1013222
def retrieve_all(self):
        
        with sqlite3.connect(self.dbname) as carddb:
            for row in carddb.execute("SELECT code FROM CARDS"):
                yield self.load_card(row[0])
214779
def get_method_bridges(self, name, arg_types=()):
        

        for m in self.get_methods_by_name(name):
            if ((m.is_bridge() and
                 m.get_arg_type_descriptors() == arg_types)):
                yield m
38165
def get_ports
      begin
        @port.get_ports
      rescue => ex
        Util.log_exception(ex, caller_locations(1, 1)[0].label)
        raise ex
      end
    end
802771
def get_all(self):
        
        self.optional_params = {}
        self.endpoints = self._ENDPOINTS[:10]
        json_data = self.fetch(fmt_p=no_pandas)
        self.endpoints = self._ENDPOINTS[10:20]
        json_data_2 = self.fetch(fmt_p=no_pandas)
        for symbol in self.symbols:
            if symbol not in json_data:
                raise IEXSymbolError(symbol)
            json_data[symbol].update(json_data_2[symbol])
        return json_data[self.symbols[0]] if self.n_symbols == 1 else json_data
750945
def connections(self):
        
        conn = lambda x: str(x).replace('connection:', '')
        return [conn(name) for name in self.sections()]
307482
def get_requests(self):
        
        safe = self.get_safe_struct()

        self.download_list = []
        self.structure_recursion(safe, self.parent_folder)
        self.sort_download_list()
        return self.download_list, self.folder_list
364172
protected function getCalls() {
        if (!$this->_calls) {
            $this->_calls = new AuthTypeCallsList(
                $this->version,
                $this->solution['accountSid'],
                $this->solution['domainSid']
            );
        }

        return $this->_calls;
    }
692010
def __get_calls_from_parser(proxy_parser, real_parser):
    
    __parsers[proxy_parser] = real_parser
    for method, safe, args, kwargs, proxy_subparser in proxy_parser.calls:
        args = (__proxy_to_real_parser(v) for v in args)
        kwargs = {k: __proxy_to_real_parser(v) for k, v in kwargs.items()}
        real_subparser = getattr(real_parser, method)(*args, **kwargs)
        if real_subparser is not None:
            __get_calls_from_parser(proxy_subparser, real_subparser)
1343755
def all_ports(self):
        
        from mbuild.port import Port
        return [successor for successor in self.successors()
                if isinstance(successor, Port)]
71234
def lastCall(self): #pylint: disable=invalid-name
        
        last_index = len(super(SinonSpy, self)._get_wrapper().call_list) - 1
        return self.getCall(last_index)
1171534
def collect(self):
        
        with SCCallSiteSync(self.context) as css:
            sock_info = self.ctx._jvm.PythonRDD.collectAndServe(self._jrdd.rdd())
        return list(_load_from_socket(sock_info, self._jrdd_deserializer))
905394
def _get_callsites(self, function_address):
        

        all_predecessors = []

        nodes = self.get_all_nodes(function_address)
        for n in nodes:
            predecessors = list(self.get_predecessors(n))
            all_predecessors.extend(predecessors)

        return all_predecessors