Python tools.get_sep函数代码示例

def _joinpath(path):
    # convert our tuple representation back into a string representing a path
    if path is None:
        return ''
    elif len(path) == 0:
        return ''
    elif path == ('',):
        return get_sep()
    elif path[0] == '':
        return get_sep() + _normpath(os.path.join(*path))
    else:
        return _normpath(os.path.join(*path))

def _quote_paths(paths, start, end):
    expand_path = builtins.__xonsh_expand_path__
    out = set()
    space = ' '
    backslash = '\\'
    double_backslash = '\\\\'
    slash = xt.get_sep()
    orig_start = start
    orig_end = end
    for s in paths:
        start = orig_start
        end = orig_end
        if (start == '' and
                (re.search(PATTERN_NEED_QUOTES, s) is not None or
                 (backslash in s and slash != backslash))):
            start = end = _quote_to_use(s)
        if os.path.isdir(expand_path(s)):
            _tail = slash
        elif end == '':
            _tail = space
        else:
            _tail = ''
        if start != '' and 'r' not in start and backslash in s:
            start = 'r%s' % start
        s = s + _tail
        if end != '':
            if "r" not in start.lower():
                s = s.replace(backslash, double_backslash)
            if s.endswith(backslash) and not s.endswith(double_backslash):
                s += backslash
        if end in s:
            s = s.replace(end, ''.join('\\%s' % i for i in end))
        out.add(start + s + end)
    return out

 def _quote_paths(self, paths, start, end):
     out = set()
     space = ' '
     backslash = '\\'
     double_backslash = '\\\\'
     slash = get_sep()
     orig_start = start
     orig_end = end
     for s in paths:
         start = orig_start
         end = orig_end
         if (start == '' and
                 (any(i in s for i in CHARACTERS_NEED_QUOTES) or
                  (backslash in s and slash != backslash))):
             start = end = self._quote_to_use(s)
         if os.path.isdir(expand_path(s)):
             _tail = slash
         elif end == '':
             _tail = space
         else:
             _tail = ''
         s = s + _tail
         if end != '':
             if "r" not in start.lower():
                 s = s.replace(backslash, double_backslash)
             elif s.endswith(backslash):
                 s += backslash
         if end in s:
             s = s.replace(end, ''.join('\\%s' % i for i in end))
         out.add(start + s + end)
     return out

def _quote_paths(paths, start, end):
    expand_path = builtins.__xonsh_expand_path__
    out = set()
    space = " "
    backslash = "\\"
    double_backslash = "\\\\"
    slash = get_sep()
    orig_start = start
    orig_end = end
    for s in paths:
        start = orig_start
        end = orig_end
        if start == "" and (any(i in s for i in CHARACTERS_NEED_QUOTES) or (backslash in s and slash != backslash)):
            start = end = _quote_to_use(s)
        if os.path.isdir(expand_path(s)):
            _tail = slash
        elif end == "":
            _tail = space
        else:
            _tail = ""
        if start != "" and "r" not in start and backslash in s:
            start = "r%s" % start
        s = s + _tail
        if end != "":
            if "r" not in start.lower():
                s = s.replace(backslash, double_backslash)
            if s.endswith(backslash) and not s.endswith(double_backslash):
                s += backslash
        if end in s:
            s = s.replace(end, "".join("\\%s" % i for i in end))
        out.add(start + s + end)
    return out

def _collapsed_pwd():
    sep = get_sep()
    pwd = _replace_home_cwd().split(sep)
    l = len(pwd)
    leader = sep if l>0 and len(pwd[0])==0 else ''
    base = [i[0] if ix != l-1 else i for ix,i in enumerate(pwd) if len(i) > 0]
    return leader + sep.join(base)

 def _quote_paths(self, paths, start, end):
     out = set()
     space = ' '
     backslash = '\\'
     double_backslash = '\\\\'
     slash = get_sep()
     for s in paths:
         if (start == '' and
                 (space in s or (backslash in s and slash != backslash))):
             start = "'"
             end = "'"
         if os.path.isdir(expand_path(s)):
             _tail = slash
         elif end == '':
             _tail = space
         else:
             _tail = ''
         s = s + _tail
         if end != '':
             if "r" not in start.lower():
                 s = s.replace(backslash, double_backslash)
             elif s.endswith(backslash):
                 s += backslash
         out.add(start + s + end)
     return out

