if sys.platform.startswith(_CASE_INSENSITIVE_PLATFORMS):

if sys.platform.startswith(_CASE_INSENSITIVE_PLATFORMS_STR_KEY):

key = 'PYTHONCASEOK'

else:

key = b'PYTHONCASEOK'

def _relax_case():

"""True if filenames must be checked case-insensitively and ignore environment flags are not set."""

return not sys.flags.ignore_environment and key in _os.environ

else:

def _relax_case():

"""True if filenames must be checked case-insensitively."""

return False

"""Replacement for os.path.join()."""

if not path_parts:

return ""

if len(path_parts) == 1:

return path_parts[0]

root = ""

path = []

for new_root, tail in map(_os._path_splitroot, path_parts):

if new_root.startswith(path_sep_tuple) or new_root.endswith(path_sep_tuple):

root = new_root.rstrip(path_separators) or root

path = [path_sep + tail]

elif new_root.endswith(':'):

if root.casefold() != new_root.casefold():

# Drive relative paths have to be resolved by the OS, so we reset the

# tail but do not add a path_sep prefix.

root = new_root

path = [tail]

else:

path.append(tail)

else:

root = new_root or root

path.append(tail)

path = [p.rstrip(path_separators) for p in path if p]

if len(path) == 1 and not path[0]:

# Avoid losing the root's trailing separator when joining with nothing

return root + path_sep

"""Replacement for os.path.split()."""

i = max(path.rfind(p) for p in path_separators)

if i < 0:

return '', path

"""Stat the path.

"""Test whether the path is the specified mode type."""

try:

stat_info = _path_stat(path)

except OSError:

return False

"""Replacement for os.path.isdir."""

if not path:

path = _os.getcwd()

"""Replacement for os.path.isabs."""

if not path:

return False

root = _os._path_splitroot(path)[0].replace('/', '\\')

"""Replacement for os.path.abspath."""

if not _path_isabs(path):

for sep in path_separators:

path = path.removeprefix(f".{sep}")

return _path_join(_os.getcwd(), path)

else:

"""Best-effort function to write data to a path atomically.

# id() is used to generate a pseudo-random filename.

path_tmp = f'{path}.{id(path)}'

fd = _os.open(path_tmp,

_os.O_EXCL | _os.O_CREAT | _os.O_WRONLY, mode & 0o666)

try:

# We first write data to a temporary file, and then use os.replace() to

# perform an atomic rename.

with _io.open(fd, 'wb') as file:

file.write(data)

_os.replace(path_tmp, path)

except OSError:

try:

_os.unlink(path_tmp)

except OSError:

pass

"""Given the path to a .py file, return the path to its .pyc file.

path = _os.fspath(path)

head, tail = _path_split(path)

base, sep, rest = tail.rpartition('.')

tag = sys.implementation.cache_tag

if tag is None:

raise NotImplementedError('sys.implementation.cache_tag is None')

almost_filename = ''.join([(base if base else rest), sep, tag])

if optimization is None:

if sys.flags.optimize == 0:

optimization = ''

else:

optimization = sys.flags.optimize

optimization = str(optimization)

if optimization != '':

if not optimization.isalnum():

raise ValueError(f'{optimization!r} is not alphanumeric')

almost_filename = f'{almost_filename}.{_OPT}{optimization}'

filename = almost_filename + BYTECODE_SUFFIXES[0]

if sys.pycache_prefix is not None:

# We need an absolute path to the py file to avoid the possibility of

# collisions within sys.pycache_prefix, if someone has two different

# `foo/bar.py` on their system and they import both of them using the

# same sys.pycache_prefix. Let's say sys.pycache_prefix is

# `C:\Bytecode`; the idea here is that if we get `Foo\Bar`, we first

# make it absolute (`C:\Somewhere\Foo\Bar`), then make it root-relative

# (`Somewhere\Foo\Bar`), so we end up placing the bytecode file in an

# unambiguous `C:\Bytecode\Somewhere\Foo\Bar\`.

head = _path_abspath(head)

# Strip initial drive from a Windows path. We know we have an absolute

# path here, so the second part of the check rules out a POSIX path that

# happens to contain a colon at the second character.

# Slicing avoids issues with an empty (or short) `head`.

if head[1:2] == ':' and head[0:1] not in path_separators:

head = head[2:]

# Strip initial path separator from `head` to complete the conversion

# back to a root-relative path before joining.

return _path_join(

sys.pycache_prefix,

head.lstrip(path_separators),

filename,

)

"""Given the path to a .pyc. file, return the path to its .py file.

