Return only the most relevant callsigns
518206
def callsigns(self) -> Set[str]:
        """"""
        sub = self.data.query("callsign == callsign")
        return set(cs for cs in sub.callsign if len(cs) > 3 and " " not in cs)
28921
def callable_name(func: Callable) -> str:
    """"""
    if func.__module__ == 'builtins':
        return func.__name__
    else:
        return '{}.{}'.format(func.__module__, func.__qualname__)
61196
def calls(self):
        
        if self._calls is None:
            self._calls = CallList(self._version, account_sid=self._solution['sid'], )
        return self._calls
3575
def getMethods(self):
        
        callables = {}

        for name in dir(self.service):
            method = getattr(self.service, name)

            if name.startswith('_') or not python.callable(method):
                continue

            callables[name] = method

        return callables
231038
def _get_call_class(method):
    """"""
    call_base, call_name = method.split('.', 1)
    # import the call class's module
    mod = __import__('ubersmith.calls.{0}'.format(call_base), fromlist=[''])
    # grab all the public members of the module
    gen = (getattr(mod, x) for x in dir(mod) if not x.startswith('_'))
    # filter them down to subclasses of BaseCall
    gen = (x for x in gen if type(x) is type and issubclass(x, BaseCall))
    # return first one that matches our method
    for call_class in gen:
        if call_class.method == method:
            return call_class
    else:
        class GenericCall(BaseCall):
            method = '.'.join((call_base, call_name))
        return GenericCall
507438
def _get_name_filters(cls, filters):
        """"""
        filters = filters.get(cls.__uid_field__)
        if not filters:
            filters = '.*'
        elif not isinstance(filters, string_types):
            filters = r'(%s)' % ('|'.join(filters))
        return filters
398083
def get_Callable_args_res(clb):
    
    try:
        return clb.__args__, clb.__result__
    except AttributeError:
        # Python 3.6
        return clb.__args__[:-1], clb.__args__[-1]
777272
def get_defaults(self):
        """"""
        defaults = self._defaults.copy()
        for field_key, default in self._default_callables.items():
            defaults[field_key] = default()
        return defaults
794536
def _get_callers(items, stage, special_cases=False):
    
    callers = utils.deepish_copy(_CALLERS[stage])
    if special_cases and "cnvkit" in callers:
        has_lumpy = any("lumpy" in get_svcallers(d) or "lumpy" in d["config"]["algorithm"].get("svcaller_orig", [])
                        for d in items)
        if has_lumpy and any("lumpy_usecnv" in dd.get_tools_on(d) for d in items):
            if stage != "initial":
                del callers["cnvkit"]
        else:
            if stage != "standard":
                del callers["cnvkit"]
    return callers
1133949
def get_client_calls(source_code):
    # type: (str) -> APICallT
    
    parsed = parse_code(source_code)
    t = SymbolTableTypeInfer(parsed)
    binder = t.bind_types()
    collector = APICallCollector(binder)
    api_calls = collector.collect_api_calls(parsed.parsed_ast)
    return api_calls
1212369
def get_reversed_aliases(self):
        
        return dict((v, k) for k, v in six.iteritems(self.aliases))
71234
def lastCall(self): #pylint: disable=invalid-name
        
        last_index = len(super(SinonSpy, self)._get_wrapper().call_list) - 1
        return self.getCall(last_index)
1238202
def retrieveVals(self):
        """"""
        fs = FSinfo(self._fshost, self._fsport, self._fspass)
        if self.hasGraph('fs_calls'):
            count = fs.getCallCount()
            self.setGraphVal('fs_calls', 'calls', count)
        if self.hasGraph('fs_channels'):
            count = fs.getChannelCount()
            self.setGraphVal('fs_channels', 'channels', count)
1116640
function getMutations(spec, attr) {
      var fns = compose(extraction, cleanup, stitch)(spec);
      return _.callmap(fns, attr);
    }
737585
def c_getprocs(self):
        """"""
        getprocs = []
        for name, dummy_args in self.funcs:
            if name == 'GetProcAddress':
                if callable(self.opts.hash_func):
                    continue
                getter = 'get_proc_by_string'
            elif self.opts.no_structs:
                getter = 'GetProcAddress'
            else:
                getter = 'windll->kernel32.GetProcAddress'
            if callable(self.opts.hash_func):
                getter = 'get_proc_by_hash'
            if self.opts.no_structs:
                var = name
            else:
                var = 'windll->{}.{}'.format(self.name, name)
            getproc = '{} = ({} *){}({}, {}{});\n'.format(
                var,
                self._c_type_name(name),
                getter,
                self._c_base_var(),
                self.opts.prefix, name
            )
            getprocs.append(getproc + self._c_null_check(var))
        return getprocs
230621
function getNames (resourceType) {
  const aliases = [resourceType];
  if (resourceAliases[resourceType]) {
    return aliases.concat(resourceAliases[resourceType]);
  }
  return alias(resourceType);
}
358982
def decode_call(self, call):
        
        # Callable name is None when callable is part of exclude list
        if call is None:
            return None
        itokens = call.split(self._callables_separator)
        odict = {}
        for key, value in self._clut.items():
            if value in itokens:
                odict[itokens[itokens.index(value)]] = key
        return self._callables_separator.join([odict[itoken] for itoken in itokens])