Get an iter of VenvPaths within the directory.
502147
def paths(self):
        """"""
        contents = os.listdir(self.path)
        contents = (os.path.join(self.path, path) for path in contents)
        contents = (VenvPath(path) for path in contents)
        return contents
1193383
def path_for(self, *args):
        """"""
        if args and args[0].startswith(os.path.sep):
            return os.path.join(*args)
        return os.path.join(self._root_path or os.getcwd(), *args)
541872
def linuxPaths(self):
        
        for ((dirTree, dirID, dirSeq), (dirPath, name)) in self.links.items():
            for path in self.fileSystem.volumes[dirTree].linuxPaths:
                yield path + "/" + dirPath + name
        if self.fullPath in self.fileSystem.mounts:
            yield self.fileSystem.mounts[self.fullPath]
116265
def extra_paths():
    
    # TODO - this is only tested on Ubuntu for now
    #        there must be a better way of getting
    #        the sip directory.
    dirs = {}
    try:
        @vext.env.run_in_syspy
        def run(*args):
            import sipconfig
            config = sipconfig.Configuration()
            dirs = {
                "sip.default_sip_dir": config.default_sip_dir,
            }
            return dirs
        dirs = run()
        return dirs
    except ImportError:
        return dirs
516385
def path(self) -> Path:
        """"""
        args = list(self._iter_translated_field_names(self.get_path_pattern_list()))
        args.append(self.get_name())
        return Path(*args)
737219
def _get_names(self, path: str) -> Iterator[str]:
        
        for i in RequirementsFinder._get_names_cached(path):
            yield i
1244017
def _iter_path(pointer):
    
    _check_status(pointer.status)
    data = pointer.data
    num_data = pointer.num_data
    points_per_type = PATH_POINTS_PER_TYPE
    position = 0
    while position < num_data:
        path_data = data[position]
        path_type = path_data.header.type
        points = ()
        for i in range(points_per_type[path_type]):
            point = data[position + i + 1].point
            points += (point.x, point.y)
        yield (path_type, points)
        position += path_data.header.length
149512
def get_paths(folder):
    ''''''
    folder = pathlib.Path(folder).resolve()
    files = folder.rglob("*_phase.txt")
    return sorted(files)
712828
def _iter_path_collection(paths, path_transforms, offsets, styles):
        """"""
        N = max(len(paths), len(offsets))

        if not path_transforms:
            path_transforms = [np.eye(3)]

        edgecolor = styles['edgecolor']
        if np.size(edgecolor) == 0:
            edgecolor = ['none']
        facecolor = styles['facecolor']
        if np.size(facecolor) == 0:
            facecolor = ['none']

        elements = [paths, path_transforms, offsets,
                    edgecolor, styles['linewidth'], facecolor]

        it = itertools
        return it.islice(py3k.zip(*py3k.map(it.cycle, elements)), N)
1138902
def _get_verts_and_connect(self, paths):
        
        verts = np.vstack(paths)
        gaps = np.add.accumulate(np.array([len(x) for x in paths])) - 1
        connect = np.ones(gaps[-1], dtype=bool)
        connect[gaps[:-1]] = False
        return verts, connect
823089
def get_paths(directory):
    '''
    '''
    fnames = [os.path.join(directory, f)
              for f in os.listdir(directory)
              if os.path.isfile(os.path.join(directory, f))
              and not f.startswith('.')]
    return fnames
152099
def print_paths(self):
        """"""
        # Uses a list to get the order right
        ret = []
        for i in self._get_paths():
            if i not in ret:
                ret.append(i)
        return os.pathsep.join(ret)
363555
public static String getPathsString(Collection<VirtualFile> paths) {
        if (paths == null) {
            throw MESSAGES.nullArgument("paths");
        }
        StringBuilder buffer = new StringBuilder();
        boolean first = true;
        for (VirtualFile path : paths) {
            if (path == null) { throw new IllegalArgumentException("Null path in " + paths); }
            if (first == false) {
                buffer.append(':');
            } else {
                first = false;
            }
            buffer.append(path.getPathName());
        }
        if (first == true) {
            buffer.append("<empty>");
        }
        return buffer.toString();
    }
749302
def iter_directory(directory):
    """"""
    for path, dir, files in os.walk(directory):
        for f in files:
            filepath = os.path.join(path, f)
            key = os.path.relpath(filepath, directory)
            yield (filepath, key)
436457
def get_tools_paths(self):
        """"""
        if settings.DEBUG or is_testing():
            return list(get_apps_tools().values())

        else:
            tools_root = settings.FLOW_TOOLS_ROOT
            subdirs = next(os.walk(tools_root))[1]

            return [os.path.join(tools_root, sdir) for sdir in subdirs]
601974
def extract_paths(self, paths, *args, **kwargs):
        
        return self.provider.extract_paths(paths, *args, **kwargs)
209747
def _build_paths(venv=None):
    
    if venv:
        paths = venv.paths
    else:
        paths = sysconfig.get_paths()
    return {
        "prefix": sys.prefix if not venv else venv.venv_dir.as_posix(),
        "data": paths["data"],
        "scripts": paths["scripts"],
        "headers": paths["include"],
        "purelib": paths["purelib"],
        "platlib": paths["platlib"],
    }