Returns a path list to all attributes that have with a particular name.
501729
def get_paths_for_attribute(self, attribute_name):
        
        has_name = lambda name, structure:  name == attribute_name
        return self.find_path(has_name, on_targets=True)
32743
def get_attrs(self, *names):
        """"""
        attrs = [getattr(self, name) for name in names]
        return attrs
49884
def path_dirs(urls):
    '''
    
    '''
    path_dirs = StringCounter()
    for url in urls:
        for path_dir in filter(None, urlparse(url).path.split('/')):
            path_dirs[path_dir] += urls[url]
    return path_dirs
292229
def get_attributes(**kwargs):
    

    attrs = db.DBSession.query(Attr).order_by(Attr.name).all()

    return attrs
465652
def attr_list(args):
    ''''''
    args.attributes = None
    result = attr_get(args)
    names = result.get("__header__",[])
    if names:
        names = names[1:]
    else:
        names = result.keys()
    return sorted(names)
346654
def filter_db_names(paths: List[str]) -> List[str]:
    
    return [
        db_path
        for db_path in paths
        if VERSION_RE.match(os.path.basename(db_path))
    ]
901966
public static Iterable<String> getAttributeNames(Iterable<Attribute> attrs) {
    return () -> stream(attrs).map(Attribute::getName).iterator();
  }
1047361
def get_roles_paths(self):
        '''
        
        '''
        roles  = []

        for path in self.config.ROLES:
            roles.append(self.get_absolute_path(path))

        return roles
606592
public List<Attribute> getAttributes(ObjectName name, String[] attributes) throws Exception {
		checkClientConnected();
		return mbeanConn.getAttributes(name, attributes).asList();
	}
16371
def get_path_list(opts):
    
    paths = []
    for opt, arg in list(opts.items()):
        if opt in ('-p', '--jspath'):
            paths.append(arg)
    return paths or [os.getcwd()]
1076483
def _attributeStrs(self):
        
        return ";".join([self._attributeStr(name)
                         for name in self.attributes.iterkeys()])
447364
public Iterator getAttributeNames() {
        if (!_iSess.isValid())
            throw new IllegalStateException();
        Iterator value = null;
        if (_iSess != null) {
            ArrayList list = new ArrayList();
            for (Enumeration e = _iSess.getAttributeNames(); e.hasMoreElements();) {
                list.add(e.nextElement());
            }
            value = list.iterator();
        }
        return value;
    }
542129
def paths(self, value):
        

        if value is not None:
            assert type(value) in (tuple, list), "'{0}' attribute: '{1}' type is not 'tuple' or 'list'!".format(
                "paths", value)
            for element in value:
                assert type(element) is unicode, "'{0}' attribute: '{1}' type is not 'unicode'!".format(
                    "paths", element)
                assert os.path.exists(element), "'{0}' attribute: '{1}' directory doesn't exists!".format("paths",
                                                                                                          element)
        self.__paths = value
885823
private List<List<ConceptId>> getComputePathResultListIncludingImplicitRelations(List<List<ConceptId>> allPaths) {
        List<List<ConceptId>> extendedPaths = new ArrayList<>();
        for (List<ConceptId> currentPath : allPaths) {
            boolean hasAttribute = currentPath.stream().anyMatch(conceptID -> tx.getConcept(conceptID).isAttribute());
            if (!hasAttribute) {
                extendedPaths.add(currentPath);
            }
        }

        // If there exist a path without attributes, we don't need to expand any path
        // as paths contain attributes would be longer after implicit relations are added
        int numExtensionAllowed = extendedPaths.isEmpty() ? Integer.MAX_VALUE : 0;
        for (List<ConceptId> currentPath : allPaths) {
            List<ConceptId> extendedPath = new ArrayList<>();
            int numExtension = 0; // record the number of extensions needed for the current path
            for (int j = 0; j < currentPath.size() - 1; j++) {
                extendedPath.add(currentPath.get(j));
                ConceptId resourceRelationId = Utility.getResourceEdgeId(tx, currentPath.get(j), currentPath.get(j + 1));
                if (resourceRelationId != null) {
                    numExtension++;
                    if (numExtension > numExtensionAllowed) break;
                    extendedPath.add(resourceRelationId);
                }
            }
            if (numExtension == numExtensionAllowed) {
                extendedPath.add(currentPath.get(currentPath.size() - 1));
                extendedPaths.add(extendedPath);
            } else if (numExtension < numExtensionAllowed) {
                extendedPath.add(currentPath.get(currentPath.size() - 1));
                extendedPaths.clear(); // longer paths are discarded
                extendedPaths.add(extendedPath);
                // update the minimum number of extensions needed so all the paths have the same length
                numExtensionAllowed = numExtension;
            }
        }
        return extendedPaths;
    }
474166
def pathNames(self) -> [str]:
        

        return [f.pathName for f in list(self._files.values())]
1371401
def get_path_and_name(full_name):
    
    if full_name:
        parts = full_name.split("/")
        return ("/".join(parts[0:-1]), parts[-1]) if len(parts) > 1 else ("/", full_name)
    return None, None
116693
@Trivial
    @Override
    public Enumeration<String> getAttributeNames() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "Getting attribute names");
        }
        return Collections.enumeration(this.attributes.keySet());
    }