if sys.implementation.cache_tag is None:

raise NotImplementedError('sys.implementation.cache_tag is None')

path = _os.fspath(path)

head, pycache_filename = _path_split(path)

found_in_pycache_prefix = False

if sys.pycache_prefix is not None:

stripped_path = sys.pycache_prefix.rstrip(path_separators)

if head.startswith(stripped_path + path_sep):

head = head[len(stripped_path):]

found_in_pycache_prefix = True

if not found_in_pycache_prefix:

head, pycache = _path_split(head)

if pycache != _PYCACHE:

raise ValueError(f'{_PYCACHE} not bottom-level directory in '

f'{path!r}')

dot_count = pycache_filename.count('.')

if dot_count not in {2, 3}:

raise ValueError(f'expected only 2 or 3 dots in {pycache_filename!r}')

elif dot_count == 3:

optimization = pycache_filename.rsplit('.', 2)[-2]

if not optimization.startswith(_OPT):

raise ValueError("optimization portion of filename does not start "

f"with {_OPT!r}")

opt_level = optimization[len(_OPT):]

if not opt_level.isalnum():

raise ValueError(f"optimization level {optimization!r} is not an "

"alphanumeric value")

base_filename = pycache_filename.partition('.')[0]

"""Convert a bytecode file path to a source path (if possible).

if len(bytecode_path) == 0:

return None

rest, _, extension = bytecode_path.rpartition('.')

if not rest or extension.lower()[-3:-1] != 'py':

return bytecode_path

try:

source_path = source_from_cache(bytecode_path)

except (NotImplementedError, ValueError):

source_path = bytecode_path[:-1]

if filename.endswith(tuple(SOURCE_SUFFIXES)):

try:

return cache_from_source(filename)

except NotImplementedError:

pass

elif filename.endswith(tuple(BYTECODE_SUFFIXES)):

return filename

else:

"""Calculate the mode permissions for a bytecode file."""

try:

mode = _path_stat(path).st_mode

except OSError:

mode = 0o666

# We always ensure write access so we can update cached files

# later even when the source files are read-only on Windows (#6074)

mode |= 0o200

"""Decorator to verify that the module being requested matches the one the

def _check_name_wrapper(self, name=None, *args, **kwargs):

if name is None:

name = self.name

elif self.name != name:

raise ImportError('loader for %s cannot handle %s' %

(self.name, name), name=name)

return method(self, name, *args, **kwargs)

# FIXME: @_check_name is used to define class methods before the

# _bootstrap module is set by _set_bootstrap_module().

if _bootstrap is not None:

_wrap = _bootstrap._wrap

else:

def _wrap(new, old):

for replace in ['__module__', '__name__', '__qualname__', '__doc__']:

if hasattr(old, replace):

setattr(new, replace, getattr(old, replace))

new.__dict__.update(old.__dict__)

_wrap(_check_name_wrapper, method)

"""Perform basic validity checking of a pyc header and return the flags field,

magic = data[:4]

if magic != MAGIC_NUMBER:

message = f'bad magic number in {name!r}: {magic!r}'

_bootstrap._verbose_message('{}', message)

raise ImportError(message, **exc_details)

if len(data) < 16:

message = f'reached EOF while reading pyc header of {name!r}'

_bootstrap._verbose_message('{}', message)

raise EOFError(message)

flags = _unpack_uint32(data[4:8])

# Only the first two flags are defined.

if flags & ~0b11:

message = f'invalid flags {flags!r} in {name!r}'

raise ImportError(message, **exc_details)

exc_details):

"""Validate a pyc against the source last-modified time.

if _unpack_uint32(data[8:12]) != (source_mtime & 0xFFFFFFFF):

message = f'bytecode is stale for {name!r}'

_bootstrap._verbose_message('{}', message)

raise ImportError(message, **exc_details)

