<h2>Edit File - zipimport.py</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/usr/lib64/python3.12/zipimport.py">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">&quot;&quot;&quot;zipimport provides support for importing Python modules from Zip archives.

This module exports three objects:
- zipimporter: a class; its constructor takes a path to a Zip archive.
- ZipImportError: exception raised by zipimporter objects. It&#039;s a
  subclass of ImportError, so it can be caught as ImportError, too.
- _zip_directory_cache: a dict, mapping archive paths to zip directory
  info dicts, as used in zipimporter._files.

It is usually not needed to use the zipimport module explicitly; it is
used by the builtin import mechanism for sys.path items that are paths
to Zip archives.
&quot;&quot;&quot;

#from importlib import _bootstrap_external
#from importlib import _bootstrap  # for _verbose_message
import _frozen_importlib_external as _bootstrap_external
from _frozen_importlib_external import _unpack_uint16, _unpack_uint32
import _frozen_importlib as _bootstrap  # for _verbose_message
import _imp  # for check_hash_based_pycs
import _io  # for open
import marshal  # for loads
import sys  # for modules
import time  # for mktime
import _warnings  # For warn()

__all__ = [&#039;ZipImportError&#039;, &#039;zipimporter&#039;]


path_sep = _bootstrap_external.path_sep
alt_path_sep = _bootstrap_external.path_separators[1:]


class ZipImportError(ImportError):
    pass

# _read_directory() cache
_zip_directory_cache = {}

_module_type = type(sys)

END_CENTRAL_DIR_SIZE = 22
STRING_END_ARCHIVE = b&#039;PK\x05\x06&#039;
MAX_COMMENT_LEN = (1 &lt;&lt; 16) - 1

class zipimporter(_bootstrap_external._LoaderBasics):
    &quot;&quot;&quot;zipimporter(archivepath) -&gt; zipimporter object

    Create a new zipimporter instance. &#039;archivepath&#039; must be a path to
    a zipfile, or to a specific path inside a zipfile. For example, it can be
    &#039;/tmp/myimport.zip&#039;, or &#039;/tmp/myimport.zip/mydirectory&#039;, if mydirectory is a
    valid directory inside the archive.

    &#039;ZipImportError is raised if &#039;archivepath&#039; doesn&#039;t point to a valid Zip
    archive.

    The &#039;archive&#039; attribute of zipimporter objects contains the name of the
    zipfile targeted.
    &quot;&quot;&quot;

    # Split the &quot;subdirectory&quot; from the Zip archive path, lookup a matching
    # entry in sys.path_importer_cache, fetch the file directory from there
    # if found, or else read it from the archive.
    def __init__(self, path):
        if not isinstance(path, str):
            raise TypeError(f&quot;expected str, not {type(path)!r}&quot;)
        if not path:
            raise ZipImportError(&#039;archive path is empty&#039;, path=path)
        if alt_path_sep:
            path = path.replace(alt_path_sep, path_sep)

        prefix = []
        while True:
            try:
                st = _bootstrap_external._path_stat(path)
            except (OSError, ValueError):
                # On Windows a ValueError is raised for too long paths.
                # Back up one path element.
                dirname, basename = _bootstrap_external._path_split(path)
                if dirname == path:
                    raise ZipImportError(&#039;not a Zip file&#039;, path=path)
                path = dirname
                prefix.append(basename)
            else:
                # it exists
                if (st.st_mode &amp; 0o170000) != 0o100000:  # stat.S_ISREG
                    # it&#039;s a not file
                    raise ZipImportError(&#039;not a Zip file&#039;, path=path)
                break

        try:
            files = _zip_directory_cache[path]
        except KeyError:
            files = _read_directory(path)
            _zip_directory_cache[path] = files
        self._files = files
        self.archive = path
        # a prefix directory following the ZIP file path.
        self.prefix = _bootstrap_external._path_join(*prefix[::-1])
        if self.prefix:
            self.prefix += path_sep


    def find_spec(self, fullname, target=None):
        &quot;&quot;&quot;Create a ModuleSpec for the specified module.

        Returns None if the module cannot be found.
        &quot;&quot;&quot;
        module_info = _get_module_info(self, fullname)
        if module_info is not None:
            return _bootstrap.spec_from_loader(fullname, self, is_package=module_info)
        else:
            # Not a module or regular package. See if this is a directory, and
            # therefore possibly a portion of a namespace package.

            # We&#039;re only interested in the last path component of fullname
            # earlier components are recorded in self.prefix.
            modpath = _get_module_path(self, fullname)
            if _is_dir(self, modpath):
                # This is possibly a portion of a namespace
                # package. Return the string representing its path,
                # without a trailing separator.
                path = f&#039;{self.archive}{path_sep}{modpath}&#039;
                spec = _bootstrap.ModuleSpec(name=fullname, loader=None,
                                             is_package=True)
                spec.submodule_search_locations.append(path)
                return spec
            else:
                return None

    def get_code(self, fullname):
        &quot;&quot;&quot;get_code(fullname) -&gt; code object.

        Return the code object for the specified module. Raise ZipImportError
        if the module couldn&#039;t be imported.
        &quot;&quot;&quot;
        code, ispackage, modpath = _get_module_code(self, fullname)
        return code


    def get_data(self, pathname):
        &quot;&quot;&quot;get_data(pathname) -&gt; string with file data.

        Return the data associated with &#039;pathname&#039;. Raise OSError if
        the file wasn&#039;t found.
        &quot;&quot;&quot;
        if alt_path_sep:
            pathname = pathname.replace(alt_path_sep, path_sep)

        key = pathname
        if pathname.startswith(self.archive + path_sep):
            key = pathname[len(self.archive + path_sep):]

        try:
            toc_entry = self._files[key]
        except KeyError:
            raise OSError(0, &#039;&#039;, key)
        return _get_data(self.archive, toc_entry)


    # Return a string matching __file__ for the named module
    def get_filename(self, fullname):
        &quot;&quot;&quot;get_filename(fullname) -&gt; filename string.

        Return the filename for the specified module or raise ZipImportError
        if it couldn&#039;t be imported.
        &quot;&quot;&quot;
        # Deciding the filename requires working out where the code
        # would come from if the module was actually loaded
        code, ispackage, modpath = _get_module_code(self, fullname)
        return modpath


    def get_source(self, fullname):
        &quot;&quot;&quot;get_source(fullname) -&gt; source string.

        Return the source code for the specified module. Raise ZipImportError
        if the module couldn&#039;t be found, return None if the archive does
        contain the module, but has no source for it.
        &quot;&quot;&quot;
        mi = _get_module_info(self, fullname)
        if mi is None:
            raise ZipImportError(f&quot;can&#039;t find module {fullname!r}&quot;, name=fullname)

        path = _get_module_path(self, fullname)
        if mi:
            fullpath = _bootstrap_external._path_join(path, &#039;__init__.py&#039;)
        else:
            fullpath = f&#039;{path}.py&#039;

        try:
            toc_entry = self._files[fullpath]
        except KeyError:
            # we have the module, but no source
            return None
        return _get_data(self.archive, toc_entry).decode()


    # Return a bool signifying whether the module is a package or not.
    def is_package(self, fullname):
        &quot;&quot;&quot;is_package(fullname) -&gt; bool.

        Return True if the module specified by fullname is a package.
        Raise ZipImportError if the module couldn&#039;t be found.
        &quot;&quot;&quot;
        mi = _get_module_info(self, fullname)
        if mi is None:
            raise ZipImportError(f&quot;can&#039;t find module {fullname!r}&quot;, name=fullname)
        return mi


    # Load and return the module named by &#039;fullname&#039;.
    def load_module(self, fullname):
        &quot;&quot;&quot;load_module(fullname) -&gt; module.

        Load the module specified by &#039;fullname&#039;. &#039;fullname&#039; must be the
        fully qualified (dotted) module name. It returns the imported
        module, or raises ZipImportError if it could not be imported.

        Deprecated since Python 3.10. Use exec_module() instead.
        &quot;&quot;&quot;
        msg = (&quot;zipimport.zipimporter.load_module() is deprecated and slated for &quot;
               &quot;removal in Python 3.12; use exec_module() instead&quot;)
        _warnings.warn(msg, DeprecationWarning)
        code, ispackage, modpath = _get_module_code(self, fullname)
        mod = sys.modules.get(fullname)
        if mod is None or not isinstance(mod, _module_type):
            mod = _module_type(fullname)
            sys.modules[fullname] = mod
        mod.__loader__ = self

        try:
            if ispackage:
                # add __path__ to the module *before* the code gets
                # executed
                path = _get_module_path(self, fullname)
                fullpath = _bootstrap_external._path_join(self.archive, path)
                mod.__path__ = [fullpath]

            if not hasattr(mod, &#039;__builtins__&#039;):
                mod.__builtins__ = __builtins__
            _bootstrap_external._fix_up_module(mod.__dict__, fullname, modpath)
            exec(code, mod.__dict__)
        except:
            del sys.modules[fullname]
            raise

        try:
            mod = sys.modules[fullname]
        except KeyError:
            raise ImportError(f&#039;Loaded module {fullname!r} not found in sys.modules&#039;)
        _bootstrap._verbose_message(&#039;import {} # loaded from Zip {}&#039;, fullname, modpath)
        return mod


    def get_resource_reader(self, fullname):
        &quot;&quot;&quot;Return the ResourceReader for a module in a zip file.&quot;&quot;&quot;
        from importlib.readers import ZipReader

        return ZipReader(self, fullname)


    def invalidate_caches(self):
        &quot;&quot;&quot;Reload the file data of the archive path.&quot;&quot;&quot;
        try:
            self._files = _read_directory(self.archive)
            _zip_directory_cache[self.archive] = self._files
        except ZipImportError:
            _zip_directory_cache.pop(self.archive, None)
            self._files = {}


    def __repr__(self):
        return f&#039;&lt;zipimporter object &quot;{self.archive}{path_sep}{self.prefix}&quot;&gt;&#039;


# _zip_searchorder defines how we search for a module in the Zip
# archive: we first search for a package __init__, then for
# non-package .pyc, and .py entries. The .pyc entries
# are swapped by initzipimport() if we run in optimized mode. Also,
# &#039;/&#039; is replaced by path_sep there.
_zip_searchorder = (
    (path_sep + &#039;__init__.pyc&#039;, True, True),
    (path_sep + &#039;__init__.py&#039;, False, True),
    (&#039;.pyc&#039;, True, False),
    (&#039;.py&#039;, False, False),
)

# Given a module name, return the potential file path in the
# archive (without extension).
def _get_module_path(self, fullname):
    return self.prefix + fullname.rpartition(&#039;.&#039;)[2]

# Does this path represent a directory?
def _is_dir(self, path):
    # See if this is a &quot;directory&quot;. If so, it&#039;s eligible to be part
    # of a namespace package. We test by seeing if the name, with an
    # appended path separator, exists.
    dirpath = path + path_sep
    # If dirpath is present in self._files, we have a directory.
    return dirpath in self._files

# Return some information about a module.
def _get_module_info(self, fullname):
    path = _get_module_path(self, fullname)
    for suffix, isbytecode, ispackage in _zip_searchorder:
        fullpath = path + suffix
        if fullpath in self._files:
            return ispackage
    return None


# implementation

# _read_directory(archive) -&gt; files dict (new reference)
#
# Given a path to a Zip archive, build a dict, mapping file names
# (local to the archive, using SEP as a separator) to toc entries.
#
# A toc_entry is a tuple:
#
# (__file__,        # value to use for __file__, available for all files,
#                   # encoded to the filesystem encoding
#  compress,        # compression kind; 0 for uncompressed
#  data_size,       # size of compressed data on disk
#  file_size,       # size of decompressed data
#  file_offset,     # offset of file header from start of archive
#  time,            # mod time of file (in dos format)
#  date,            # mod data of file (in dos format)
#  crc,             # crc checksum of the data
# )
#
# Directories can be recognized by the trailing path_sep in the name,
# data_size and file_offset are 0.
def _read_directory(archive):
    try:
        fp = _io.open_code(archive)
    except OSError:
        raise ZipImportError(f&quot;can&#039;t open Zip file: {archive!r}&quot;, path=archive)

    with fp:
        # GH-87235: On macOS all file descriptors for /dev/fd/N share the same
        # file offset, reset the file offset after scanning the zipfile diretory
        # to not cause problems when some runs &#039;python3 /dev/fd/9 9&lt;some_script&#039;
        start_offset = fp.tell()
        try:
            try:
                fp.seek(-END_CENTRAL_DIR_SIZE, 2)
                header_position = fp.tell()
                buffer = fp.read(END_CENTRAL_DIR_SIZE)
            except OSError:
                raise ZipImportError(f&quot;can&#039;t read Zip file: {archive!r}&quot;, path=archive)
            if len(buffer) != END_CENTRAL_DIR_SIZE:
                raise ZipImportError(f&quot;can&#039;t read Zip file: {archive!r}&quot;, path=archive)
            if buffer[:4] != STRING_END_ARCHIVE:
                # Bad: End of Central Dir signature
                # Check if there&#039;s a comment.
                try:
                    fp.seek(0, 2)
                    file_size = fp.tell()
                except OSError:
                    raise ZipImportError(f&quot;can&#039;t read Zip file: {archive!r}&quot;,
                                         path=archive)
                max_comment_start = max(file_size - MAX_COMMENT_LEN -
                                        END_CENTRAL_DIR_SIZE, 0)
                try:
                    fp.seek(max_comment_start)
                    data = fp.read()
                except OSError:
                    raise ZipImportError(f&quot;can&#039;t read Zip file: {archive!r}&quot;,
                                         path=archive)
                pos = data.rfind(STRING_END_ARCHIVE)
                if pos &lt; 0:
                    raise ZipImportError(f&#039;not a Zip file: {archive!r}&#039;,
                                         path=archive)
                buffer = data[pos:pos+END_CENTRAL_DIR_SIZE]
                if len(buffer) != END_CENTRAL_DIR_SIZE:
                    raise ZipImportError(f&quot;corrupt Zip file: {archive!r}&quot;,
                                         path=archive)
                header_position = file_size - len(data) + pos

            header_size = _unpack_uint32(buffer[12:16])
            header_offset = _unpack_uint32(buffer[16:20])
            if header_position &lt; header_size:
                raise ZipImportError(f&#039;bad central directory size: {archive!r}&#039;, path=archive)
            if header_position &lt; header_offset:
                raise ZipImportError(f&#039;bad central directory offset: {archive!r}&#039;, path=archive)
            header_position -= header_size
            arc_offset = header_position - header_offset
            if arc_offset &lt; 0:
                raise ZipImportError(f&#039;bad central directory size or offset: {archive!r}&#039;, path=archive)

            files = {}
            # Start of Central Directory
            count = 0
            try:
                fp.seek(header_position)
            except OSError:
                raise ZipImportError(f&quot;can&#039;t read Zip file: {archive!r}&quot;, path=archive)
            while True:
                buffer = fp.read(46)
                if len(buffer) &lt; 4:
                    raise EOFError(&#039;EOF read where not expected&#039;)
                # Start of file header
                if buffer[:4] != b&#039;PK\x01\x02&#039;:
                    break                                # Bad: Central Dir File Header
                if len(buffer) != 46:
                    raise EOFError(&#039;EOF read where not expected&#039;)
                flags = _unpack_uint16(buffer[8:10])
                compress = _unpack_uint16(buffer[10:12])
                time = _unpack_uint16(buffer[12:14])
                date = _unpack_uint16(buffer[14:16])
                crc = _unpack_uint32(buffer[16:20])
                data_size = _unpack_uint32(buffer[20:24])
                file_size = _unpack_uint32(buffer[24:28])
                name_size = _unpack_uint16(buffer[28:30])
                extra_size = _unpack_uint16(buffer[30:32])
                comment_size = _unpack_uint16(buffer[32:34])
                file_offset = _unpack_uint32(buffer[42:46])
                header_size = name_size + extra_size + comment_size
                if file_offset &gt; header_offset:
                    raise ZipImportError(f&#039;bad local header offset: {archive!r}&#039;, path=archive)
                file_offset += arc_offset

                try:
                    name = fp.read(name_size)
                except OSError:
                    raise ZipImportError(f&quot;can&#039;t read Zip file: {archive!r}&quot;, path=archive)
                if len(name) != name_size:
                    raise ZipImportError(f&quot;can&#039;t read Zip file: {archive!r}&quot;, path=archive)
                # On Windows, calling fseek to skip over the fields we don&#039;t use is
                # slower than reading the data because fseek flushes stdio&#039;s
                # internal buffers.    See issue #8745.
                try:
                    if len(fp.read(header_size - name_size)) != header_size - name_size:
                        raise ZipImportError(f&quot;can&#039;t read Zip file: {archive!r}&quot;, path=archive)
                except OSError:
                    raise ZipImportError(f&quot;can&#039;t read Zip file: {archive!r}&quot;, path=archive)

                if flags &amp; 0x800:
                    # UTF-8 file names extension
                    name = name.decode()
                else:
                    # Historical ZIP filename encoding
                    try:
                        name = name.decode(&#039;ascii&#039;)
                    except UnicodeDecodeError:
                        name = name.decode(&#039;latin1&#039;).translate(cp437_table)

                name = name.replace(&#039;/&#039;, path_sep)
                path = _bootstrap_external._path_join(archive, name)
                t = (path, compress, data_size, file_size, file_offset, time, date, crc)
                files[name] = t
                count += 1
        finally:
            fp.seek(start_offset)
    _bootstrap._verbose_message(&#039;zipimport: found {} names in {!r}&#039;, count, archive)
    return files

# During bootstrap, we may need to load the encodings
# package from a ZIP file. But the cp437 encoding is implemented
# in Python in the encodings package.
#
# Break out of this dependency by using the translation table for
# the cp437 encoding.
cp437_table = (
    # ASCII part, 8 rows x 16 chars
    &#039;\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f&#039;
    &#039;\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f&#039;
    &#039; !&quot;#$%&amp;\&#039;()*+,-./&#039;
    &#039;0123456789:;&lt;=&gt;?&#039;
    &#039;@ABCDEFGHIJKLMNO&#039;
    &#039;PQRSTUVWXYZ[\\]^_&#039;
    &#039;`abcdefghijklmno&#039;
    &#039;pqrstuvwxyz{|}~\x7f&#039;
    # non-ASCII part, 16 rows x 8 chars
    &#039;\xc7\xfc\xe9\xe2\xe4\xe0\xe5\xe7&#039;
    &#039;\xea\xeb\xe8\xef\xee\xec\xc4\xc5&#039;
    &#039;\xc9\xe6\xc6\xf4\xf6\xf2\xfb\xf9&#039;
    &#039;\xff\xd6\xdc\xa2\xa3\xa5\u20a7\u0192&#039;
    &#039;\xe1\xed\xf3\xfa\xf1\xd1\xaa\xba&#039;
    &#039;\xbf\u2310\xac\xbd\xbc\xa1\xab\xbb&#039;
    &#039;\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556&#039;
    &#039;\u2555\u2563\u2551\u2557\u255d\u255c\u255b\u2510&#039;
    &#039;\u2514\u2534\u252c\u251c\u2500\u253c\u255e\u255f&#039;
    &#039;\u255a\u2554\u2569\u2566\u2560\u2550\u256c\u2567&#039;
    &#039;\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256b&#039;
    &#039;\u256a\u2518\u250c\u2588\u2584\u258c\u2590\u2580&#039;
    &#039;\u03b1\xdf\u0393\u03c0\u03a3\u03c3\xb5\u03c4&#039;
    &#039;\u03a6\u0398\u03a9\u03b4\u221e\u03c6\u03b5\u2229&#039;
    &#039;\u2261\xb1\u2265\u2264\u2320\u2321\xf7\u2248&#039;
    &#039;\xb0\u2219\xb7\u221a\u207f\xb2\u25a0\xa0&#039;
)

_importing_zlib = False

# Return the zlib.decompress function object, or NULL if zlib couldn&#039;t
# be imported. The function is cached when found, so subsequent calls
# don&#039;t import zlib again.
def _get_decompress_func():
    global _importing_zlib
    if _importing_zlib:
        # Someone has a zlib.py[co] in their Zip file
        # let&#039;s avoid a stack overflow.
        _bootstrap._verbose_message(&#039;zipimport: zlib UNAVAILABLE&#039;)
        raise ZipImportError(&quot;can&#039;t decompress data; zlib not available&quot;)

    _importing_zlib = True
    try:
        from zlib import decompress
    except Exception:
        _bootstrap._verbose_message(&#039;zipimport: zlib UNAVAILABLE&#039;)
        raise ZipImportError(&quot;can&#039;t decompress data; zlib not available&quot;)
    finally:
        _importing_zlib = False

    _bootstrap._verbose_message(&#039;zipimport: zlib available&#039;)
    return decompress

# Given a path to a Zip file and a toc_entry, return the (uncompressed) data.
def _get_data(archive, toc_entry):
    datapath, compress, data_size, file_size, file_offset, time, date, crc = toc_entry
    if data_size &lt; 0:
        raise ZipImportError(&#039;negative data size&#039;)

    with _io.open_code(archive) as fp:
        # Check to make sure the local file header is correct
        try:
            fp.seek(file_offset)
        except OSError:
            raise ZipImportError(f&quot;can&#039;t read Zip file: {archive!r}&quot;, path=archive)
        buffer = fp.read(30)
        if len(buffer) != 30:
            raise EOFError(&#039;EOF read where not expected&#039;)

        if buffer[:4] != b&#039;PK\x03\x04&#039;:
            # Bad: Local File Header
            raise ZipImportError(f&#039;bad local file header: {archive!r}&#039;, path=archive)

        name_size = _unpack_uint16(buffer[26:28])
        extra_size = _unpack_uint16(buffer[28:30])
        header_size = 30 + name_size + extra_size
        file_offset += header_size  # Start of file data
        try:
            fp.seek(file_offset)
        except OSError:
            raise ZipImportError(f&quot;can&#039;t read Zip file: {archive!r}&quot;, path=archive)
        raw_data = fp.read(data_size)
        if len(raw_data) != data_size:
            raise OSError(&quot;zipimport: can&#039;t read data&quot;)

    if compress == 0:
        # data is not compressed
        return raw_data

    # Decompress with zlib
    try:
        decompress = _get_decompress_func()
    except Exception:
        raise ZipImportError(&quot;can&#039;t decompress data; zlib not available&quot;)
    return decompress(raw_data, -15)


# Lenient date/time comparison function. The precision of the mtime
# in the archive is lower than the mtime stored in a .pyc: we
# must allow a difference of at most one second.
def _eq_mtime(t1, t2):
    # dostime only stores even seconds, so be lenient
    return abs(t1 - t2) &lt;= 1


# Given the contents of a .py[co] file, unmarshal the data
# and return the code object. Raises ImportError it the magic word doesn&#039;t
# match, or if the recorded .py[co] metadata does not match the source.
def _unmarshal_code(self, pathname, fullpath, fullname, data):
    exc_details = {
        &#039;name&#039;: fullname,
        &#039;path&#039;: fullpath,
    }

    flags = _bootstrap_external._classify_pyc(data, fullname, exc_details)

    hash_based = flags &amp; 0b1 != 0
    if hash_based:
        check_source = flags &amp; 0b10 != 0
        if (_imp.check_hash_based_pycs != &#039;never&#039; and
                (check_source or _imp.check_hash_based_pycs == &#039;always&#039;)):
            source_bytes = _get_pyc_source(self, fullpath)
            if source_bytes is not None:
                source_hash = _imp.source_hash(
                    _bootstrap_external._RAW_MAGIC_NUMBER,
                    source_bytes,
                )

                _bootstrap_external._validate_hash_pyc(
                    data, source_hash, fullname, exc_details)
    else:
        source_mtime, source_size = \
            _get_mtime_and_size_of_source(self, fullpath)

        if source_mtime:
            # We don&#039;t use _bootstrap_external._validate_timestamp_pyc
            # to allow for a more lenient timestamp check.
            if (not _eq_mtime(_unpack_uint32(data[8:12]), source_mtime) or
                    _unpack_uint32(data[12:16]) != source_size):
                _bootstrap._verbose_message(
                    f&#039;bytecode is stale for {fullname!r}&#039;)
                return None

    code = marshal.loads(data[16:])
    if not isinstance(code, _code_type):
        raise TypeError(f&#039;compiled module {pathname!r} is not a code object&#039;)
    return code

_code_type = type(_unmarshal_code.__code__)


# Replace any occurrences of &#039;\r\n?&#039; in the input string with &#039;\n&#039;.
# This converts DOS and Mac line endings to Unix line endings.
def _normalize_line_endings(source):
    source = source.replace(b&#039;\r\n&#039;, b&#039;\n&#039;)
    source = source.replace(b&#039;\r&#039;, b&#039;\n&#039;)
    return source

# Given a string buffer containing Python source code, compile it
# and return a code object.
def _compile_source(pathname, source):
    source = _normalize_line_endings(source)
    return compile(source, pathname, &#039;exec&#039;, dont_inherit=True)

# Convert the date/time values found in the Zip archive to a value
# that&#039;s compatible with the time stamp stored in .pyc files.
def _parse_dostime(d, t):
    return time.mktime((
        (d &gt;&gt; 9) + 1980,    # bits 9..15: year
        (d &gt;&gt; 5) &amp; 0xF,     # bits 5..8: month
        d &amp; 0x1F,           # bits 0..4: day
        t &gt;&gt; 11,            # bits 11..15: hours
        (t &gt;&gt; 5) &amp; 0x3F,    # bits 8..10: minutes
        (t &amp; 0x1F) * 2,     # bits 0..7: seconds / 2
        -1, -1, -1))

# Given a path to a .pyc file in the archive, return the
# modification time of the matching .py file and its size,
# or (0, 0) if no source is available.
def _get_mtime_and_size_of_source(self, path):
    try:
        # strip &#039;c&#039; or &#039;o&#039; from *.py[co]
        assert path[-1:] in (&#039;c&#039;, &#039;o&#039;)
        path = path[:-1]
        toc_entry = self._files[path]
        # fetch the time stamp of the .py file for comparison
        # with an embedded pyc time stamp
        time = toc_entry[5]
        date = toc_entry[6]
        uncompressed_size = toc_entry[3]
        return _parse_dostime(date, time), uncompressed_size
    except (KeyError, IndexError, TypeError):
        return 0, 0


# Given a path to a .pyc file in the archive, return the
# contents of the matching .py file, or None if no source
# is available.
def _get_pyc_source(self, path):
    # strip &#039;c&#039; or &#039;o&#039; from *.py[co]
    assert path[-1:] in (&#039;c&#039;, &#039;o&#039;)
    path = path[:-1]

    try:
        toc_entry = self._files[path]
    except KeyError:
        return None
    else:
        return _get_data(self.archive, toc_entry)


# Get the code object associated with the module specified by
# &#039;fullname&#039;.
def _get_module_code(self, fullname):
    path = _get_module_path(self, fullname)
    import_error = None
    for suffix, isbytecode, ispackage in _zip_searchorder:
        fullpath = path + suffix
        _bootstrap._verbose_message(&#039;trying {}{}{}&#039;, self.archive, path_sep, fullpath, verbosity=2)
        try:
            toc_entry = self._files[fullpath]
        except KeyError:
            pass
        else:
            modpath = toc_entry[0]
            data = _get_data(self.archive, toc_entry)
            code = None
            if isbytecode:
                try:
                    code = _unmarshal_code(self, modpath, fullpath, fullname, data)
                except ImportError as exc:
                    import_error = exc
            else:
                code = _compile_source(modpath, data)
            if code is None:
                # bad magic number or non-matching mtime
                # in byte code, try next
                continue
            modpath = toc_entry[0]
            return code, ispackage, modpath
    else:
        if import_error:
            msg = f&quot;module load failed: {import_error}&quot;
            raise ZipImportError(msg, name=fullname) from import_error
        else:
            raise ZipImportError(f&quot;can&#039;t find module {fullname!r}&quot;, name=fullname)
</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>