Get the path of the wrapped folder
354033
def path(self):
        '''  '''
        if isinstance(self.dir, Directory):
            return self.dir._path
        elif isinstance(self.dir, ROOT.TDirectory):
            return self.dir.GetPath()
        elif isinstance(self.dir, _FolderView):
            return self.dir.path()
        else:
            return str(self.dir)
570017
public static function getPathWithResolvedParents(string $folder): string
    {
        $withoutTrailingParents = \preg_replace('~([\\/][.]{2})*$~', '', $folder);
        $parentsCount = (int)((\strlen($folder) - \strlen($withoutTrailingParents)) / 3);
        while ($parentsCount > 0 && $withoutTrailingParents !== '') {
            $withoutTrailingParents = \dirname($withoutTrailingParents, 1);
            $parentsCount--;
            [$withoutTrailingParents, $newParentsCount] = self::getDirWithoutTrailingParentsAndTheirCount($withoutTrailingParents);
            $parentsCount += $newParentsCount;
        }

        return \basename($withoutTrailingParents);
    }
442846
def get_path_name(self):
        
        path = fix_raw_path(os.path.dirname(os.path.abspath(self.path)))
        name = os.path.basename(self.path)
        return path, name
67475
def path(self, separator="/"):
        """"""
        rt = ""
        for i in reversed(self):
            rt = "{}{}{}".format(rt, i.name, separator)
        return rt[:-1]
937620
def path(self):
        """"""
        names = []
        obj = self
        while obj:
            names.insert(0, obj.name)
            obj = obj.parent_dir
        sep = self.filesystem._path_separator(self.name)
        if names[0] == sep:
            names.pop(0)
            dir_path = sep.join(names)
            # Windows paths with drive have a root separator entry
            # which should be removed
            is_drive = names and len(names[0]) == 2 and names[0][1] == ':'
            if not is_drive:
                dir_path = sep + dir_path
        else:
            dir_path = sep.join(names)
        dir_path = self.filesystem.absnormpath(dir_path)
        return dir_path
582979
def _get_path(dict_, path):
    '''
    
    '''
    cur = dict_
    for part in path.split('/'):
        cur = cur[part]
    return cur
1259177
def complete_path(curr_dir, last_dir):
    
    if not last_dir or curr_dir.startswith(last_dir):
        return curr_dir
    elif last_dir == '~':
        return os.path.join(last_dir, curr_dir)
1309482
def dirpath(self):
        """"""
        if self.isfile():
            return Path(op.dirname(self._fspath))
        else:
            return Path(self)
620799
function getPath(parent, unresolved) {
	let parentVisited = false;

	return Object.keys(unresolved).filter((module) => {
		if (module === parent) {
			parentVisited = true;
		}
		return parentVisited && unresolved[module];
	});
}
251894
def _path(self, attrpath):
        """"""

        attr, _, subpath = attrpath.partition(".")
        if attr not in self.__dict__:
            self.__dict__[attr] = Namespace()
            self.__namespaces.add(attr)

        if subpath:
            return self.__dict__[attr]._path(subpath)
        else:
            return self.__dict__[attr]
255317
def get_fpath(self, cachedir=None, cfgstr=None, ext=None):
        
        _dpath = self.get_cachedir(cachedir)
        _fname = self.get_prefix()
        _cfgstr = self.get_cfgstr() if cfgstr is None else cfgstr
        _ext =   self.ext if ext is None else ext
        fpath = _args2_fpath(_dpath, _fname, _cfgstr, _ext)
        return fpath
1048322
function getBinPath(packageInstallFolder, binName) {
    const binFolderPath = path.resolve(packageInstallFolder, NODE_MODULES_FOLDER_NAME, '.bin');
    const resolvedBinName = (os.platform() === 'win32') ? `${binName}.cmd` : binName;
    return path.resolve(binFolderPath, resolvedBinName);
}
168055
def _ClientPathToString(client_path, prefix=""):
  """"""
  return os.path.join(prefix, client_path.client_id, client_path.vfs_path)
1164949
def showpath(path):
    """"""
    if logger.verbose:
        return os.path.abspath(path)
    else:
        path = os.path.relpath(path)
        if path.startswith(os.curdir + os.sep):
            path = path[len(os.curdir + os.sep):]
        return path
808308
def _getpath(self, path):
        ""
        if is_blacklisted(path):
            raise JottaFuseError('Blacklisted file, refusing to retrieve it')

        return self.client.getObject(path)
367237
def path(self):
        """"""

        if self.parent:
            try:
                parent_path = self.parent.path.encode()
            except AttributeError:
                parent_path = self.parent.path
            return os.path.join(parent_path, self.name)
        return b"/"
732683
public String getAsPath() {
    // String.replaceAll() - cannot be used because of it uses a regex as a
    // parameter and a '.'(dot) means a any symbol.
    StringBuffer str = new StringBuffer();
    for (int i = 0; i < folderId.length(); i++)
      if (folderId.charAt(i) == '.')
        str.append('/');
      else
        str.append(folderId.charAt(i));
    return str.toString();
  }