For a given item (scope + name), return all strings (in a tuple)
        that it is meant to execute, if any exist.  Returns None is none.
176155
def getExecuteStrings(self, parScope, parName):
        
        # The data structure of _allExecutes was chosen for how easily/quickly
        # this particular access can be made here.
        fullName = parScope+'.'+parName
        return self._allExecutes.get(fullName)
668802
def any(self, func):
        
        return any([func(k, v) for k, v in self.items()])
562111
def _get_key_values(self, name):
        
        results = {}

        for key, value in self.qs.items():
            try:
                if not key.startswith(name):
                    continue

                key_start = key.index('[') + 1
                key_end = key.index(']')
                item_key = key[key_start:key_end]

                if ',' in value:
                    item_value = value.split(',')
                else:
                    item_value = value
                results.update({item_key: item_value})
            except Exception:
                raise BadRequest("Parse error", source={'parameter': key})

        return results
1242320
def scope_to_list(scope):
    """"""
    if isinstance(scope, (tuple, list, set)):
        return [unicode_type(s) for s in scope]
    elif scope is None:
        return None
    else:
        return scope.strip().split(" ")
322616
def itemgetters(*args):
    

    f = itemgetter(*args)

    def inner(l):
        return [f(x) for x in l]

    return inner
286915
def scope(self, key):
        '''
        '''
        if self.name is None:
            return key
        return '{:s}/{:s}'.format(self.name, key)
608967
def items(self):
        ''''''
        if hasattr(self, '_items'):
            return self.filter_items(self._items)
        self._items = self.get_items()
        return self.filter_items(self._items)
528623
def _parse(cls, scope):
    
    if not scope:
      return ('default',)
    if isinstance(scope, string_types):
      scope = scope.split(' ')
    scope = {str(s).lower() for s in scope if s}
    return scope or ('default',)
800328
def get_named_by_definition(cls, element_list, string_def):
        """"""
        try:
            return next(
                (
                    st.value
                    for st in element_list
                    if st.definition == string_def
                )
            )
        except Exception:
            return None
1125230
def items(self):
        
        if self.matcher:
            for item in self._fetch_items():
                if self.matcher.match(item):
                    yield item
        else:
            for item in self._fetch_items():
                yield item
1159540
def find_item(self, fq_name):
        
        names = fq_name.split(self._separator)
        current = self._yapconf_items
        for name in names:
            if isinstance(current, (YapconfDictItem, YapconfListItem)):
                current = current.children

            if name not in current:
                return None
            current = current[name]
        return current
118694
def to_names(scope):
    
    return [
        name
        for (name, value) in SCOPE_NAME_DICT.iteritems()
        if check(value, scope)
    ]
718780
def get_by(self, name):
    """"""
    return next((item for item in self if item.name == name), None)
507076
def get_item_string(items_list):
    
    if not items_list:
        return ''
    string_list = []
    for item in items_list:
        try:
            name = item.name
            string_list.append(name)
        except AttributeError:
            pass
    return ":".join(string_list)
1031544
def list_to_scope(scope):
    """"""
    if isinstance(scope, unicode_type) or scope is None:
        return scope
    elif isinstance(scope, (set, tuple, list)):
        return " ".join([unicode_type(s) for s in scope])
    else:
        raise ValueError("Invalid scope (%s), must be string, tuple, set, or list." % scope)
634844
def get(self, item):
        
        if isinstance(item, six.string_types):
            item = super(StorageClient, self).get(item)
        return item
552212
def _search_generator(self, item: Any) -> Generator[Tuple[Any, Any], None, None]:
        """"""
        results = 0
        for key, value in self.enumerate(item):
            yield key, value
            results += 1
        if results == 0:
            raise SearchError(str(item))