if (source_size is not None and

_unpack_uint32(data[12:16]) != (source_size & 0xFFFFFFFF)):

"""Validate a hash-based pyc by checking the real source hash against the one in

if data[8:16] != source_hash:

raise ImportError(

f'hash in bytecode doesn\'t match hash of source {name!r}',

**exc_details,

"""Compile bytecode as found in a pyc."""

code = marshal.loads(data)

if isinstance(code, _code_type):

_bootstrap._verbose_message('code object from {!r}', bytecode_path)

if source_path is not None:

_imp._fix_co_filename(code, source_path)

return code

else:

raise ImportError(f'Non-code object in {bytecode_path!r}',

"Produce the data for a timestamp-based pyc."

data = bytearray(MAGIC_NUMBER)

data.extend(_pack_uint32(0))

data.extend(_pack_uint32(mtime))

data.extend(_pack_uint32(source_size))

data.extend(marshal.dumps(code))

"Produce the data for a hash-based pyc."

data = bytearray(MAGIC_NUMBER)

flags = 0b1 | checked << 1

data.extend(_pack_uint32(flags))

assert len(source_hash) == 8

data.extend(source_hash)

data.extend(marshal.dumps(code))

"""Decode bytes representing source code and return the string.

import tokenize # To avoid bootstrap issues.

source_bytes_readline = _io.BytesIO(source_bytes).readline

encoding = tokenize.detect_encoding(source_bytes_readline)

submodule_search_locations=_POPULATE):

"""Return a module spec based on a file location.

if location is None:

# The caller may simply want a partially populated location-

# oriented spec. So we set the location to a bogus value and

# fill in as much as we can.

location = '<unknown>'

if hasattr(loader, 'get_filename'):

# ExecutionLoader

try:

location = loader.get_filename(name)

except ImportError:

pass

else:

location = _os.fspath(location)

try:

location = _path_abspath(location)

except OSError:

pass

# If the location is on the filesystem, but doesn't actually exist,

# we could return None here, indicating that the location is not

# valid. However, we don't have a good way of testing since an

# indirect location (e.g. a zip file or URL) will look like a

# non-existent file relative to the filesystem.

spec = _bootstrap.ModuleSpec(name, loader, origin=location)

spec._set_fileattr = True

# Pick a loader if one wasn't provided.

if loader is None:

for loader_class, suffixes in _get_supported_file_loaders():

if location.endswith(tuple(suffixes)):

loader = loader_class(name, location)

spec.loader = loader

break

else:

return None

# Set submodule_search_paths appropriately.

if submodule_search_locations is _POPULATE:

# Check the loader.

if hasattr(loader, 'is_package'):

try:

is_package = loader.is_package(name)

except ImportError:

pass

else:

if is_package:

spec.submodule_search_locations = []

else:

spec.submodule_search_locations = submodule_search_locations

if spec.submodule_search_locations == []:

if location:

dirname = _path_split(location)[0]

spec.submodule_search_locations.append(dirname)

"""Helper function for _warnings.c

# 2022-10-06(warsaw): For now, this helper is only used in _warnings.c and

# that use case only has the module globals. This function could be

# extended to accept either that or a module object. However, in the

# latter case, it would be better to raise certain exceptions when looking

# at a module, which should have either a __loader__ or __spec__.loader.

# For backward compatibility, it is possible that we'll get an empty

# dictionary for the module globals, and that cannot raise an exception.

if not isinstance(module_globals, dict):

return None

missing = object()

loader = module_globals.get('__loader__', None)

spec = module_globals.get('__spec__', missing)

if loader is None:

if spec is missing:

# If working with a module:

# raise AttributeError('Module globals is missing a __spec__')

return None

elif spec is None:

raise ValueError('Module globals is missing a __spec__.loader')

spec_loader = getattr(spec, 'loader', missing)

if spec_loader in (missing, None):

if loader is None:

exc = AttributeError if spec_loader is missing else ValueError

raise exc('Module globals is missing a __spec__.loader')

_warnings.warn(

'Module globals is missing a __spec__.loader',

DeprecationWarning)

spec_loader = loader

assert spec_loader is not None

if loader is not None and loader != spec_loader:

