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."""

return key in _os.environ

else:

def _relax_case():

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

return False

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

if len(path_separators) == 1:

front, _, tail = path.rpartition(path_sep)

return front, tail

for x in reversed(path):

if x in path_separators:

front, tail = path.rsplit(x, maxsplit=1)

return front, tail

"""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.

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

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

path_tmp = '{}.{}'.format(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.FileIO(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.

if debug_override is not None:

_warnings.warn('the debug_override parameter is deprecated; use '

"'optimization' instead", DeprecationWarning)

if optimization is not None:

message = 'debug_override or optimization must be set to None'

raise TypeError(message)

optimization = '' if debug_override else 1

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('{!r} is not alphanumeric'.format(optimization))

almost_filename = '{}.{}{}'.format(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\`.

if not _path_isabs(head):

head = _path_join(_os.getcwd(), 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.

if head[1] == ':' and head[0] 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)

try:

_wrap = _bootstrap._wrap

except NameError:

# XXX yuck

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)

"""Try to find a loader for the specified module by delegating to

# Call find_loader(). If it returns a string (indicating this

# is a namespace package portion), generate a warning and

# return None.

loader, portions = self.find_loader(fullname)

if loader is None and len(portions):

msg = 'Not importing directory {}: missing __init__'

_warnings.warn(msg.format(portions[0]), ImportWarning)

"""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 = _r_long(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 _r_long(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

_r_long(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('Non-code object in {!r}'.format(bytecode_path),

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

data = bytearray(MAGIC_NUMBER)

data.extend(_w_long(0))

data.extend(_w_long(mtime))

data.extend(_w_long(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(_w_long(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)

newline_decoder = _io.IncrementalNewlineDecoder(None, True)

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)

# 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)

"""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 = False # Changed in _setup()

@classmethod

def _open_registry(cls, 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):

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)

return spec

@classmethod

def find_module(cls, fullname, path=None):

"""Find module named in the registry.

spec = cls.find_spec(fullname, path)

if spec is not None:

return spec.loader

else:

"""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('cannot load module {!r} when get_code() '

'returns None'.format(module.__name__))

_bootstrap._call_with_frames_removed(exec, code, module.__dict__)

def load_module(self, fullname):

"""This module is deprecated."""

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 path

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, *, _optimize=-1):

"""Return the code object compiled from source.

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

dont_inherit=True, optimize=_optimize)

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(

_RAW_MAGIC_NUMBER,

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)

_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(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)

_bootstrap._verbose_message('wrote {!r}', bytecode_path)

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 load_module(self, fullname):

"""Load a module from a file.

# The only reason for this method is for the name check.

# Issue #14857: Avoid the zero-argument form of super so the implementation

# of that form can be updated without breaking the frozen module

return super(FileLoader, self).load_module(fullname)

@_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."""

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

return file.read()

# ResourceReader ABC API.

@_check_name

def get_resource_reader(self, module):

if self.is_package(module):

return self

return None

def open_resource(self, resource):

path = _path_join(_path_split(self.path)[0], resource)

return _io.FileIO(path, 'r')

def resource_path(self, resource):

if not self.is_resource(resource):

raise FileNotFoundError

path = _path_join(_path_split(self.path)[0], resource)

return path

def is_resource(self, name):

if path_sep in name:

return False

path = _path_join(_path_split(self.path)[0], name)

return _path_isfile(path)

def contents(self):

"""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