Returns a list of sentinels for ``name``.
761471
def sentinels(self, name):
        """"""
        fut = self.execute(b'SENTINELS', name, encoding='utf-8')
        return wait_convert(fut, parse_sentinel_slaves_and_sentinels)
1252346
def List(self, name, initial=None):
        
        return types.List(name, self.api, initial=initial)
214289
def get_listeners(self, name):
                
        return list(map(lambda listener: listener[0], self.listeners[name]))
1109096
def collection_names(self, callback):
        """"""
        callback = partial(self._collection_names_result, callback)
        self["system.namespaces"].find(_must_use_master=True, callback=callback)
1307158
def select_observations(self, name):
        
        return [n for n in self.get_obs_nodes() if n.obsname==name]
1103539
private NodeList getByName(String name) {
        NodeList answer = new NodeList();
        for (Object child : children()) {
            if (child instanceof Node) {
                Node childNode = (Node) child;
                Object childNodeName = childNode.name();
                if (childNodeName instanceof QName) {
                    QName qn = (QName) childNodeName;
                    if (qn.matches(name)) {
                        answer.add(childNode);
                    }
                } else if (name.equals(childNodeName)) {
                    answer.add(childNode);
                }
            }
        }
        return answer;
    }
358941
def findall(self, name):
        
        return [
            S3Element(self.root_name, elem)
            for elem in self.element.findall('s3:{}'.format(name), _S3_NS)
        ]
1019114
def wc_names(self):
        """"""
        if self.wc_name is None:
            res = set()
        else:
            res = set([self.wc_name])
        if self.args is not None:
            for arg in self.args:
                if isinstance(arg, Pattern):
                    res.update(arg.wc_names)
        if self.kwargs is not None:
            for val in self.kwargs.values():
                if isinstance(val, Pattern):
                    res.update(val.wc_names)
        return res
33897
def _get_commands_by_name(self, blueprint, name):
        
        return list(filter(lambda value: value.name == name, blueprint.get_commands()))
632247
def get_index_by_name(self, name):
        """"""
        for i in range(len(self.vertices)):
            if self.vertices[i].name == name:
                return i
        raise ValueError('Reverse look up of name failed.')
368715
def names(self):
        """"""
        #This is where the context information is extremely useful in 
        #limiting the extent of the search space we need to examine.
        if self._names is None:
            attribute = self.get_attribute()
            if self.context.module is not None:
                symbol = self.context.symbol
                fullsymbol = self.context.full_symbol
                self._names = self._complete_el(symbol, attribute, fullsymbol)
            else:
                self._names = []

        return self._names
1331621
def get_search_names(name):
    
    parts = re.split('[-_.]', name)
    if len(parts) == 1:
        return parts

    result = set()
    for i in range(len(parts) - 1, 0, -1):
        for s1 in '-_.':
            prefix = s1.join(parts[:i])
            for s2 in '-_.':
                suffix = s2.join(parts[i:])
                for s3 in '-_.':
                    result.add(s3.join([prefix, suffix]))
    return list(result)
489706
def get_flagged_names():
    """"""

    l = []
    for w in _widget_cache.values():
        if w.flagged:
            l.append(w.get_node().get_value())
    return l
518591
def get_all(self, name):
        
        return [annot for annot in self.all_annotations if annot.name == name]
941177
def target_names(targets):
    """"""
    names = []
    for entry in targets:
        if isinstance(entry, ast.Name):
            names.append(entry.id)
        elif isinstance(entry, ast.Tuple):
            for element in entry.elts:
                if isinstance(element, ast.Name):
                    names.append(element.id)

    return names
395283
def list_names(cls):
        """"""
        response = subwrap.run(['lxc-ls'])
        output = response.std_out
        return map(str.strip, output.splitlines())
1310376
def get_by_name(self, name): # pylint: disable=invalid-name,redefined-builtin
        
        rs, _ = self.list(filter=field('name').eq(name), limit=1)
        if len(rs) is 0:
            raise CDRouterError('no such device')
        return rs[0]