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

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)

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

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)

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

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