Fetch and parse the function table.

        Returns:
            A dictionary that maps function IDs to information about the
                function.
168515
def function_table(self, function_id=None):
        
        self._check_connected()
        function_table_keys = self.redis_client.keys(
            ray.gcs_utils.FUNCTION_PREFIX + "*")
        results = {}
        for key in function_table_keys:
            info = self.redis_client.hgetall(key)
            function_info_parsed = {
                "DriverID": binary_to_hex(info[b"driver_id"]),
                "Module": decode(info[b"module"]),
                "Name": decode(info[b"name"])
            }
            results[binary_to_hex(info[b"function_id"])] = function_info_parsed
        return results
281900
def getDXGIOutputInfo(self):
        

        fn = self.function_table.getDXGIOutputInfo
        pnAdapterIndex = c_int32()
        pnAdapterOutputIndex = c_int32()
        fn(byref(pnAdapterIndex), byref(pnAdapterOutputIndex))
        return pnAdapterIndex.value, pnAdapterOutputIndex.value
1204370
def functions(self):
        
        return [v for v in self.globals.values()
                if isinstance(v, values.Function)]
293209
def get_functions(self):
        
        instances = self._get_instances(ast.FunctionDef)
        instances = [
            PyFunction(instance, self.package)
            for instance in instances
        ]
        return instances
54806
def read_table(self, table, key_filter=True):
        
        filters = self.filters[None] + self.filters[table]
        if key_filter:
            for f in self.relations[table]:
                key = f.name
                if f.key and (self._index.get(key) is not None):
                    ids = self._index[key]
                    # Can't keep local variables (like ids) in the scope of
                    # the lambda expression, so make it a default argument.
                    # Source: http://stackoverflow.com/a/938493/1441112
                    function = lambda r, x, ids=ids: x in ids
                    filters.append(([key], function))
        applicators = self.applicators[table]
        rows = self.read_raw_table(table)
        return filter_rows(filters, apply_rows(applicators, rows))
81649
def _getFuncArgs(func):
  
  """
  code = func.func_code
  Defaults = func.func_defaults

  nargs = code.co_argcount
  ArgNames = code.co_varnames[:nargs]

  Args = OrderedDict()
  argCount = len(ArgNames)
  defCount = len(Defaults) if Defaults else 0
  diff = argCount - defCount

  for i in range(0, diff):
    Args[ArgNames[i]] = {}

  for i in range(diff, argCount):
    Args[ArgNames[i]] = {'default': Defaults[i - diff]}

  return Args
1218914
def collect(self):
        
        class_functions = []
        for key in self.__class__.__dict__.keys():
            func = self.__class__.__dict__[key]
            if (inspect.isfunction(func)):
                class_functions.append(func)

        functions = sorted(class_functions, key=lambda func: func.__name__)
        for function in functions:
            value = function(self)
            if value:
                return value
496896
def _dict_of_funcs(self, funcs: list) -> pd.Series:
        """"""
        return {func.__name__: func for func in funcs}
551718
def map(self, func):
        
        for row in self.table:
            for i, cell in enumerate(row):
                row[i] = func(cell)
820544
def get_functions(fname):
    
    txt = '' 
    with open(fname, 'r') as f:
        for line in f:
            if line.strip()[0:4] == 'def ':
                txt += '<PRE>' + strip_text_after_string(strip_text_after_string(line, '#')[4:], ':') + '</PRE>\n'
            if line[0:5] == 'class':
                txt += '<PRE>' + strip_text_after_string(strip_text_after_string(line, '#'), ':') + '</PRE>\n'
    return txt + '<BR>'
1158845
def get_summary(self):
        
        func_summaries = [f.get_summary() for f in self.functions]
        modif_summaries = [f.get_summary() for f in self.modifiers]
        return (self.name, [str(x) for x in self.inheritance], [str(x) for x in self.variables], func_summaries, modif_summaries)
990410
def getDXGIOutputInfo(self):
        

        fn = self.function_table.getDXGIOutputInfo
        pnAdapterIndex = c_int32()
        fn(byref(pnAdapterIndex))
        return pnAdapterIndex.value
980021
def _event_func_names(self, event: str) -> List[str]:
        
        return [func.__name__ for func in self._events[event]]
812451
def get_func_info(func):
    """"""
    name = func.__name__
    doc = func.__doc__ or ""
    try:
        nicename = func.description
    except AttributeError:
        if doc:
            nicename = doc.split('\n')[0]
            if len(nicename) > 80:
                nicename = name
        else:
            nicename = name
    parameters = []
    try:
        closure = func.func_closure
    except AttributeError:
        closure = func.__closure__
    try:
        varnames = func.func_code.co_freevars
    except AttributeError:
        varnames = func.__code__.co_freevars

    if closure:
        for index, arg in enumerate(closure):
            if not callable(arg.cell_contents):
                parameters.append((varnames[index],
                                   text_type(arg.cell_contents)))
    return ({
        "nicename": nicename,
        "doc": doc,
        "parameters": parameters,
        "name": name,
        "time": str(datetime.datetime.now()),
        "hostname": socket.gethostname(),
    })
1105106
def get_table(table_name):
    
    table = get_raw_table(table_name)
    if isinstance(table, TableFuncWrapper):
        table = table()
    return table
812594
def all_function_definitions(function):
    
    return [function] + [f for c in function.contract.inheritance
                         for f in c.functions_and_modifiers_not_inherited
                         if f.full_name == function.full_name]
914522
def load_table_data(self):
        
        # We only want the data to be loaded once, so we track if we have...
        if not self._table_data_loaded:
            for table_name, table in self._tables.items():
                # Fetch the data function.
                func_name = "get_%s_data" % table_name
                data_func = getattr(self, func_name, None)
                if data_func is None:
                    cls_name = self.__class__.__name__
                    raise NotImplementedError(
                        "You must define a %(func_name)s method on"
                        " %(cls_name)s."
                        % {'func_name': func_name, 'cls_name': cls_name})

                # Load the data.
                table.data = data_func()
                table._meta.has_prev_data = self.has_prev_data(table)
                table._meta.has_more_data = self.has_more_data(table)
            # Mark our data as loaded so we don't run the loaders again.
            self._table_data_loaded = True