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

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

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)

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

head, pycache_filename = _path_split(path)

head, pycache = _path_split(head)

if pycache != _PYCACHE:

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

'{!r}'.format(_PYCACHE, path))

dot_count = pycache_filename.count('.')

if dot_count not in {2, 3}:

raise ValueError('expected only 2 or 3 dots in '

'{!r}'.format(pycache_filename))

elif dot_count == 3:

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

if not optimization.startswith(_OPT):

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

"with {!r}".format(_OPT))

opt_level = optimization[len(_OPT):]

if not opt_level.isalnum():

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

"value".format(optimization))

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

"""Print the message to stderr if -v/PYTHONVERBOSE is turned on."""

if sys.flags.verbose >= verbosity:

if not message.startswith(('#', 'import ')):

message = '# ' + message

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

"""Validate the header of the passed-in bytecode against source_stats (if

exc_details = {}

if name is not None:

exc_details['name'] = name

else:

# To prevent having to make all messages have a conditional name.

name = '<bytecode>'

if path is not None:

exc_details['path'] = path

magic = data[:4]

raw_timestamp = data[4:8]

raw_size = data[8:12]

if magic != MAGIC_NUMBER:

message = 'bad magic number in {!r}: {!r}'.format(name, magic)

_verbose_message('{}', message)

raise ImportError(message, **exc_details)

elif len(raw_timestamp) != 4:

message = 'reached EOF while reading timestamp in {!r}'.format(name)

_verbose_message('{}', message)

raise EOFError(message)

elif len(raw_size) != 4:

message = 'reached EOF while reading size of source in {!r}'.format(name)

_verbose_message('{}', message)

raise EOFError(message)

if source_stats is not None:

try:

source_mtime = int(source_stats['mtime'])

except KeyError:

pass

else:

if _r_long(raw_timestamp) != source_mtime:

message = 'bytecode is stale for {!r}'.format(name)

_verbose_message('{}', message)

raise ImportError(message, **exc_details)

try:

source_size = source_stats['size'] & 0xFFFFFFFF

except KeyError:

pass

else:

if _r_long(raw_size) != source_size:

raise ImportError('bytecode is stale for {!r}'.format(name),

**exc_details)

"""Compile bytecode as returned by _validate_bytecode_header()."""

code = marshal.loads(data)

if isinstance(code, _code_type):

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

"""Compile a code object into bytecode for writing out to a byte-compiled

data = bytearray(MAGIC_NUMBER)

data.extend(_w_long(mtime))

data.extend(_w_long(source_size))

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

# 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=sys.version[:3])

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

def path_mtime(self, path):

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

raise IOError

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

try:

bytecode_path = cache_from_source(source_path)

except NotImplementedError:

bytecode_path = None

else:

try:

st = self.path_stats(source_path)

except IOError:

pass

else:

source_mtime = int(st['mtime'])

try:

data = self.get_data(bytecode_path)

except OSError:

pass

else:

try:

bytes_data = _validate_bytecode_header(data,

source_stats=st, name=fullname,

path=bytecode_path)

except (ImportError, EOFError):

pass

else:

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

source_path)

return _compile_bytecode(bytes_data, name=fullname,

bytecode_path=bytecode_path,

source_path=source_path)

source_bytes = self.get_data(source_path)

code_object = self.source_to_code(source_bytes, source_path)

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

data = _code_to_bytecode(code_object, source_mtime,

len(source_bytes))

try:

self._cache_bytecode(source_path, bytecode_path, data)

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

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

_verbose_message('could not create {!r}: {!r}', parent, exc)

return

try:

_write_atomic(path, data, _mode)

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

except OSError as exc:

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

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

def get_code(self, fullname):

path = self.get_filename(fullname)

data = self.get_data(path)

bytes_data = _validate_bytecode_header(data, name=fullname, path=path)

return _compile_bytecode(bytes_data, name=fullname, bytecode_path=path)

def get_source(self, fullname):

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

"""Loader for extension modules.

def __init__(self, name, path):

self.name = name

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)

def create_module(self, spec):

"""Create an unitialized extension module"""

module = _bootstrap._call_with_frames_removed(

_imp.create_dynamic, spec)

_verbose_message('extension module {!r} loaded from {!r}',

spec.name, self.path)

return module

def exec_module(self, module):

"""Initialize an extension module"""

_bootstrap._call_with_frames_removed(_imp.exec_dynamic, module)

_verbose_message('extension module {!r} executed from {!r}',

self.name, self.path)

def is_package(self, fullname):

"""Return True if the extension module is a package."""

file_name = _path_split(self.path)[1]

return any(file_name == '__init__' + suffix

for suffix in EXTENSION_SUFFIXES)

def get_code(self, fullname):

"""Return None as an extension module cannot create a code object."""

return None

def get_source(self, fullname):

"""Return None as extension modules have no source code."""

return None

@_check_name

def get_filename(self, fullname):

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

"""Represents a namespace package's path. It uses the module name

def __init__(self, name, path, path_finder):

self._name = name

self._path = path

self._last_parent_path = tuple(self._get_parent_path())

self._path_finder = path_finder

def _find_parent_path_names(self):

"""Returns a tuple of (parent-module-name, parent-path-attr-name)"""

parent, dot, me = self._name.rpartition('.')

if dot == '':

# This is a top-level module. sys.path contains the parent path.

return 'sys', 'path'

# Not a top-level module. parent-module.__path__ contains the

# parent path.

return parent, '__path__'

def _get_parent_path(self):

parent_module_name, path_attr_name = self._find_parent_path_names()

return getattr(sys.modules[parent_module_name], path_attr_name)

def _recalculate(self):

# If the parent's path has changed, recalculate _path

parent_path = tuple(self._get_parent_path()) # Make a copy

if parent_path != self._last_parent_path:

spec = self._path_finder(self._name, parent_path)

# Note that no changes are made if a loader is returned, but we

# do remember the new parent path

if spec is not None and spec.loader is None:

if spec.submodule_search_locations:

self._path = spec.submodule_search_locations

self._last_parent_path = parent_path # Save the copy

return self._path

def __iter__(self):

return iter(self._recalculate())

def __len__(self):

return len(self._recalculate())

def __repr__(self):

return '_NamespacePath({!r})'.format(self._path)

def __contains__(self, item):

return item in self._recalculate()

def append(self, item):