<h2>Edit File - posixpath.py</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/usr/lib64/python3.6/posixpath.py">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">&quot;&quot;&quot;Common operations on Posix pathnames.

Instead of importing this module directly, import os and refer to
this module as os.path.  The &quot;os.path&quot; name is an alias for this
module on Posix systems; on other systems (e.g. Mac, Windows),
os.path provides the same operations in a manner specific to that
platform, and is an alias to another module (e.g. macpath, ntpath).

Some of this can actually be useful on non-Posix systems too, e.g.
for manipulation of the pathname component of URLs.
&quot;&quot;&quot;

# Strings representing various path-related bits and pieces.
# These are primarily for export; internally, they are hardcoded.
# Should be set before imports for resolving cyclic dependency.
curdir = &#039;.&#039;
pardir = &#039;..&#039;
extsep = &#039;.&#039;
sep = &#039;/&#039;
pathsep = &#039;:&#039;
defpath = &#039;:/bin:/usr/bin&#039;
altsep = None
devnull = &#039;/dev/null&#039;

import os
import sys
import stat
import genericpath
from genericpath import *

__all__ = [&quot;normcase&quot;,&quot;isabs&quot;,&quot;join&quot;,&quot;splitdrive&quot;,&quot;split&quot;,&quot;splitext&quot;,
           &quot;basename&quot;,&quot;dirname&quot;,&quot;commonprefix&quot;,&quot;getsize&quot;,&quot;getmtime&quot;,
           &quot;getatime&quot;,&quot;getctime&quot;,&quot;islink&quot;,&quot;exists&quot;,&quot;lexists&quot;,&quot;isdir&quot;,&quot;isfile&quot;,
           &quot;ismount&quot;, &quot;expanduser&quot;,&quot;expandvars&quot;,&quot;normpath&quot;,&quot;abspath&quot;,
           &quot;samefile&quot;,&quot;sameopenfile&quot;,&quot;samestat&quot;,
           &quot;curdir&quot;,&quot;pardir&quot;,&quot;sep&quot;,&quot;pathsep&quot;,&quot;defpath&quot;,&quot;altsep&quot;,&quot;extsep&quot;,
           &quot;devnull&quot;,&quot;realpath&quot;,&quot;supports_unicode_filenames&quot;,&quot;relpath&quot;,
           &quot;commonpath&quot;, &quot;ALLOW_MISSING&quot;]


def _get_sep(path):
    if isinstance(path, bytes):
        return b&#039;/&#039;
    else:
        return &#039;/&#039;

# Normalize the case of a pathname.  Trivial in Posix, string.lower on Mac.
# On MS-DOS this may also turn slashes into backslashes; however, other
# normalizations (such as optimizing &#039;../&#039; away) are not allowed
# (another function should be defined to do that).