def _change_working_directory(newdir, follow_symlinks=False):
    env = builtins.__xonsh_env__
    old = env['PWD']
    new = os.path.join(old, newdir)
    absnew = os.path.abspath(new)

    if follow_symlinks:
        absnew = os.path.realpath(absnew)

    try:
        os.chdir(absnew)
    except (OSError, FileNotFoundError):
        if new.endswith(get_sep()):
            new = new[:-1]
        if os.path.basename(new) == '..':
            env['PWD'] = new
    else:
        if old is not None:
            env['OLDPWD'] = old
        if new is not None:
            env['PWD'] = absnew

    # Fire event if the path actually changed
    if old != env['PWD']:
        events.on_chdir.fire(olddir=old, newdir=env['PWD'])

def _splitpath_helper(path, sofar=()):
    folder, path = os.path.split(path)
    if path:
        sofar = sofar + (path, )
    if (not folder or folder == xt.get_sep() or
       (xp.ON_WINDOWS and os.path.splitdrive(path)[0])):
        return sofar[::-1]
    return _splitpath_helper(folder, sofar)

def _splitpath(path):
    # convert a path into an intermediate tuple representation
    # if this tuple starts with '', it means that the path was an absolute path
    path = _normpath(path)
    if path.startswith(get_sep()):
        pre = ('', )
    else:
        pre = ()
    return pre + _splitpath_helper(path, ())

def _dots(prefix):
    slash = xt.get_sep()
    if slash == "\\":
        slash = ""
    if prefix in {"", "."}:
        return ("." + slash, ".." + slash)
    elif prefix == "..":
        return (".." + slash,)
    else:
        return ()

def _dots(prefix):
    slash = get_sep()
    if slash == '\\':
        slash = ''
    if prefix in {'', '.'}:
        return ('.'+slash, '..'+slash)
    elif prefix == '..':
        return ('..'+slash,)
    else:
        return ()

def completionwrap(s):
    """ Returns the repr of input string s if that string contains 
    a 'problem' token that will confuse the xonsh parser
    """
    space = ' '
    slash = get_sep()
    return (_normpath(repr(s + (slash if os.path.isdir(s) else '')))
           if COMPLETION_WRAP_TOKENS.intersection(s) else
           s + space
           if s[-1:].isalnum() else
           s) 

def _splitpath_helper(path, sofar=()):
    folder, path = os.path.split(path)
    if path:
        sofar = sofar + (path, )
    if not folder or folder == xt.get_sep():
        return sofar[::-1]
    elif xp.ON_WINDOWS and not path:
        return os.path.splitdrive(folder)[:1] + sofar[::-1]
    elif xp.ON_WINDOWS and os.path.splitdrive(path)[0]:
        return sofar[::-1]
    return _splitpath_helper(folder, sofar)

def _change_working_directory(newdir):
    env = builtins.__xonsh_env__
    old = env['PWD']
    new = os.path.join(old, newdir)
    try:
        os.chdir(os.path.abspath(new))
    except (OSError, FileNotFoundError):
        if new.endswith(get_sep()):
            new = new[:-1]
        if os.path.basename(new) == '..':
            env['PWD'] = new
        return
    if old is not None:
        env['OLDPWD'] = old
    if new is not None:
        env['PWD'] = os.path.abspath(new)

def _dynamically_collapsed_pwd():
    """Return the compact current working directory.  It respects the
    environment variable DYNAMIC_CWD_WIDTH.
    """
    original_path = _replace_home_cwd()
    target_width, units = builtins.__xonsh__.env["DYNAMIC_CWD_WIDTH"]
    elision_char = builtins.__xonsh__.env["DYNAMIC_CWD_ELISION_CHAR"]
    if target_width == float("inf"):
        return original_path
    if units == "%":
        cols, _ = shutil.get_terminal_size()
        target_width = (cols * target_width) // 100
    sep = xt.get_sep()
    pwd = original_path.split(sep)
    last = pwd.pop()
    remaining_space = target_width - len(last)
    # Reserve space for separators
    remaining_space_for_text = remaining_space - len(pwd)
    parts = []
    for i in range(len(pwd)):
        part = pwd[i]
        part_len = int(
            min(len(part), max(1, remaining_space_for_text // (len(pwd) - i)))
        )
        remaining_space_for_text -= part_len
        if len(part) > part_len:
            reduced_part = part[0 : part_len - len(elision_char)] + elision_char
            parts.append(reduced_part)
        else:
            parts.append(part)
    parts.append(last)
    full = sep.join(parts)
    truncature_char = elision_char if elision_char else "..."
    # If even if displaying one letter per dir we are too long
    if len(full) > target_width:
        # We truncate the left most part
        full = truncature_char + full[int(-target_width) + len(truncature_char) :]
        # if there is not even a single separator we still
        # want to display at least the beginning of the directory
        if full.find(sep) == -1:
            full = (truncature_char + sep + last)[
                0 : int(target_width) - len(truncature_char)
            ] + truncature_char
    return full