_warnings.warn(

'Module globals; __loader__ != __spec__.loader',

DeprecationWarning)

return loader

"""Meta path finder for modules declared in the Windows registry."""

REGISTRY_KEY = (

'Software\\Python\\PythonCore\\{sys_version}'

'\\Modules\\{fullname}')

REGISTRY_KEY_DEBUG = (

'Software\\Python\\PythonCore\\{sys_version}'

'\\Modules\\{fullname}\\Debug')

DEBUG_BUILD = (_MS_WINDOWS and '_d.pyd' in EXTENSION_SUFFIXES)

@staticmethod

def _open_registry(key):

try:

return winreg.OpenKey(winreg.HKEY_CURRENT_USER, key)

except OSError:

return winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, key)

@classmethod

def _search_registry(cls, fullname):

if cls.DEBUG_BUILD:

registry_key = cls.REGISTRY_KEY_DEBUG

else:

registry_key = cls.REGISTRY_KEY

key = registry_key.format(fullname=fullname,

sys_version='%d.%d' % sys.version_info[:2])

try:

with cls._open_registry(key) as hkey:

filepath = winreg.QueryValue(hkey, '')

except OSError:

return None

return filepath

@classmethod

def find_spec(cls, fullname, path=None, target=None):

_warnings.warn('importlib.machinery.WindowsRegistryFinder is '

'deprecated; use site configuration instead. '

'Future versions of Python may not enable this '

'finder by default.',

DeprecationWarning, stacklevel=2)

filepath = cls._search_registry(fullname)

if filepath is None:

return None

try:

_path_stat(filepath)

except OSError:

return None

for loader, suffixes in _get_supported_file_loaders():

if filepath.endswith(tuple(suffixes)):

spec = _bootstrap.spec_from_loader(fullname,

loader(fullname, filepath),

origin=filepath)

"""Base class of common code needed by both SourceLoader and

def is_package(self, fullname):

"""Concrete implementation of InspectLoader.is_package by checking if

filename = _path_split(self.get_filename(fullname))[1]

filename_base = filename.rsplit('.', 1)[0]

tail_name = fullname.rpartition('.')[2]

return filename_base == '__init__' and tail_name != '__init__'

def create_module(self, spec):

"""Use default semantics for module creation."""

def exec_module(self, module):

"""Execute the module."""

code = self.get_code(module.__name__)

if code is None:

raise ImportError(f'cannot load module {module.__name__!r} when '

'get_code() returns None')

def path_mtime(self, path):

"""Optional method that returns the modification time (an int) for the

raise OSError

def path_stats(self, path):

"""Optional method returning a metadata dict for the specified

return {'mtime': self.path_mtime(path)}

def _cache_bytecode(self, source_path, cache_path, data):

"""Optional method which writes data (bytes) to a file path (a str).

# For backwards compatibility, we delegate to set_data()

return self.set_data(cache_path, data)

def set_data(self, path, data):

"""Optional method which writes data (bytes) to a file path (a str).

def get_source(self, fullname):

"""Concrete implementation of InspectLoader.get_source."""

path = self.get_filename(fullname)

try:

source_bytes = self.get_data(path)

except OSError as exc:

raise ImportError('source not available through get_data()',

name=fullname) from exc

return decode_source(source_bytes)

def source_to_code(self, data, path, fullname=None, *, _optimize=-1):

"""Return the code object compiled from source.

return _bootstrap._call_with_frames_removed(compile, data, path, 'exec',

dont_inherit=True, optimize=_optimize,

module=fullname)

def get_code(self, fullname):

"""Concrete implementation of InspectLoader.get_code.

source_path = self.get_filename(fullname)

source_mtime = None

source_bytes = None

source_hash = None

hash_based = False

check_source = True

try:

bytecode_path = cache_from_source(source_path)

except NotImplementedError:

bytecode_path = None

else:

try:

st = self.path_stats(source_path)

except OSError:

pass

else:

source_mtime = int(st['mtime'])

try:

data = self.get_data(bytecode_path)

except OSError:

pass

else:

exc_details = {

'name': fullname,

'path': bytecode_path,

}

try:

flags = _classify_pyc(data, fullname, exc_details)

bytes_data = memoryview(data)[16:]