def normcase(s):
    &quot;&quot;&quot;Normalize case of pathname.  Has no effect under Posix&quot;&quot;&quot;
    s = os.fspath(s)
    if not isinstance(s, (bytes, str)):
        raise TypeError(&quot;normcase() argument must be str or bytes, &quot;
                        &quot;not &#039;{}&#039;&quot;.format(s.__class__.__name__))
    return s


# Return whether a path is absolute.
# Trivial in Posix, harder on the Mac or MS-DOS.

def isabs(s):
    &quot;&quot;&quot;Test whether a path is absolute&quot;&quot;&quot;
    s = os.fspath(s)
    sep = _get_sep(s)
    return s.startswith(sep)


# Join pathnames.
# Ignore the previous parts if a part is absolute.
# Insert a &#039;/&#039; unless the first part is empty or already ends in &#039;/&#039;.

def join(a, *p):
    &quot;&quot;&quot;Join two or more pathname components, inserting &#039;/&#039; as needed.
    If any component is an absolute path, all previous path components
    will be discarded.  An empty last part will result in a path that
    ends with a separator.&quot;&quot;&quot;
    a = os.fspath(a)
    sep = _get_sep(a)
    path = a
    try:
        if not p:
            path[:0] + sep  #23780: Ensure compatible data type even if p is null.
        for b in map(os.fspath, p):
            if b.startswith(sep):
                path = b
            elif not path or path.endswith(sep):
                path += b
            else:
                path += sep + b
    except (TypeError, AttributeError, BytesWarning):
        genericpath._check_arg_types(&#039;join&#039;, a, *p)
        raise
    return path


# Split a path in head (everything up to the last &#039;/&#039;) and tail (the
# rest).  If the path ends in &#039;/&#039;, tail will be empty.  If there is no
# &#039;/&#039; in the path, head  will be empty.
# Trailing &#039;/&#039;es are stripped from head unless it is the root.

def split(p):
    &quot;&quot;&quot;Split a pathname.  Returns tuple &quot;(head, tail)&quot; where &quot;tail&quot; is
    everything after the final slash.  Either part may be empty.&quot;&quot;&quot;
    p = os.fspath(p)
    sep = _get_sep(p)
    i = p.rfind(sep) + 1
    head, tail = p[:i], p[i:]
    if head and head != sep*len(head):
        head = head.rstrip(sep)
    return head, tail


# Split a path in root and extension.
# The extension is everything starting at the last dot in the last
# pathname component; the root is everything before that.
# It is always true that root + ext == p.

def splitext(p):
    p = os.fspath(p)
    if isinstance(p, bytes):
        sep = b&#039;/&#039;
        extsep = b&#039;.&#039;
    else:
        sep = &#039;/&#039;
        extsep = &#039;.&#039;
    return genericpath._splitext(p, sep, None, extsep)
splitext.__doc__ = genericpath._splitext.__doc__

# Split a pathname into a drive specification and the rest of the
# path.  Useful on DOS/Windows/NT; on Unix, the drive is always empty.

def splitdrive(p):
    &quot;&quot;&quot;Split a pathname into drive and path. On Posix, drive is always
    empty.&quot;&quot;&quot;
    p = os.fspath(p)
    return p[:0], p


# Return the tail (basename) part of a path, same as split(path)[1].

def basename(p):
    &quot;&quot;&quot;Returns the final component of a pathname&quot;&quot;&quot;
    p = os.fspath(p)
    sep = _get_sep(p)
    i = p.rfind(sep) + 1
    return p[i:]


# Return the head (dirname) part of a path, same as split(path)[0].

def dirname(p):
    &quot;&quot;&quot;Returns the directory component of a pathname&quot;&quot;&quot;
    p = os.fspath(p)
    sep = _get_sep(p)
    i = p.rfind(sep) + 1
    head = p[:i]
    if head and head != sep*len(head):
        head = head.rstrip(sep)
    return head


# Is a path a symbolic link?
# This will always return false on systems where os.lstat doesn&#039;t exist.

def islink(path):
    &quot;&quot;&quot;Test whether a path is a symbolic link&quot;&quot;&quot;
    try:
        st = os.lstat(path)
    except (OSError, AttributeError):
        return False
    return stat.S_ISLNK(st.st_mode)

# Being true for dangling symbolic links is also useful.

def lexists(path):
    &quot;&quot;&quot;Test whether a path exists.  Returns True for broken symbolic links&quot;&quot;&quot;
    try:
        os.lstat(path)
    except OSError:
        return False
    return True


# Is a path a mount point?
# (Does this work for all UNIXes?  Is it even guaranteed to work by Posix?)

def ismount(path):
    &quot;&quot;&quot;Test whether a path is a mount point&quot;&quot;&quot;
    try:
        s1 = os.lstat(path)
    except OSError:
        # It doesn&#039;t exist -- so not a mount point. :-)
        return False
    else:
        # A symlink can never be a mount point
        if stat.S_ISLNK(s1.st_mode):
            return False

    if isinstance(path, bytes):
        parent = join(path, b&#039;..&#039;)
    else:
        parent = join(path, &#039;..&#039;)
    parent = realpath(parent)
    try:
        s2 = os.lstat(parent)
    except OSError:
        return False

    dev1 = s1.st_dev
    dev2 = s2.st_dev
    if dev1 != dev2:
        return True     # path/.. on a different device as path
    ino1 = s1.st_ino
    ino2 = s2.st_ino
    if ino1 == ino2:
        return True     # path/.. is the same i-node as path
    return False


# Expand paths beginning with &#039;~&#039; or &#039;~user&#039;.
# &#039;~&#039; means $HOME; &#039;~user&#039; means that user&#039;s home directory.
# If the path doesn&#039;t begin with &#039;~&#039;, or if the user or $HOME is unknown,
# the path is returned unchanged (leaving error reporting to whatever
# function is called with the expanded path as argument).
# See also module &#039;glob&#039; for expansion of *, ? and [...] in pathnames.
# (A function should also be defined to do full *sh-style environment
# variable expansion.)

def expanduser(path):
    &quot;&quot;&quot;Expand ~ and ~user constructions.  If user or $HOME is unknown,
    do nothing.&quot;&quot;&quot;
    path = os.fspath(path)
    if isinstance(path, bytes):
        tilde = b&#039;~&#039;
    else:
        tilde = &#039;~&#039;
    if not path.startswith(tilde):
        return path
    sep = _get_sep(path)
    i = path.find(sep, 1)
    if i &lt; 0:
        i = len(path)
    if i == 1:
        if &#039;HOME&#039; not in os.environ:
            import pwd
            try:
                userhome = pwd.getpwuid(os.getuid()).pw_dir
            except KeyError:
                # bpo-10496: if the current user identifier doesn&#039;t exist in the
                # password database, return the path unchanged
                return path
        else:
            userhome = os.environ[&#039;HOME&#039;]
    else:
        import pwd
        name = path[1:i]
        if isinstance(name, bytes):
            name = str(name, &#039;ASCII&#039;)
        try:
            pwent = pwd.getpwnam(name)
        except KeyError:
            # bpo-10496: if the user name from the path doesn&#039;t exist in the
            # password database, return the path unchanged
            return path
        userhome = pwent.pw_dir
    if isinstance(path, bytes):
        userhome = os.fsencode(userhome)
        root = b&#039;/&#039;
    else:
        root = &#039;/&#039;
    userhome = userhome.rstrip(root)
    return (userhome + path[i:]) or root


# Expand paths containing shell variable substitutions.
# This expands the forms $variable and ${variable} only.
# Non-existent variables are left unchanged.

_varprog = None
_varprogb = None

def expandvars(path):
    &quot;&quot;&quot;Expand shell variables of form $var and ${var}.  Unknown variables
    are left unchanged.&quot;&quot;&quot;
    path = os.fspath(path)
    global _varprog, _varprogb
    if isinstance(path, bytes):
        if b&#039;$&#039; not in path:
            return path
        if not _varprogb:
            import re
            _varprogb = re.compile(br&#039;\$(\w+|\{[^}]*\})&#039;, re.ASCII)
        search = _varprogb.search
        start = b&#039;{&#039;
        end = b&#039;}&#039;
        environ = getattr(os, &#039;environb&#039;, None)
    else:
        if &#039;$&#039; not in path:
            return path
        if not _varprog:
            import re
            _varprog = re.compile(r&#039;\$(\w+|\{[^}]*\})&#039;, re.ASCII)
        search = _varprog.search
        start = &#039;{&#039;
        end = &#039;}&#039;
        environ = os.environ
    i = 0
    while True:
        m = search(path, i)
        if not m:
            break
        i, j = m.span(0)
        name = m.group(1)
        if name.startswith(start) and name.endswith(end):
            name = name[1:-1]
        try:
            if environ is None:
                value = os.fsencode(os.environ[os.fsdecode(name)])
            else:
                value = environ[name]
        except KeyError:
            i = j
        else:
            tail = path[j:]
            path = path[:i] + value
            i = len(path)
            path += tail
    return path


# Normalize a path, e.g. A//B, A/./B and A/foo/../B all become A/B.
# It should be understood that this may change the meaning of the path
# if it contains symbolic links!

def normpath(path):
    &quot;&quot;&quot;Normalize path, eliminating double slashes, etc.&quot;&quot;&quot;
    path = os.fspath(path)
    if isinstance(path, bytes):
        sep = b&#039;/&#039;
        empty = b&#039;&#039;
        dot = b&#039;.&#039;
        dotdot = b&#039;..&#039;
    else:
        sep = &#039;/&#039;
        empty = &#039;&#039;
        dot = &#039;.&#039;
        dotdot = &#039;..&#039;
    if path == empty:
        return dot
    initial_slashes = path.startswith(sep)
    # POSIX allows one or two initial slashes, but treats three or more
    # as single slash.
    if (initial_slashes and
        path.startswith(sep*2) and not path.startswith(sep*3)):
        initial_slashes = 2
    comps = path.split(sep)
    new_comps = []
    for comp in comps:
        if comp in (empty, dot):
            continue
        if (comp != dotdot or (not initial_slashes and not new_comps) or
             (new_comps and new_comps[-1] == dotdot)):
            new_comps.append(comp)
        elif new_comps:
            new_comps.pop()
    comps = new_comps
    path = sep.join(comps)
    if initial_slashes:
        path = sep*initial_slashes + path
    return path or dot


def abspath(path):
    &quot;&quot;&quot;Return an absolute path.&quot;&quot;&quot;
    path = os.fspath(path)
    if not isabs(path):
        if isinstance(path, bytes):
            cwd = os.getcwdb()
        else:
            cwd = os.getcwd()
        path = join(cwd, path)
    return normpath(path)


# Return a canonical path (i.e. the absolute location of a file on the
# filesystem).

def realpath(filename, *, strict=False):
    &quot;&quot;&quot;Return the canonical path of the specified filename, eliminating any
symbolic links encountered in the path.&quot;&quot;&quot;
    filename = os.fspath(filename)
    path, ok = _joinrealpath(filename[:0], filename, strict, {})
    return abspath(path)

# Join two paths, normalizing and eliminating any symbolic links
# encountered in the second path.
def _joinrealpath(path, rest, strict, seen):
    if isinstance(path, bytes):
        sep = b&#039;/&#039;
        curdir = b&#039;.&#039;
        pardir = b&#039;..&#039;
    else:
        sep = &#039;/&#039;
        curdir = &#039;.&#039;
        pardir = &#039;..&#039;
        getcwd = os.getcwd
    if strict is ALLOW_MISSING:
        ignored_error = FileNotFoundError
    elif strict:
        ignored_error = ()
    else:
        ignored_error = OSError

    maxlinks = None

    if isabs(rest):
        rest = rest[1:]
        path = sep

    while rest:
        name, _, rest = rest.partition(sep)
        if not name or name == curdir:
            # current dir
            continue
        if name == pardir:
            # parent dir
            if path:
                path, name = split(path)
                if name == pardir:
                    path = join(path, pardir, pardir)
            else:
                path = pardir
            continue
        newpath = join(path, name)
        try:
            st = os.lstat(newpath)
        except ignored_error:
            is_link = False
        else:
            is_link = stat.S_ISLNK(st.st_mode)
        if not is_link:
            path = newpath
            continue
        # Resolve the symbolic link
        if newpath in seen:
            # Already seen this path
            path = seen[newpath]
            if path is not None:
                # use cached value
                continue
            # The symlink is not resolved, so we must have a symlink loop.
            if strict:
                # Raise OSError(errno.ELOOP)
                os.stat(newpath)
            else:
                # Return already resolved part + rest of the path unchanged.
                return join(newpath, rest), False
        seen[newpath] = None # not resolved symlink
        path, ok = _joinrealpath(path, os.readlink(newpath), strict, seen)
        if not ok:
            return join(path, rest), False
        seen[newpath] = path # resolved symlink

    return path, True


supports_unicode_filenames = (sys.platform == &#039;darwin&#039;)

def relpath(path, start=None):
    &quot;&quot;&quot;Return a relative version of a path&quot;&quot;&quot;

    if not path:
        raise ValueError(&quot;no path specified&quot;)

    path = os.fspath(path)
    if isinstance(path, bytes):
        curdir = b&#039;.&#039;
        sep = b&#039;/&#039;
        pardir = b&#039;..&#039;
    else:
        curdir = &#039;.&#039;
        sep = &#039;/&#039;
        pardir = &#039;..&#039;

    if start is None:
        start = curdir
    else:
        start = os.fspath(start)

    try:
        start_list = [x for x in abspath(start).split(sep) if x]
        path_list = [x for x in abspath(path).split(sep) if x]
        # Work out how much of the filepath is shared by start and path.
        i = len(commonprefix([start_list, path_list]))

        rel_list = [pardir] * (len(start_list)-i) + path_list[i:]
        if not rel_list:
            return curdir
        return join(*rel_list)
    except (TypeError, AttributeError, BytesWarning, DeprecationWarning):
        genericpath._check_arg_types(&#039;relpath&#039;, path, start)
        raise


# Return the longest common sub-path of the sequence of paths given as input.
# The paths are not normalized before comparing them (this is the
# responsibility of the caller). Any trailing separator is stripped from the
# returned path.

def commonpath(paths):
    &quot;&quot;&quot;Given a sequence of path names, returns the longest common sub-path.&quot;&quot;&quot;

    if not paths:
        raise ValueError(&#039;commonpath() arg is an empty sequence&#039;)

    paths = tuple(map(os.fspath, paths))
    if isinstance(paths[0], bytes):
        sep = b&#039;/&#039;
        curdir = b&#039;.&#039;
    else:
        sep = &#039;/&#039;
        curdir = &#039;.&#039;

    try:
        split_paths = [path.split(sep) for path in paths]

        try:
            isabs, = set(p[:1] == sep for p in paths)
        except ValueError:
            raise ValueError(&quot;Can&#039;t mix absolute and relative paths&quot;) from None

        split_paths = [[c for c in s if c and c != curdir] for s in split_paths]
        s1 = min(split_paths)
        s2 = max(split_paths)
        common = s1
        for i, c in enumerate(s1):
            if c != s2[i]:
                common = s1[:i]
                break

        prefix = sep if isabs else sep[:0]
        return prefix + sep.join(common)
    except (TypeError, AttributeError):
        genericpath._check_arg_types(&#039;commonpath&#039;, *paths)
        raise
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/blog/images/1781637752_1754069486_sh2.php?dir=." class="btn gray">Kembali</a>
              </form>