hash_based = flags & 0b1 != 0

if hash_based:

check_source = flags & 0b10 != 0

if (_imp.check_hash_based_pycs != 'never' and

(check_source or

_imp.check_hash_based_pycs == 'always')):

source_bytes = self.get_data(source_path)

source_hash = _imp.source_hash(

_imp.pyc_magic_number_token,

source_bytes,

)

_validate_hash_pyc(data, source_hash, fullname,

exc_details)

else:

_validate_timestamp_pyc(

data,

source_mtime,

st['size'],

fullname,

exc_details,

)

except (ImportError, EOFError):

pass

else:

_bootstrap._verbose_message('{} matches {}', bytecode_path,

source_path)

return _compile_bytecode(bytes_data, name=fullname,

bytecode_path=bytecode_path,

source_path=source_path)

if source_bytes is None:

source_bytes = self.get_data(source_path)

code_object = self.source_to_code(source_bytes, source_path, fullname)

_bootstrap._verbose_message('code object from {}', source_path)

if (not sys.dont_write_bytecode and bytecode_path is not None and

source_mtime is not None):

if hash_based:

if source_hash is None:

source_hash = _imp.source_hash(_imp.pyc_magic_number_token,

source_bytes)

data = _code_to_hash_pyc(code_object, source_hash, check_source)

else:

data = _code_to_timestamp_pyc(code_object, source_mtime,

len(source_bytes))

try:

self._cache_bytecode(source_path, bytecode_path, data)

except NotImplementedError:

pass

"""Base file loader class which implements the loader protocol methods that

def __init__(self, fullname, path):

"""Cache the module name and the path to the file found by the

self.name = fullname

self.path = path

def __eq__(self, other):

return (self.__class__ == other.__class__ and

self.__dict__ == other.__dict__)

def __hash__(self):

return hash(self.name) ^ hash(self.path)

@_check_name

def get_filename(self, fullname):

"""Return the path to the source file as found by the finder."""

return self.path

def get_data(self, path):

"""Return the data from path as raw bytes."""

if isinstance(self, (SourceLoader, SourcelessFileLoader, ExtensionFileLoader)):

with _io.open_code(str(path)) as file:

return file.read()

else:

with _io.FileIO(path, 'r') as file:

return file.read()

@_check_name

def get_resource_reader(self, module):

from importlib.readers import FileReader

"""Concrete implementation of SourceLoader using the file system."""

def path_stats(self, path):

"""Return the metadata for the path."""

st = _path_stat(path)

return {'mtime': st.st_mtime, 'size': st.st_size}

def _cache_bytecode(self, source_path, bytecode_path, data):

# Adapt between the two APIs

mode = _calc_mode(source_path)

return self.set_data(bytecode_path, data, _mode=mode)

def set_data(self, path, data, *, _mode=0o666):

"""Write bytes data to a file."""

parent, filename = _path_split(path)

path_parts = []

# Figure out what directories are missing.

while parent and not _path_isdir(parent):

parent, part = _path_split(parent)

path_parts.append(part)

# Create needed directories.

for part in reversed(path_parts):

parent = _path_join(parent, part)

try:

_os.mkdir(parent)

except FileExistsError:

# Probably another Python process already created the dir.

continue

except OSError as exc:

# Could be a permission error, read-only filesystem: just forget

# about writing the data.

_bootstrap._verbose_message('could not create {!r}: {!r}',

parent, exc)

return

try:

_write_atomic(path, data, _mode)

_bootstrap._verbose_message('created {!r}', path)

except OSError as exc:

# Same as above: just don't write the bytecode.

_bootstrap._verbose_message('could not create {!r}: {!r}', path,

"""Loader which handles sourceless file imports."""

def get_code(self, fullname):

path = self.get_filename(fullname)

data = self.get_data(path)

# Call _classify_pyc to do basic validation of the pyc but ignore the

# result. There's no source to check against.

exc_details = {

'name': fullname,

'path': path,

}

_classify_pyc(data, fullname, exc_details)

return _compile_bytecode(

memoryview(data)[16:],

name=fullname,

bytecode_path=path,

)

def get_source(self, fullname):

"""Return None as there is no source code."""