mirror of
https://github.com/RustPython/RustPython.git
synced 2026-10-29 11:14:38 +08:00
Jeong, YunWon
7c6c78f955
* Add _interpreters and _interpchannels modules
Apply the patch baseline for the low-level subinterpreter modules:
- crates/vm/src/stdlib/_interpreters.rs: create/destroy/list_all/get_main/
get_current/is_running/exec/call/run_string/run_func/set___main___attrs/
is_shareable/whence and the Interpreter*Error exceptions
- crates/vm/src/stdlib/_interpchannels.rs: channel create/destroy/send/recv/
list_all/list_interpreters/release/close and the Channel*Error exceptions
- crates/vm/src/vm/crossinterp.rs: cross-interpreter data protocol
- crates/vm/src/vm/{interpreter,mod,runtime,vm_new}.rs: interpreter registry
and lifecycle plumbing the modules need
- Lib/concurrent/interpreters/: high-level PEP 734 package
Assisted-by: Claude:claude-opus-5
* Correct _interpreters and _interpchannels against CPython 3.14
Argument matching:
- Add `function::ArgSpec`, a `PyArg_ParseTupleAndKeywords` equivalent that
applies the `|`, `$` and `:` markers of a format string to a `kwlist`, and
route every module function of both modules through it. This enforces
keyword-only parameters, rejects unexpected keywords, accepts keyword forms
that were previously positional-only (`whence(id=)`, `get_config(id=)`,
`set___main___attrs(id=, updates=)`, `capture_exception(exc=)`,
`_register_end_types(send=, recv=)`), and reproduces the arity messages.
- `O!` slots (`shared`, `updates`, `call`'s `args`/`kwargs`) now reject None,
and `_PyArg_BadArgument` renders None as "None" rather than "NoneType".
- `new_config` takes at most one positional `str`; `list_all` of
`_interpchannels` is argument-less.
- Convert arguments in `kwlist` order, so an argument's own error is raised
ahead of the checks that follow it.
_interpreters:
- Add the `CrossInterpreterBufferView` type and build the received memoryview
on it, keeping the sending interpreter's exporter out of the destination.
- Build `excinfo.errdisplay` from `traceback.TracebackException`.
Feature flags:
- `os.fork` checks finalization before `allow_fork`, matching `os_fork_impl`.
- `_thread.start_new_thread` and `start_joinable_thread` reject an interpreter
without `allow_threads`.
Lib/concurrent/interpreters/_crossinterp.py: restore the stripped docstrings
and comments.
Assisted-by: Claude:claude-opus-5
* Correct the stateless checks and error shapes of _interpreters against CPython 3.14
verify_stateless_function follows _PyFunction_VerifyStateless: it rejects
non-dict builtins, a non-empty __defaults__, __kwdefaults__ or __closure__,
and code whose LOAD_GLOBAL names are held by the function's globals or
absent from its builtins.
code_returns_only_none follows _PyCode_ReturnsOnlyNone: generator,
coroutine and async-generator code is rejected up front, the instruction
walk skips inline caches and maps specialized and instrumented opcodes
back, and the LOAD_CONST preceding each RETURN_VALUE is compared against
the index of None in co_consts.
ExcInfo::capture keeps an empty exception message instead of dropping it,
and builds `formatted` as `module.qualname: msg`, leaving out the builtins
and __main__ modules.
_interpreters.call packs the callable through _PyFunction_GetXIData before
pickle and re-raises the stateless-check failure when both fail. A func,
args or kwargs that cannot be rebuilt in the target, and a result without
cross-interpreter data, now raise NotShareableError with the snapshot as
the cause rather than being returned as excinfo.
_interpreters.capture_exception() without an argument returns None.
pickle_loads and _PyFunction_GetXIData attach the underlying failure as
__cause__.
channel_send converts the object to cross-interpreter data after the
channel's `closing` check.
ChannelID rich comparison returns the result of comparing its id with the
other number instead of coercing that result to bool.
PyMemoryView_FromObjectAndFlags raises "memoryview: a bytes-like object is
required, not 'X'" for an object that is not a buffer.
Assisted-by: Claude:claude-opus-5
* Correct cross-interpreter data conversion and channel argument parsing
Bound shareable ints by isize, raising OverflowError("try sending as
bytes") outside that range and keeping it as the NotShareableError cause.
Report an unshareable object by its repr, and attach a failing conversion
as __cause__ of the NotShareableError raised for the object it was called
for, so each level of a nested tuple appears in the chain.
Guard each tuple item conversion with with_recursion("while sharing a
tuple").
Gate the memoryview getdata function on `_interpreters` having been
imported, and route channel_send_buffer through a memoryview so it uses
that function and the resolved fallback.
Create the cross-interpreter exception types from the module_exec of
either module that raises them, instead of only `_interpreters`.
parse_cid raises OverflowError("int too big to convert"); int_arg
reproduces the `i` converter's three overflow messages and is also used
while parsing channel_send arguments.
Add BASETYPE to _queue.Empty, and gate nt.execv/nt.execve on allow_exec.
Assisted-by: Claude:claude-opus-5
* Correct interpreter ID parsing and the channel_send defaults lookup
_PyInterpreterState_ObjectToID accepts any object with __index__, raises
OverflowError("int too big to convert") outside the int64 range, and
reports a negative ID with the repr of the original object.
channelsmod_send reads the channel's default unboundop and fallback only
when one of the two arguments is negative, so an explicit pair is
validated before the channel is looked up.
Assisted-by: Claude:claude-opus-5
* Add the _interpqueues module and concurrent.interpreters._queues
_interpqueues holds a process-wide queue table and exposes create,
destroy, list_all, put, get, bind, release, get_maxsize,
get_queue_defaults, is_full, get_count and _register_heap_types, raising
QueueError and QueueNotFoundError. QueueEmpty and QueueFull, which
subclass queue.Empty and queue.Full, are registered per interpreter by
concurrent.interpreters._queues.
Cross-interpreter data carries a queue as a refcounted queue ID that
binds when the data is captured and releases when it is dropped, and
is_shareable reports a registered Queue as shareable.
Queue and channel items owned by an interpreter are now cleared from
Interpreter::finalize, after module finalization, rather than from
destroy_owned_interpreter, so values sent by an atexit callback also
become unbound.
is_shareable gates memoryview on the same registration flag as the
getdata lookup.
Assisted-by: Claude:claude-opus-5
* Add the high-level concurrent.interpreters API
Interpreter, ExecutionFailed and the queue aliases, copied verbatim from
CPython 3.14.
Assisted-by: Claude:claude-opus-5
* Destroy leftover subinterpreters when the main interpreter finalizes
Interpreter::finalize now runs finalize_subinterpreters between the atexit
handlers and the finalizing flag: when the main interpreter still owns
subinterpreters it emits the RuntimeWarning "remaining subinterpreters;
close them with Interpreter.close()" and then finalizes each of them.
runtime::owned_interpreter_ids lists the runtime-owned interpreters.
Assisted-by: Claude:claude-opus-5
* Absolutize the script path in run_file
_Py_abspath and _PyPathConfig_ComputeSysPath0 arrive as abs_path and
script_sys_path0. run_file hands the absolutized path to get_importer
and to the runner, so __file__ and co_filename no longer stay relative,
and inserts the symlink-resolved script directory as sys.path[0]
instead of the argument's parent.
test_cmd_line_script.test_script_abspath no longer expects a failure.
Assisted-by: Claude:claude-opus-5
* Name types in error messages the way tp_name does
The object, number, sequence and mapping protocols, the
unsupported-operand helpers, and the type-specific messages fed from
them now read PyType::slot_name() where they read PyType::name(),
so a type declared with a module keeps it.
Message texts corrected along the way:
- PySequence_Size, PyMapping_Size, PySequence_GetItem and
PySequence_SetItem/DelItem split their merged wording in two, and
PyObject_SetItem/DelItem say "object".
- PyObject_GenericSetAttr reports a read-only attribute and the
missing __dict__.
- check_class drops the type name it appended.
- __int__ and __index__ drop the class prefix; __float__ keeps it.
- float(), complex(), round(), next(), str subscripting and list
subscripting take their own wording.
- str.join and bytes.join number the item they turn down and name what
they wanted, and report a non-iterable as "can only join an
iterable".
test_class.testObjectAttributeAccessErrorMessages,
string_tests.test_subscript and the test_descrtut doctest no longer
expect a failure.
Assisted-by: Claude:claude-opus-5
* Gate script_code's source compilation on the compiler feature
crossinterp::script_code called vm.compile unconditionally, which only
exists with the rustpython-compiler feature. Builds without it, such as
example_projects/barebone, now raise a TypeError instead of failing to
compile.
Assisted-by: Claude:claude-opus-5
* Skip test_pyinit_function_raises_exception
The test imports _testsinglephase in its body without a decorator
guarding it, and now that _interpreters exists requires_subinterpreters
no longer skips it.
Assisted-by: Claude:claude-opus-5
3421 lines
128 KiB
Python
Vendored
3421 lines
128 KiB
Python
Vendored
import builtins
|
|
import errno
|
|
import glob
|
|
import json
|
|
import importlib.util
|
|
from importlib._bootstrap_external import _get_sourcefile
|
|
from importlib.machinery import (
|
|
AppleFrameworkLoader,
|
|
BuiltinImporter,
|
|
ExtensionFileLoader,
|
|
FrozenImporter,
|
|
SourceFileLoader,
|
|
)
|
|
import marshal
|
|
import os
|
|
import py_compile
|
|
import random
|
|
import shutil
|
|
import stat
|
|
import subprocess
|
|
import sys
|
|
import textwrap
|
|
import threading
|
|
import time
|
|
import types
|
|
import unittest
|
|
from unittest import mock
|
|
import _imp
|
|
|
|
from test.support import os_helper
|
|
from test.support import (
|
|
STDLIB_DIR,
|
|
swap_attr,
|
|
swap_item,
|
|
cpython_only,
|
|
is_apple_mobile,
|
|
is_emscripten,
|
|
is_wasm32,
|
|
run_in_subinterp,
|
|
run_in_subinterp_with_config,
|
|
Py_TRACE_REFS,
|
|
requires_gil_enabled,
|
|
Py_GIL_DISABLED,
|
|
no_rerun,
|
|
force_not_colorized_test_class,
|
|
catch_unraisable_exception
|
|
)
|
|
from test.support.import_helper import (
|
|
forget, make_legacy_pyc, unlink, unload, ready_to_import,
|
|
DirsOnSysPath, CleanImport, import_module)
|
|
from test.support.os_helper import (
|
|
TESTFN, rmtree, temp_umask, TESTFN_UNENCODABLE)
|
|
from test.support import script_helper
|
|
from test.support import threading_helper
|
|
from test.test_importlib.util import uncache
|
|
from types import ModuleType
|
|
try:
|
|
import _testsinglephase
|
|
except ImportError:
|
|
_testsinglephase = None
|
|
try:
|
|
import _testmultiphase
|
|
except ImportError:
|
|
_testmultiphase = None
|
|
try:
|
|
import _interpreters
|
|
except ModuleNotFoundError:
|
|
_interpreters = None
|
|
try:
|
|
import _testinternalcapi
|
|
except ImportError:
|
|
_testinternalcapi = None
|
|
|
|
|
|
skip_if_dont_write_bytecode = unittest.skipIf(
|
|
sys.dont_write_bytecode,
|
|
"test meaningful only when writing bytecode")
|
|
|
|
|
|
def _require_loader(module, loader, skip):
|
|
if isinstance(module, str):
|
|
module = __import__(module)
|
|
|
|
MODULE_KINDS = {
|
|
BuiltinImporter: 'built-in',
|
|
ExtensionFileLoader: 'extension',
|
|
AppleFrameworkLoader: 'framework extension',
|
|
FrozenImporter: 'frozen',
|
|
SourceFileLoader: 'pure Python',
|
|
}
|
|
|
|
expected = loader
|
|
assert isinstance(expected, type), expected
|
|
expected = MODULE_KINDS[expected]
|
|
|
|
actual = module.__spec__.loader
|
|
if not isinstance(actual, type):
|
|
actual = type(actual)
|
|
actual = MODULE_KINDS[actual]
|
|
|
|
if actual != expected:
|
|
err = f'expected module to be {expected}, got {module.__spec__}'
|
|
if skip:
|
|
raise unittest.SkipTest(err)
|
|
raise Exception(err)
|
|
return module
|
|
|
|
def require_builtin(module, *, skip=False):
|
|
module = _require_loader(module, BuiltinImporter, skip)
|
|
assert module.__spec__.origin == 'built-in', module.__spec__
|
|
|
|
def require_extension(module, *, skip=False):
|
|
# Apple extensions must be distributed as frameworks. This requires
|
|
# a specialist loader.
|
|
if is_apple_mobile:
|
|
_require_loader(module, AppleFrameworkLoader, skip)
|
|
else:
|
|
_require_loader(module, ExtensionFileLoader, skip)
|
|
|
|
def require_frozen(module, *, skip=True):
|
|
module = _require_loader(module, FrozenImporter, skip)
|
|
assert module.__spec__.origin == 'frozen', module.__spec__
|
|
|
|
def require_pure_python(module, *, skip=False):
|
|
_require_loader(module, SourceFileLoader, skip)
|
|
|
|
def create_extension_loader(modname, filename):
|
|
# Apple extensions must be distributed as frameworks. This requires
|
|
# a specialist loader.
|
|
if is_apple_mobile:
|
|
return AppleFrameworkLoader(modname, filename)
|
|
else:
|
|
return ExtensionFileLoader(modname, filename)
|
|
|
|
def import_extension_from_file(modname, filename, *, put_in_sys_modules=True):
|
|
loader = create_extension_loader(modname, filename)
|
|
spec = importlib.util.spec_from_loader(modname, loader)
|
|
module = importlib.util.module_from_spec(spec)
|
|
loader.exec_module(module)
|
|
if put_in_sys_modules:
|
|
sys.modules[modname] = module
|
|
return module
|
|
|
|
|
|
def remove_files(name):
|
|
for f in (name + ".py",
|
|
name + ".pyc",
|
|
name + ".pyw",
|
|
name + "$py.class"):
|
|
unlink(f)
|
|
rmtree('__pycache__')
|
|
|
|
|
|
if _testsinglephase is not None:
|
|
def restore__testsinglephase(*, _orig=_testsinglephase):
|
|
# We started with the module imported and want to restore
|
|
# it to its nominal state.
|
|
sys.modules.pop('_testsinglephase', None)
|
|
_orig._clear_globals()
|
|
origin = _orig.__spec__.origin
|
|
_testinternalcapi.clear_extension('_testsinglephase', origin)
|
|
import _testsinglephase
|
|
|
|
|
|
def requires_singlephase_init(meth):
|
|
"""Decorator to skip if single-phase init modules are not supported."""
|
|
if not isinstance(meth, type):
|
|
def meth(self, _meth=meth):
|
|
try:
|
|
return _meth(self)
|
|
finally:
|
|
restore__testsinglephase()
|
|
meth = cpython_only(meth)
|
|
msg = "gh-117694: free-threaded build does not currently support single-phase init modules in sub-interpreters"
|
|
meth = requires_gil_enabled(msg)(meth)
|
|
return unittest.skipIf(_testsinglephase is None,
|
|
'test requires _testsinglephase module')(meth)
|
|
|
|
|
|
def requires_subinterpreters(meth):
|
|
"""Decorator to skip a test if subinterpreters are not supported."""
|
|
return unittest.skipIf(_interpreters is None,
|
|
'subinterpreters required')(meth)
|
|
|
|
|
|
class ModuleSnapshot(types.SimpleNamespace):
|
|
"""A representation of a module for testing.
|
|
|
|
Fields:
|
|
|
|
* id - the module's object ID
|
|
* module - the actual module or an adequate substitute
|
|
* __file__
|
|
* __spec__
|
|
* name
|
|
* origin
|
|
* ns - a copy (dict) of the module's __dict__ (or None)
|
|
* ns_id - the object ID of the module's __dict__
|
|
* cached - the sys.modules[mod.__spec__.name] entry (or None)
|
|
* cached_id - the object ID of the sys.modules entry (or None)
|
|
|
|
In cases where the value is not available (e.g. due to serialization),
|
|
the value will be None.
|
|
"""
|
|
_fields = tuple('id module ns ns_id cached cached_id'.split())
|
|
|
|
@classmethod
|
|
def from_module(cls, mod):
|
|
name = mod.__spec__.name
|
|
cached = sys.modules.get(name)
|
|
return cls(
|
|
id=id(mod),
|
|
module=mod,
|
|
ns=types.SimpleNamespace(**mod.__dict__),
|
|
ns_id=id(mod.__dict__),
|
|
cached=cached,
|
|
cached_id=id(cached),
|
|
)
|
|
|
|
SCRIPT = textwrap.dedent('''
|
|
{imports}
|
|
|
|
name = {name!r}
|
|
|
|
{prescript}
|
|
|
|
mod = {name}
|
|
|
|
{body}
|
|
|
|
{postscript}
|
|
''')
|
|
IMPORTS = textwrap.dedent('''
|
|
import sys
|
|
''').strip()
|
|
SCRIPT_BODY = textwrap.dedent('''
|
|
# Capture the snapshot data.
|
|
cached = sys.modules.get(name)
|
|
snapshot = dict(
|
|
id=id(mod),
|
|
module=dict(
|
|
__file__=mod.__file__,
|
|
__spec__=dict(
|
|
name=mod.__spec__.name,
|
|
origin=mod.__spec__.origin,
|
|
),
|
|
),
|
|
ns=None,
|
|
ns_id=id(mod.__dict__),
|
|
cached=None,
|
|
cached_id=id(cached) if cached else None,
|
|
)
|
|
''').strip()
|
|
CLEANUP_SCRIPT = textwrap.dedent('''
|
|
# Clean up the module.
|
|
sys.modules.pop(name, None)
|
|
''').strip()
|
|
|
|
@classmethod
|
|
def build_script(cls, name, *,
|
|
prescript=None,
|
|
import_first=False,
|
|
postscript=None,
|
|
postcleanup=False,
|
|
):
|
|
if postcleanup is True:
|
|
postcleanup = cls.CLEANUP_SCRIPT
|
|
elif isinstance(postcleanup, str):
|
|
postcleanup = textwrap.dedent(postcleanup).strip()
|
|
postcleanup = cls.CLEANUP_SCRIPT + os.linesep + postcleanup
|
|
else:
|
|
postcleanup = ''
|
|
prescript = textwrap.dedent(prescript).strip() if prescript else ''
|
|
postscript = textwrap.dedent(postscript).strip() if postscript else ''
|
|
|
|
if postcleanup:
|
|
if postscript:
|
|
postscript = postscript + os.linesep * 2 + postcleanup
|
|
else:
|
|
postscript = postcleanup
|
|
|
|
if import_first:
|
|
prescript += textwrap.dedent(f'''
|
|
|
|
# Now import the module.
|
|
assert name not in sys.modules
|
|
import {name}''')
|
|
|
|
return cls.SCRIPT.format(
|
|
imports=cls.IMPORTS.strip(),
|
|
name=name,
|
|
prescript=prescript.strip(),
|
|
body=cls.SCRIPT_BODY.strip(),
|
|
postscript=postscript,
|
|
)
|
|
|
|
@classmethod
|
|
def parse(cls, text):
|
|
raw = json.loads(text)
|
|
mod = raw['module']
|
|
mod['__spec__'] = types.SimpleNamespace(**mod['__spec__'])
|
|
raw['module'] = types.SimpleNamespace(**mod)
|
|
return cls(**raw)
|
|
|
|
@classmethod
|
|
def from_subinterp(cls, name, interpid=None, *, pipe=None, **script_kwds):
|
|
if pipe is not None:
|
|
return cls._from_subinterp(name, interpid, pipe, script_kwds)
|
|
pipe = os.pipe()
|
|
try:
|
|
return cls._from_subinterp(name, interpid, pipe, script_kwds)
|
|
finally:
|
|
r, w = pipe
|
|
os.close(r)
|
|
os.close(w)
|
|
|
|
@classmethod
|
|
def _from_subinterp(cls, name, interpid, pipe, script_kwargs):
|
|
r, w = pipe
|
|
|
|
# Build the script.
|
|
postscript = textwrap.dedent(f'''
|
|
# Send the result over the pipe.
|
|
import json
|
|
import os
|
|
os.write({w}, json.dumps(snapshot).encode())
|
|
|
|
''')
|
|
_postscript = script_kwargs.get('postscript')
|
|
if _postscript:
|
|
_postscript = textwrap.dedent(_postscript).lstrip()
|
|
postscript += _postscript
|
|
script_kwargs['postscript'] = postscript.strip()
|
|
script = cls.build_script(name, **script_kwargs)
|
|
|
|
# Run the script.
|
|
if interpid is None:
|
|
ret = run_in_subinterp(script)
|
|
if ret != 0:
|
|
raise AssertionError(f'{ret} != 0')
|
|
else:
|
|
_interpreters.run_string(interpid, script)
|
|
|
|
# Parse the results.
|
|
text = os.read(r, 1000)
|
|
return cls.parse(text.decode())
|
|
|
|
|
|
@force_not_colorized_test_class
|
|
class ImportTests(unittest.TestCase):
|
|
|
|
def setUp(self):
|
|
remove_files(TESTFN)
|
|
importlib.invalidate_caches()
|
|
|
|
def tearDown(self):
|
|
unload(TESTFN)
|
|
|
|
def test_import_raises_ModuleNotFoundError(self):
|
|
with self.assertRaises(ModuleNotFoundError):
|
|
import something_that_should_not_exist_anywhere
|
|
|
|
def test_import_null_byte_in_name_raises_ModuleNotFoundError(self):
|
|
# gh-150633: module names containing null bytes should not
|
|
# lead to duplicates in sys.modules
|
|
before = set(sys.modules.keys())
|
|
with self.assertRaises(ModuleNotFoundError):
|
|
__import__('zipimport\x00junk')
|
|
|
|
self.assertEqual(set(sys.modules.keys()), before)
|
|
|
|
def test_from_import_missing_module_raises_ModuleNotFoundError(self):
|
|
with self.assertRaises(ModuleNotFoundError):
|
|
from something_that_should_not_exist_anywhere import blah
|
|
|
|
def test_from_import_missing_attr_raises_ImportError(self):
|
|
with self.assertRaises(ImportError):
|
|
from importlib import something_that_should_not_exist_anywhere
|
|
|
|
def test_from_import_missing_attr_has_name_and_path(self):
|
|
with CleanImport('os'):
|
|
import os
|
|
with self.assertRaises(ImportError) as cm:
|
|
from os import i_dont_exist
|
|
self.assertEqual(cm.exception.name, 'os')
|
|
self.assertEqual(cm.exception.path, os.__file__)
|
|
self.assertRegex(str(cm.exception), r"cannot import name 'i_dont_exist' from 'os' \(.*os.py\)")
|
|
|
|
@cpython_only
|
|
def test_from_import_missing_attr_has_name_and_so_path(self):
|
|
_testcapi = import_module("_testcapi")
|
|
with self.assertRaises(ImportError) as cm:
|
|
from _testcapi import i_dont_exist
|
|
self.assertEqual(cm.exception.name, '_testcapi')
|
|
if hasattr(_testcapi, "__file__"):
|
|
# The path on the exception is strictly the spec origin, not the
|
|
# module's __file__. For most cases, these are the same; but on
|
|
# iOS, the Framework relocation process results in the exception
|
|
# being raised from the spec location.
|
|
self.assertEqual(cm.exception.path, _testcapi.__spec__.origin)
|
|
self.assertRegex(
|
|
str(cm.exception),
|
|
r"cannot import name 'i_dont_exist' from '_testcapi' \(.*(\.(so|pyd))?\)"
|
|
)
|
|
else:
|
|
self.assertEqual(
|
|
str(cm.exception),
|
|
"cannot import name 'i_dont_exist' from '_testcapi' (unknown location)"
|
|
)
|
|
|
|
def test_from_import_missing_attr_has_name(self):
|
|
with self.assertRaises(ImportError) as cm:
|
|
# _warning has no path as it's a built-in module.
|
|
from _warning import i_dont_exist
|
|
self.assertEqual(cm.exception.name, '_warning')
|
|
self.assertIsNone(cm.exception.path)
|
|
|
|
def test_from_import_missing_attr_path_is_canonical(self):
|
|
with self.assertRaises(ImportError) as cm:
|
|
from os.path import i_dont_exist
|
|
self.assertIn(cm.exception.name, {'posixpath', 'ntpath'})
|
|
self.assertIsNotNone(cm.exception)
|
|
|
|
def test_from_import_star_invalid_type(self):
|
|
import re
|
|
with ready_to_import() as (name, path):
|
|
with open(path, 'w', encoding='utf-8') as f:
|
|
f.write("__all__ = [b'invalid_type']")
|
|
globals = {}
|
|
with self.assertRaisesRegex(
|
|
TypeError, f"{re.escape(name)}\\.__all__ must be str"
|
|
):
|
|
exec(f"from {name} import *", globals)
|
|
self.assertNotIn(b"invalid_type", globals)
|
|
with ready_to_import() as (name, path):
|
|
with open(path, 'w', encoding='utf-8') as f:
|
|
f.write("globals()[b'invalid_type'] = object()")
|
|
globals = {}
|
|
with self.assertRaisesRegex(
|
|
TypeError, f"{re.escape(name)}\\.__dict__ must be str"
|
|
):
|
|
exec(f"from {name} import *", globals)
|
|
self.assertNotIn(b"invalid_type", globals)
|
|
|
|
def test_case_sensitivity(self):
|
|
# Brief digression to test that import is case-sensitive: if we got
|
|
# this far, we know for sure that "random" exists.
|
|
with self.assertRaises(ImportError):
|
|
import RAnDoM
|
|
|
|
def test_double_const(self):
|
|
# Importing double_const checks that float constants
|
|
# serialized by marshal as PYC files don't lose precision
|
|
# (SF bug 422177).
|
|
from test.test_import.data import double_const
|
|
unload('test.test_import.data.double_const')
|
|
from test.test_import.data import double_const # noqa: F811
|
|
|
|
def test_import(self):
|
|
def test_with_extension(ext):
|
|
# The extension is normally ".py", perhaps ".pyw".
|
|
source = TESTFN + ext
|
|
pyc = TESTFN + ".pyc"
|
|
|
|
with open(source, "w", encoding='utf-8') as f:
|
|
print("# This tests Python's ability to import a",
|
|
ext, "file.", file=f)
|
|
a = random.randrange(1000)
|
|
b = random.randrange(1000)
|
|
print("a =", a, file=f)
|
|
print("b =", b, file=f)
|
|
|
|
if TESTFN in sys.modules:
|
|
del sys.modules[TESTFN]
|
|
importlib.invalidate_caches()
|
|
try:
|
|
try:
|
|
mod = __import__(TESTFN)
|
|
except ImportError as err:
|
|
self.fail("import from %s failed: %s" % (ext, err))
|
|
|
|
self.assertEqual(mod.a, a,
|
|
"module loaded (%s) but contents invalid" % mod)
|
|
self.assertEqual(mod.b, b,
|
|
"module loaded (%s) but contents invalid" % mod)
|
|
finally:
|
|
forget(TESTFN)
|
|
unlink(source)
|
|
unlink(pyc)
|
|
|
|
sys.path.insert(0, os.curdir)
|
|
try:
|
|
test_with_extension(".py")
|
|
if sys.platform.startswith("win"):
|
|
for ext in [".PY", ".Py", ".pY", ".pyw", ".PYW", ".pYw"]:
|
|
test_with_extension(ext)
|
|
finally:
|
|
del sys.path[0]
|
|
|
|
def test_module_with_large_stack(self, module='longlist'):
|
|
# Regression test for http://bugs.python.org/issue561858.
|
|
filename = module + '.py'
|
|
|
|
# Create a file with a list of 65000 elements.
|
|
with open(filename, 'w', encoding='utf-8') as f:
|
|
f.write('d = [\n')
|
|
for i in range(65000):
|
|
f.write('"",\n')
|
|
f.write(']')
|
|
|
|
try:
|
|
# Compile & remove .py file; we only need .pyc.
|
|
# Bytecode must be relocated from the PEP 3147 bytecode-only location.
|
|
py_compile.compile(filename)
|
|
finally:
|
|
unlink(filename)
|
|
|
|
# Need to be able to load from current dir.
|
|
sys.path.append('')
|
|
importlib.invalidate_caches()
|
|
|
|
namespace = {}
|
|
try:
|
|
make_legacy_pyc(filename)
|
|
# This used to crash.
|
|
exec('import ' + module, None, namespace)
|
|
finally:
|
|
# Cleanup.
|
|
del sys.path[-1]
|
|
unlink(filename + 'c')
|
|
unlink(filename + 'o')
|
|
|
|
# Remove references to the module (unload the module)
|
|
namespace.clear()
|
|
try:
|
|
del sys.modules[module]
|
|
except KeyError:
|
|
pass
|
|
|
|
def test_failing_import_sticks(self):
|
|
source = TESTFN + ".py"
|
|
with open(source, "w", encoding='utf-8') as f:
|
|
print("a = 1/0", file=f)
|
|
|
|
# New in 2.4, we shouldn't be able to import that no matter how often
|
|
# we try.
|
|
sys.path.insert(0, os.curdir)
|
|
importlib.invalidate_caches()
|
|
if TESTFN in sys.modules:
|
|
del sys.modules[TESTFN]
|
|
try:
|
|
for i in [1, 2, 3]:
|
|
self.assertRaises(ZeroDivisionError, __import__, TESTFN)
|
|
self.assertNotIn(TESTFN, sys.modules,
|
|
"damaged module in sys.modules on %i try" % i)
|
|
finally:
|
|
del sys.path[0]
|
|
remove_files(TESTFN)
|
|
|
|
def test_import_name_binding(self):
|
|
# import x.y.z binds x in the current namespace
|
|
import test as x
|
|
import test.support
|
|
self.assertIs(x, test, x.__name__)
|
|
self.assertHasAttr(test.support, "__file__")
|
|
|
|
# import x.y.z as w binds z as w
|
|
import test.support as y
|
|
self.assertIs(y, test.support, y.__name__)
|
|
|
|
def test_issue31286(self):
|
|
# import in a 'finally' block resulted in SystemError
|
|
try:
|
|
x = ...
|
|
finally:
|
|
import test.support.script_helper as x
|
|
|
|
# import in a 'while' loop resulted in stack overflow
|
|
i = 0
|
|
while i < 10:
|
|
import test.support.script_helper as x
|
|
i += 1
|
|
|
|
# import in a 'for' loop resulted in segmentation fault
|
|
for i in range(2):
|
|
import test.support.script_helper as x # noqa: F811
|
|
|
|
def test_failing_reload(self):
|
|
# A failing reload should leave the module object in sys.modules.
|
|
source = TESTFN + os.extsep + "py"
|
|
with open(source, "w", encoding='utf-8') as f:
|
|
f.write("a = 1\nb=2\n")
|
|
|
|
sys.path.insert(0, os.curdir)
|
|
try:
|
|
mod = __import__(TESTFN)
|
|
self.assertIn(TESTFN, sys.modules)
|
|
self.assertEqual(mod.a, 1, "module has wrong attribute values")
|
|
self.assertEqual(mod.b, 2, "module has wrong attribute values")
|
|
|
|
# On WinXP, just replacing the .py file wasn't enough to
|
|
# convince reload() to reparse it. Maybe the timestamp didn't
|
|
# move enough. We force it to get reparsed by removing the
|
|
# compiled file too.
|
|
remove_files(TESTFN)
|
|
|
|
# Now damage the module.
|
|
with open(source, "w", encoding='utf-8') as f:
|
|
f.write("a = 10\nb=20//0\n")
|
|
|
|
self.assertRaises(ZeroDivisionError, importlib.reload, mod)
|
|
# But we still expect the module to be in sys.modules.
|
|
mod = sys.modules.get(TESTFN)
|
|
self.assertIsNotNone(mod, "expected module to be in sys.modules")
|
|
|
|
# We should have replaced a w/ 10, but the old b value should
|
|
# stick.
|
|
self.assertEqual(mod.a, 10, "module has wrong attribute values")
|
|
self.assertEqual(mod.b, 2, "module has wrong attribute values")
|
|
|
|
finally:
|
|
del sys.path[0]
|
|
remove_files(TESTFN)
|
|
unload(TESTFN)
|
|
|
|
@skip_if_dont_write_bytecode
|
|
def test_file_to_source(self):
|
|
# check if __file__ points to the source file where available
|
|
source = TESTFN + ".py"
|
|
with open(source, "w", encoding='utf-8') as f:
|
|
f.write("test = None\n")
|
|
|
|
sys.path.insert(0, os.curdir)
|
|
try:
|
|
mod = __import__(TESTFN)
|
|
self.assertEndsWith(mod.__file__, '.py')
|
|
os.remove(source)
|
|
del sys.modules[TESTFN]
|
|
make_legacy_pyc(source)
|
|
importlib.invalidate_caches()
|
|
mod = __import__(TESTFN)
|
|
base, ext = os.path.splitext(mod.__file__)
|
|
self.assertEqual(ext, '.pyc')
|
|
finally:
|
|
del sys.path[0]
|
|
remove_files(TESTFN)
|
|
if TESTFN in sys.modules:
|
|
del sys.modules[TESTFN]
|
|
|
|
def test_import_by_filename(self):
|
|
path = os.path.abspath(TESTFN)
|
|
encoding = sys.getfilesystemencoding()
|
|
try:
|
|
path.encode(encoding)
|
|
except UnicodeEncodeError:
|
|
self.skipTest('path is not encodable to {}'.format(encoding))
|
|
with self.assertRaises(ImportError) as c:
|
|
__import__(path)
|
|
|
|
def test_import_in_del_does_not_crash(self):
|
|
# Issue 4236
|
|
testfn = script_helper.make_script('', TESTFN, textwrap.dedent("""\
|
|
import sys
|
|
class C:
|
|
def __del__(self):
|
|
import importlib
|
|
sys.argv.insert(0, C())
|
|
"""))
|
|
script_helper.assert_python_ok(testfn)
|
|
|
|
@skip_if_dont_write_bytecode
|
|
def test_timestamp_overflow(self):
|
|
# A modification timestamp larger than 2**32 should not be a problem
|
|
# when importing a module (issue #11235).
|
|
sys.path.insert(0, os.curdir)
|
|
try:
|
|
source = TESTFN + ".py"
|
|
compiled = importlib.util.cache_from_source(source)
|
|
with open(source, 'w', encoding='utf-8') as f:
|
|
pass
|
|
try:
|
|
os.utime(source, (2 ** 33 - 5, 2 ** 33 - 5))
|
|
except OverflowError:
|
|
self.skipTest("cannot set modification time to large integer")
|
|
except OSError as e:
|
|
if e.errno not in (getattr(errno, 'EOVERFLOW', None),
|
|
getattr(errno, 'EINVAL', None)):
|
|
raise
|
|
self.skipTest("cannot set modification time to large integer ({})".format(e))
|
|
__import__(TESTFN)
|
|
# The pyc file was created.
|
|
os.stat(compiled)
|
|
finally:
|
|
del sys.path[0]
|
|
remove_files(TESTFN)
|
|
|
|
def test_bogus_fromlist(self):
|
|
try:
|
|
__import__('http', fromlist=['blah'])
|
|
except ImportError:
|
|
self.fail("fromlist must allow bogus names")
|
|
|
|
@cpython_only
|
|
def test_delete_builtins_import(self):
|
|
args = ["-c", "del __builtins__.__import__; import os"]
|
|
popen = script_helper.spawn_python(*args)
|
|
stdout, stderr = popen.communicate()
|
|
self.assertIn(b"ImportError", stdout)
|
|
|
|
def test_from_import_message_for_nonexistent_module(self):
|
|
with self.assertRaisesRegex(ImportError, "^No module named 'bogus'"):
|
|
from bogus import foo
|
|
|
|
def test_from_import_message_for_existing_module(self):
|
|
with self.assertRaisesRegex(ImportError, "^cannot import name 'bogus'"):
|
|
from re import bogus
|
|
|
|
def test_from_import_AttributeError(self):
|
|
# Issue #24492: trying to import an attribute that raises an
|
|
# AttributeError should lead to an ImportError.
|
|
class AlwaysAttributeError:
|
|
def __getattr__(self, _):
|
|
raise AttributeError
|
|
|
|
module_name = 'test_from_import_AttributeError'
|
|
self.addCleanup(unload, module_name)
|
|
sys.modules[module_name] = AlwaysAttributeError()
|
|
with self.assertRaises(ImportError) as cm:
|
|
from test_from_import_AttributeError import does_not_exist
|
|
|
|
self.assertEqual(str(cm.exception),
|
|
"cannot import name 'does_not_exist' from '<unknown module name>' (unknown location)")
|
|
|
|
@cpython_only
|
|
def test_issue31492(self):
|
|
# There shouldn't be an assertion failure in case of failing to import
|
|
# from a module with a bad __name__ attribute, or in case of failing
|
|
# to access an attribute of such a module.
|
|
with swap_attr(os, '__name__', None):
|
|
with self.assertRaises(ImportError):
|
|
from os import does_not_exist
|
|
|
|
with self.assertRaises(AttributeError):
|
|
os.does_not_exist
|
|
|
|
@threading_helper.requires_working_threading()
|
|
def test_concurrency(self):
|
|
# bpo 38091: this is a hack to slow down the code that calls
|
|
# has_deadlock(); the logic was itself sometimes deadlocking.
|
|
def delay_has_deadlock(frame, event, arg):
|
|
if event == 'call' and frame.f_code.co_name == 'has_deadlock':
|
|
time.sleep(0.1)
|
|
|
|
sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'data'))
|
|
try:
|
|
exc = None
|
|
def run():
|
|
sys.settrace(delay_has_deadlock)
|
|
event.wait()
|
|
try:
|
|
import package
|
|
except BaseException as e:
|
|
nonlocal exc
|
|
exc = e
|
|
sys.settrace(None)
|
|
|
|
for i in range(10):
|
|
event = threading.Event()
|
|
threads = [threading.Thread(target=run) for x in range(2)]
|
|
try:
|
|
with threading_helper.start_threads(threads, event.set):
|
|
time.sleep(0)
|
|
finally:
|
|
sys.modules.pop('package', None)
|
|
sys.modules.pop('package.submodule', None)
|
|
if exc is not None:
|
|
raise exc
|
|
finally:
|
|
del sys.path[0]
|
|
|
|
@unittest.expectedFailure # TODO: RUSTPYTHON; no C extension support
|
|
@unittest.skipUnless(sys.platform == "win32", "Windows-specific")
|
|
def test_dll_dependency_import(self):
|
|
from _winapi import GetModuleFileName
|
|
dllname = GetModuleFileName(sys.dllhandle)
|
|
pydname = importlib.util.find_spec("_sqlite3").origin
|
|
depname = os.path.join(
|
|
os.path.dirname(pydname),
|
|
"sqlite3{}.dll".format("_d" if "_d" in pydname else ""))
|
|
|
|
with os_helper.temp_dir() as tmp:
|
|
tmp2 = os.path.join(tmp, "DLLs")
|
|
os.mkdir(tmp2)
|
|
|
|
pyexe = os.path.join(tmp, os.path.basename(sys.executable))
|
|
shutil.copy(sys.executable, pyexe)
|
|
shutil.copy(dllname, tmp)
|
|
for f in glob.glob(os.path.join(glob.escape(sys.prefix), "vcruntime*.dll")):
|
|
shutil.copy(f, tmp)
|
|
|
|
shutil.copy(pydname, tmp2)
|
|
|
|
env = None
|
|
env = {k.upper(): os.environ[k] for k in os.environ}
|
|
env["PYTHONPATH"] = tmp2 + ";" + STDLIB_DIR
|
|
|
|
# Test 1: import with added DLL directory
|
|
subprocess.check_call([
|
|
pyexe, "-Sc", ";".join([
|
|
"import os",
|
|
"p = os.add_dll_directory({!r})".format(
|
|
os.path.dirname(depname)),
|
|
"import _sqlite3",
|
|
"p.close"
|
|
])],
|
|
stderr=subprocess.STDOUT,
|
|
env=env,
|
|
cwd=os.path.dirname(pyexe))
|
|
|
|
# Test 2: import with DLL adjacent to PYD
|
|
shutil.copy(depname, tmp2)
|
|
subprocess.check_call([pyexe, "-Sc", "import _sqlite3"],
|
|
stderr=subprocess.STDOUT,
|
|
env=env,
|
|
cwd=os.path.dirname(pyexe))
|
|
|
|
def test_issue105979(self):
|
|
# this used to crash
|
|
with self.assertRaises(ImportError) as cm:
|
|
_imp.get_frozen_object("x", b"6\'\xd5Cu\x12")
|
|
self.assertIn("Frozen object named 'x' is invalid",
|
|
str(cm.exception))
|
|
|
|
def test_frozen_module_from_import_error(self):
|
|
with self.assertRaises(ImportError) as cm:
|
|
from os import this_will_never_exist
|
|
self.assertIn(
|
|
f"cannot import name 'this_will_never_exist' from 'os' ({os.__file__})",
|
|
str(cm.exception),
|
|
)
|
|
with self.assertRaises(ImportError) as cm:
|
|
from sys import this_will_never_exist
|
|
self.assertIn(
|
|
"cannot import name 'this_will_never_exist' from 'sys' (unknown location)",
|
|
str(cm.exception),
|
|
)
|
|
|
|
scripts = [
|
|
"""
|
|
import os
|
|
os.__spec__.has_location = False
|
|
os.__file__ = []
|
|
from os import this_will_never_exist
|
|
""",
|
|
"""
|
|
import os
|
|
os.__spec__.has_location = False
|
|
del os.__file__
|
|
from os import this_will_never_exist
|
|
""",
|
|
"""
|
|
import os
|
|
os.__spec__.origin = []
|
|
os.__file__ = []
|
|
from os import this_will_never_exist
|
|
"""
|
|
]
|
|
for script in scripts:
|
|
with self.subTest(script=script):
|
|
expected_error = (
|
|
b"cannot import name 'this_will_never_exist' "
|
|
b"from 'os' (unknown location)"
|
|
)
|
|
popen = script_helper.spawn_python("-c", script)
|
|
stdout, stderr = popen.communicate()
|
|
self.assertIn(expected_error, stdout)
|
|
|
|
def test_non_module_from_import_error(self):
|
|
prefix = """
|
|
import sys
|
|
class NotAModule: ...
|
|
nm = NotAModule()
|
|
nm.symbol = 123
|
|
sys.modules["not_a_module"] = nm
|
|
from not_a_module import symbol
|
|
"""
|
|
scripts = [
|
|
prefix + "from not_a_module import missing_symbol",
|
|
prefix + "nm.__spec__ = []\nfrom not_a_module import missing_symbol",
|
|
]
|
|
for script in scripts:
|
|
with self.subTest(script=script):
|
|
expected_error = (
|
|
b"ImportError: cannot import name 'missing_symbol' from "
|
|
b"'<unknown module name>' (unknown location)"
|
|
)
|
|
popen = script_helper.spawn_python("-c", script)
|
|
stdout, stderr = popen.communicate()
|
|
self.assertIn(expected_error, stdout)
|
|
|
|
def test_script_shadowing_stdlib(self):
|
|
script_errors = [
|
|
(
|
|
"import fractions\nfractions.Fraction",
|
|
rb"AttributeError: module 'fractions' has no attribute 'Fraction'"
|
|
),
|
|
(
|
|
"from fractions import Fraction",
|
|
rb"ImportError: cannot import name 'Fraction' from 'fractions'"
|
|
)
|
|
]
|
|
for script, error in script_errors:
|
|
with self.subTest(script=script), os_helper.temp_dir() as tmp:
|
|
with open(os.path.join(tmp, "fractions.py"), "w", encoding='utf-8') as f:
|
|
f.write(script)
|
|
|
|
expected_error = error + (
|
|
rb" \(consider renaming '.*fractions.py' since it has the "
|
|
rb"same name as the standard library module named 'fractions' "
|
|
rb"and prevents importing that standard library module\)"
|
|
)
|
|
|
|
popen = script_helper.spawn_python(os.path.join(tmp, "fractions.py"), cwd=tmp)
|
|
stdout, stderr = popen.communicate()
|
|
self.assertRegex(stdout, expected_error)
|
|
|
|
popen = script_helper.spawn_python('-m', 'fractions', cwd=tmp)
|
|
stdout, stderr = popen.communicate()
|
|
self.assertRegex(stdout, expected_error)
|
|
|
|
popen = script_helper.spawn_python('-c', 'import fractions', cwd=tmp)
|
|
stdout, stderr = popen.communicate()
|
|
self.assertRegex(stdout, expected_error)
|
|
|
|
# and there's no error at all when using -P
|
|
popen = script_helper.spawn_python('-P', 'fractions.py', cwd=tmp)
|
|
stdout, stderr = popen.communicate()
|
|
self.assertEqual(stdout, b'')
|
|
|
|
tmp_child = os.path.join(tmp, "child")
|
|
os.mkdir(tmp_child)
|
|
|
|
# test the logic with different cwd
|
|
popen = script_helper.spawn_python(os.path.join(tmp, "fractions.py"), cwd=tmp_child)
|
|
stdout, stderr = popen.communicate()
|
|
self.assertRegex(stdout, expected_error)
|
|
|
|
popen = script_helper.spawn_python('-m', 'fractions', cwd=tmp_child)
|
|
stdout, stderr = popen.communicate()
|
|
self.assertEqual(stdout, b'') # no error
|
|
|
|
popen = script_helper.spawn_python('-c', 'import fractions', cwd=tmp_child)
|
|
stdout, stderr = popen.communicate()
|
|
self.assertEqual(stdout, b'') # no error
|
|
|
|
def test_package_shadowing_stdlib_module(self):
|
|
script_errors = [
|
|
(
|
|
"fractions.Fraction",
|
|
rb"AttributeError: module 'fractions' has no attribute 'Fraction'"
|
|
),
|
|
(
|
|
"from fractions import Fraction",
|
|
rb"ImportError: cannot import name 'Fraction' from 'fractions'"
|
|
)
|
|
]
|
|
for script, error in script_errors:
|
|
with self.subTest(script=script), os_helper.temp_dir() as tmp:
|
|
os.mkdir(os.path.join(tmp, "fractions"))
|
|
with open(
|
|
os.path.join(tmp, "fractions", "__init__.py"), "w", encoding='utf-8'
|
|
) as f:
|
|
f.write("shadowing_module = True")
|
|
with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
|
|
f.write("import fractions; fractions.shadowing_module\n")
|
|
f.write(script)
|
|
|
|
expected_error = error + (
|
|
rb" \(consider renaming '.*[\\/]fractions[\\/]+__init__.py' since it has the "
|
|
rb"same name as the standard library module named 'fractions' "
|
|
rb"and prevents importing that standard library module\)"
|
|
)
|
|
|
|
popen = script_helper.spawn_python(os.path.join(tmp, "main.py"), cwd=tmp)
|
|
stdout, stderr = popen.communicate()
|
|
self.assertRegex(stdout, expected_error)
|
|
|
|
popen = script_helper.spawn_python('-m', 'main', cwd=tmp)
|
|
stdout, stderr = popen.communicate()
|
|
self.assertRegex(stdout, expected_error)
|
|
|
|
# and there's no shadowing at all when using -P
|
|
popen = script_helper.spawn_python('-P', 'main.py', cwd=tmp)
|
|
stdout, stderr = popen.communicate()
|
|
self.assertRegex(stdout, b"module 'fractions' has no attribute 'shadowing_module'")
|
|
|
|
def test_script_shadowing_third_party(self):
|
|
script_errors = [
|
|
(
|
|
"import numpy\nnumpy.array",
|
|
rb"AttributeError: module 'numpy' has no attribute 'array'"
|
|
),
|
|
(
|
|
"from numpy import array",
|
|
rb"ImportError: cannot import name 'array' from 'numpy'"
|
|
)
|
|
]
|
|
for script, error in script_errors:
|
|
with self.subTest(script=script), os_helper.temp_dir() as tmp:
|
|
with open(os.path.join(tmp, "numpy.py"), "w", encoding='utf-8') as f:
|
|
f.write(script)
|
|
|
|
expected_error = error + (
|
|
rb" \(consider renaming '.*numpy.py' if it has the "
|
|
rb"same name as a library you intended to import\)\s+\z"
|
|
)
|
|
|
|
popen = script_helper.spawn_python(os.path.join(tmp, "numpy.py"))
|
|
stdout, stderr = popen.communicate()
|
|
self.assertRegex(stdout, expected_error)
|
|
|
|
popen = script_helper.spawn_python('-m', 'numpy', cwd=tmp)
|
|
stdout, stderr = popen.communicate()
|
|
self.assertRegex(stdout, expected_error)
|
|
|
|
popen = script_helper.spawn_python('-c', 'import numpy', cwd=tmp)
|
|
stdout, stderr = popen.communicate()
|
|
self.assertRegex(stdout, expected_error)
|
|
|
|
def test_script_maybe_not_shadowing_third_party(self):
|
|
with os_helper.temp_dir() as tmp:
|
|
with open(os.path.join(tmp, "numpy.py"), "w", encoding='utf-8') as f:
|
|
f.write("this_script_does_not_attempt_to_import_numpy = True")
|
|
|
|
expected_error = (
|
|
rb"AttributeError: module 'numpy' has no attribute 'attr'\s+\z"
|
|
)
|
|
popen = script_helper.spawn_python('-c', 'import numpy; numpy.attr', cwd=tmp)
|
|
stdout, stderr = popen.communicate()
|
|
self.assertRegex(stdout, expected_error)
|
|
|
|
expected_error = (
|
|
rb"ImportError: cannot import name 'attr' from 'numpy' \(.*\)\s+\z"
|
|
)
|
|
popen = script_helper.spawn_python('-c', 'from numpy import attr', cwd=tmp)
|
|
stdout, stderr = popen.communicate()
|
|
self.assertRegex(stdout, expected_error)
|
|
|
|
def test_script_shadowing_stdlib_edge_cases(self):
|
|
with os_helper.temp_dir() as tmp:
|
|
with open(os.path.join(tmp, "fractions.py"), "w", encoding='utf-8') as f:
|
|
f.write("shadowing_module = True")
|
|
|
|
# Unhashable str subclass
|
|
with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
|
|
f.write("""
|
|
import fractions
|
|
fractions.shadowing_module
|
|
class substr(str):
|
|
__hash__ = None
|
|
fractions.__name__ = substr('fractions')
|
|
try:
|
|
fractions.Fraction
|
|
except TypeError as e:
|
|
print(str(e))
|
|
""")
|
|
popen = script_helper.spawn_python("main.py", cwd=tmp)
|
|
stdout, stderr = popen.communicate()
|
|
self.assertIn(b"unhashable type: 'substr'", stdout.rstrip())
|
|
|
|
with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
|
|
f.write("""
|
|
import fractions
|
|
fractions.shadowing_module
|
|
class substr(str):
|
|
__hash__ = None
|
|
fractions.__name__ = substr('fractions')
|
|
try:
|
|
from fractions import Fraction
|
|
except TypeError as e:
|
|
print(str(e))
|
|
""")
|
|
|
|
popen = script_helper.spawn_python("main.py", cwd=tmp)
|
|
stdout, stderr = popen.communicate()
|
|
self.assertIn(b"unhashable type: 'substr'", stdout.rstrip())
|
|
|
|
# Various issues with sys module
|
|
with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
|
|
f.write("""
|
|
import fractions
|
|
fractions.shadowing_module
|
|
|
|
import sys
|
|
sys.stdlib_module_names = None
|
|
try:
|
|
fractions.Fraction
|
|
except AttributeError as e:
|
|
print(str(e))
|
|
|
|
del sys.stdlib_module_names
|
|
try:
|
|
fractions.Fraction
|
|
except AttributeError as e:
|
|
print(str(e))
|
|
|
|
sys.path = [0]
|
|
try:
|
|
fractions.Fraction
|
|
except AttributeError as e:
|
|
print(str(e))
|
|
""")
|
|
popen = script_helper.spawn_python("main.py", cwd=tmp)
|
|
stdout, stderr = popen.communicate()
|
|
lines = stdout.splitlines()
|
|
self.assertEqual(len(lines), 3)
|
|
for line in lines:
|
|
self.assertEqual(line, b"module 'fractions' has no attribute 'Fraction'")
|
|
|
|
with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
|
|
f.write("""
|
|
import fractions
|
|
fractions.shadowing_module
|
|
|
|
import sys
|
|
sys.stdlib_module_names = None
|
|
try:
|
|
from fractions import Fraction
|
|
except ImportError as e:
|
|
print(str(e))
|
|
|
|
del sys.stdlib_module_names
|
|
try:
|
|
from fractions import Fraction
|
|
except ImportError as e:
|
|
print(str(e))
|
|
|
|
sys.path = [0]
|
|
try:
|
|
from fractions import Fraction
|
|
except ImportError as e:
|
|
print(str(e))
|
|
""")
|
|
popen = script_helper.spawn_python("main.py", cwd=tmp)
|
|
stdout, stderr = popen.communicate()
|
|
lines = stdout.splitlines()
|
|
self.assertEqual(len(lines), 3)
|
|
for line in lines:
|
|
self.assertRegex(line, rb"cannot import name 'Fraction' from 'fractions' \(.*\)")
|
|
|
|
# Various issues with origin
|
|
with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
|
|
f.write("""
|
|
import fractions
|
|
fractions.shadowing_module
|
|
del fractions.__spec__.origin
|
|
try:
|
|
fractions.Fraction
|
|
except AttributeError as e:
|
|
print(str(e))
|
|
|
|
fractions.__spec__.origin = []
|
|
try:
|
|
fractions.Fraction
|
|
except AttributeError as e:
|
|
print(str(e))
|
|
""")
|
|
|
|
popen = script_helper.spawn_python("main.py", cwd=tmp)
|
|
stdout, stderr = popen.communicate()
|
|
lines = stdout.splitlines()
|
|
self.assertEqual(len(lines), 2)
|
|
for line in lines:
|
|
self.assertEqual(line, b"module 'fractions' has no attribute 'Fraction'")
|
|
|
|
with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
|
|
f.write("""
|
|
import fractions
|
|
fractions.shadowing_module
|
|
del fractions.__spec__.origin
|
|
try:
|
|
from fractions import Fraction
|
|
except ImportError as e:
|
|
print(str(e))
|
|
|
|
fractions.__spec__.origin = []
|
|
try:
|
|
from fractions import Fraction
|
|
except ImportError as e:
|
|
print(str(e))
|
|
""")
|
|
popen = script_helper.spawn_python("main.py", cwd=tmp)
|
|
stdout, stderr = popen.communicate()
|
|
lines = stdout.splitlines()
|
|
self.assertEqual(len(lines), 2)
|
|
for line in lines:
|
|
self.assertRegex(line, rb"cannot import name 'Fraction' from 'fractions' \(.*\)")
|
|
|
|
@unittest.skipIf(sys.platform == 'win32', 'Cannot delete cwd on Windows')
|
|
@unittest.skipIf(sys.platform == 'sunos5', 'Cannot delete cwd on Solaris/Illumos')
|
|
@unittest.skipIf(sys.platform.startswith('aix'), 'Cannot delete cwd on AIX')
|
|
def test_script_shadowing_stdlib_cwd_failure(self):
|
|
with os_helper.temp_dir() as tmp:
|
|
subtmp = os.path.join(tmp, "subtmp")
|
|
os.mkdir(subtmp)
|
|
with open(os.path.join(subtmp, "main.py"), "w", encoding='utf-8') as f:
|
|
f.write(f"""
|
|
import sys
|
|
assert sys.path[0] == ''
|
|
|
|
import os
|
|
import shutil
|
|
shutil.rmtree(os.getcwd())
|
|
|
|
os.does_not_exist
|
|
""")
|
|
# Use -c to ensure sys.path[0] is ""
|
|
popen = script_helper.spawn_python("-c", "import main", cwd=subtmp)
|
|
stdout, stderr = popen.communicate()
|
|
expected_error = rb"AttributeError: module 'os' has no attribute 'does_not_exist'"
|
|
self.assertRegex(stdout, expected_error)
|
|
|
|
def test_script_shadowing_stdlib_sys_path_modification(self):
|
|
script_errors = [
|
|
(
|
|
"import fractions\nfractions.Fraction",
|
|
rb"AttributeError: module 'fractions' has no attribute 'Fraction'"
|
|
),
|
|
(
|
|
"from fractions import Fraction",
|
|
rb"ImportError: cannot import name 'Fraction' from 'fractions'"
|
|
)
|
|
]
|
|
for script, error in script_errors:
|
|
with self.subTest(script=script), os_helper.temp_dir() as tmp:
|
|
with open(os.path.join(tmp, "fractions.py"), "w", encoding='utf-8') as f:
|
|
f.write("shadowing_module = True")
|
|
with open(os.path.join(tmp, "main.py"), "w", encoding='utf-8') as f:
|
|
f.write('import sys; sys.path.insert(0, "this_folder_does_not_exist")\n')
|
|
f.write(script)
|
|
expected_error = error + (
|
|
rb" \(consider renaming '.*fractions.py' since it has the "
|
|
rb"same name as the standard library module named 'fractions' "
|
|
rb"and prevents importing that standard library module\)"
|
|
)
|
|
|
|
popen = script_helper.spawn_python("main.py", cwd=tmp)
|
|
stdout, stderr = popen.communicate()
|
|
self.assertRegex(stdout, expected_error)
|
|
|
|
@unittest.expectedFailure # TODO: RUSTPYTHON; _imp.create_dynamic not implemented
|
|
def test_create_dynamic_null(self):
|
|
with self.assertRaisesRegex(ValueError, 'embedded null character'):
|
|
class Spec:
|
|
name = "a\x00b"
|
|
origin = "abc"
|
|
_imp.create_dynamic(Spec())
|
|
|
|
with self.assertRaisesRegex(ValueError, 'embedded null character'):
|
|
class Spec2:
|
|
name = "abc"
|
|
origin = "a\x00b"
|
|
_imp.create_dynamic(Spec2())
|
|
|
|
|
|
@skip_if_dont_write_bytecode
|
|
class FilePermissionTests(unittest.TestCase):
|
|
# tests for file mode on cached .pyc files
|
|
|
|
@unittest.skipUnless(os.name == 'posix',
|
|
"test meaningful only on posix systems")
|
|
@unittest.skipIf(
|
|
is_wasm32,
|
|
"Emscripten's/WASI's umask is a stub."
|
|
)
|
|
def test_creation_mode(self):
|
|
mask = 0o022
|
|
with temp_umask(mask), ready_to_import() as (name, path):
|
|
cached_path = importlib.util.cache_from_source(path)
|
|
module = __import__(name)
|
|
if not os.path.exists(cached_path):
|
|
self.fail("__import__ did not result in creation of "
|
|
"a .pyc file")
|
|
stat_info = os.stat(cached_path)
|
|
|
|
# Check that the umask is respected, and the executable bits
|
|
# aren't set.
|
|
self.assertEqual(oct(stat.S_IMODE(stat_info.st_mode)),
|
|
oct(0o666 & ~mask))
|
|
|
|
@unittest.skipUnless(os.name == 'posix',
|
|
"test meaningful only on posix systems")
|
|
@os_helper.skip_unless_working_chmod
|
|
def test_cached_mode_issue_2051(self):
|
|
# permissions of .pyc should match those of .py, regardless of mask
|
|
mode = 0o600
|
|
with temp_umask(0o022), ready_to_import() as (name, path):
|
|
cached_path = importlib.util.cache_from_source(path)
|
|
os.chmod(path, mode)
|
|
__import__(name)
|
|
if not os.path.exists(cached_path):
|
|
self.fail("__import__ did not result in creation of "
|
|
"a .pyc file")
|
|
stat_info = os.stat(cached_path)
|
|
|
|
self.assertEqual(oct(stat.S_IMODE(stat_info.st_mode)), oct(mode))
|
|
|
|
@unittest.skipUnless(os.name == 'posix',
|
|
"test meaningful only on posix systems")
|
|
@os_helper.skip_unless_working_chmod
|
|
def test_cached_readonly(self):
|
|
mode = 0o400
|
|
with temp_umask(0o022), ready_to_import() as (name, path):
|
|
cached_path = importlib.util.cache_from_source(path)
|
|
os.chmod(path, mode)
|
|
__import__(name)
|
|
if not os.path.exists(cached_path):
|
|
self.fail("__import__ did not result in creation of "
|
|
"a .pyc file")
|
|
stat_info = os.stat(cached_path)
|
|
|
|
expected = mode | 0o200 # Account for fix for issue #6074
|
|
self.assertEqual(oct(stat.S_IMODE(stat_info.st_mode)), oct(expected))
|
|
|
|
def test_pyc_always_writable(self):
|
|
# Initially read-only .pyc files on Windows used to cause problems
|
|
# with later updates, see issue #6074 for details
|
|
with ready_to_import() as (name, path):
|
|
# Write a Python file, make it read-only and import it
|
|
with open(path, 'w', encoding='utf-8') as f:
|
|
f.write("x = 'original'\n")
|
|
# Tweak the mtime of the source to ensure pyc gets updated later
|
|
s = os.stat(path)
|
|
os.utime(path, (s.st_atime, s.st_mtime-100000000))
|
|
os.chmod(path, 0o400)
|
|
m = __import__(name)
|
|
self.assertEqual(m.x, 'original')
|
|
# Change the file and then reimport it
|
|
os.chmod(path, 0o600)
|
|
with open(path, 'w', encoding='utf-8') as f:
|
|
f.write("x = 'rewritten'\n")
|
|
unload(name)
|
|
importlib.invalidate_caches()
|
|
m = __import__(name)
|
|
self.assertEqual(m.x, 'rewritten')
|
|
# Now delete the source file and check the pyc was rewritten
|
|
unlink(path)
|
|
unload(name)
|
|
importlib.invalidate_caches()
|
|
bytecode_only = path + "c"
|
|
os.rename(importlib.util.cache_from_source(path), bytecode_only)
|
|
m = __import__(name)
|
|
self.assertEqual(m.x, 'rewritten')
|
|
|
|
|
|
class PycRewritingTests(unittest.TestCase):
|
|
# Test that the `co_filename` attribute on code objects always points
|
|
# to the right file, even when various things happen (e.g. both the .py
|
|
# and the .pyc file are renamed).
|
|
|
|
module_name = "unlikely_module_name"
|
|
module_source = """
|
|
import sys
|
|
code_filename = sys._getframe().f_code.co_filename
|
|
module_filename = __file__
|
|
constant = 1000
|
|
def func():
|
|
pass
|
|
func_filename = func.__code__.co_filename
|
|
"""
|
|
dir_name = os.path.abspath(TESTFN)
|
|
file_name = os.path.join(dir_name, module_name) + os.extsep + "py"
|
|
compiled_name = importlib.util.cache_from_source(file_name)
|
|
|
|
def setUp(self):
|
|
self.sys_path = sys.path[:]
|
|
self.orig_module = sys.modules.pop(self.module_name, None)
|
|
os.mkdir(self.dir_name)
|
|
with open(self.file_name, "w", encoding='utf-8') as f:
|
|
f.write(self.module_source)
|
|
sys.path.insert(0, self.dir_name)
|
|
importlib.invalidate_caches()
|
|
|
|
def tearDown(self):
|
|
sys.path[:] = self.sys_path
|
|
if self.orig_module is not None:
|
|
sys.modules[self.module_name] = self.orig_module
|
|
else:
|
|
unload(self.module_name)
|
|
unlink(self.file_name)
|
|
unlink(self.compiled_name)
|
|
rmtree(self.dir_name)
|
|
|
|
def import_module(self):
|
|
ns = globals()
|
|
__import__(self.module_name, ns, ns)
|
|
return sys.modules[self.module_name]
|
|
|
|
def test_basics(self):
|
|
mod = self.import_module()
|
|
self.assertEqual(mod.module_filename, self.file_name)
|
|
self.assertEqual(mod.code_filename, self.file_name)
|
|
self.assertEqual(mod.func_filename, self.file_name)
|
|
del sys.modules[self.module_name]
|
|
mod = self.import_module()
|
|
self.assertEqual(mod.module_filename, self.file_name)
|
|
self.assertEqual(mod.code_filename, self.file_name)
|
|
self.assertEqual(mod.func_filename, self.file_name)
|
|
|
|
def test_incorrect_code_name(self):
|
|
py_compile.compile(self.file_name, dfile="another_module.py")
|
|
mod = self.import_module()
|
|
self.assertEqual(mod.module_filename, self.file_name)
|
|
self.assertEqual(mod.code_filename, self.file_name)
|
|
self.assertEqual(mod.func_filename, self.file_name)
|
|
|
|
def test_module_without_source(self):
|
|
target = "another_module.py"
|
|
py_compile.compile(self.file_name, dfile=target)
|
|
os.remove(self.file_name)
|
|
pyc_file = make_legacy_pyc(self.file_name)
|
|
importlib.invalidate_caches()
|
|
mod = self.import_module()
|
|
self.assertEqual(mod.module_filename, pyc_file)
|
|
self.assertEqual(mod.code_filename, target)
|
|
self.assertEqual(mod.func_filename, target)
|
|
|
|
def test_foreign_code(self):
|
|
py_compile.compile(self.file_name)
|
|
with open(self.compiled_name, "rb") as f:
|
|
header = f.read(16)
|
|
code = marshal.load(f)
|
|
constants = list(code.co_consts)
|
|
foreign_code = importlib.import_module.__code__
|
|
pos = constants.index(1000)
|
|
constants[pos] = foreign_code
|
|
code = code.replace(co_consts=tuple(constants))
|
|
with open(self.compiled_name, "wb") as f:
|
|
f.write(header)
|
|
marshal.dump(code, f)
|
|
mod = self.import_module()
|
|
self.assertEqual(mod.constant.co_filename, foreign_code.co_filename)
|
|
|
|
|
|
class PathsTests(unittest.TestCase):
|
|
SAMPLES = ('test', 'test\u00e4\u00f6\u00fc\u00df', 'test\u00e9\u00e8',
|
|
'test\u00b0\u00b3\u00b2')
|
|
path = TESTFN
|
|
|
|
def setUp(self):
|
|
os.mkdir(self.path)
|
|
self.syspath = sys.path[:]
|
|
|
|
def tearDown(self):
|
|
rmtree(self.path)
|
|
sys.path[:] = self.syspath
|
|
|
|
# Regression test for http://bugs.python.org/issue1293.
|
|
def test_trailing_slash(self):
|
|
with open(os.path.join(self.path, 'test_trailing_slash.py'),
|
|
'w', encoding='utf-8') as f:
|
|
f.write("testdata = 'test_trailing_slash'")
|
|
sys.path.append(self.path+'/')
|
|
mod = __import__("test_trailing_slash")
|
|
self.assertEqual(mod.testdata, 'test_trailing_slash')
|
|
unload("test_trailing_slash")
|
|
|
|
# Regression test for http://bugs.python.org/issue3677.
|
|
@unittest.skipUnless(sys.platform == 'win32', 'Windows-specific')
|
|
def test_UNC_path(self):
|
|
with open(os.path.join(self.path, 'test_unc_path.py'), 'w') as f:
|
|
f.write("testdata = 'test_unc_path'")
|
|
importlib.invalidate_caches()
|
|
# Create the UNC path, like \\myhost\c$\foo\bar.
|
|
path = os.path.abspath(self.path)
|
|
import socket
|
|
hn = socket.gethostname()
|
|
drive = path[0]
|
|
unc = "\\\\%s\\%s$"%(hn, drive)
|
|
unc += path[2:]
|
|
try:
|
|
os.listdir(unc)
|
|
except OSError as e:
|
|
if e.errno in (errno.EPERM, errno.EACCES, errno.ENOENT):
|
|
# See issue #15338
|
|
self.skipTest("cannot access administrative share %r" % (unc,))
|
|
raise
|
|
sys.path.insert(0, unc)
|
|
try:
|
|
mod = __import__("test_unc_path")
|
|
except ImportError as e:
|
|
self.fail("could not import 'test_unc_path' from %r: %r"
|
|
% (unc, e))
|
|
self.assertEqual(mod.testdata, 'test_unc_path')
|
|
self.assertStartsWith(mod.__file__, unc)
|
|
unload("test_unc_path")
|
|
|
|
|
|
class RelativeImportTests(unittest.TestCase):
|
|
|
|
def tearDown(self):
|
|
unload("test.relimport")
|
|
setUp = tearDown
|
|
|
|
def test_relimport_star(self):
|
|
# This will import * from .test_import.
|
|
from .. import relimport
|
|
self.assertHasAttr(relimport, "RelativeImportTests")
|
|
|
|
def test_issue3221(self):
|
|
# Note for mergers: the 'absolute' tests from the 2.x branch
|
|
# are missing in Py3k because implicit relative imports are
|
|
# a thing of the past
|
|
#
|
|
# Regression test for http://bugs.python.org/issue3221.
|
|
def check_relative():
|
|
exec("from . import relimport", ns)
|
|
|
|
# Check relative import OK with __package__ and __name__ correct
|
|
ns = dict(__package__='test', __name__='test.notarealmodule')
|
|
check_relative()
|
|
|
|
# Check relative import OK with only __name__ wrong
|
|
ns = dict(__package__='test', __name__='notarealpkg.notarealmodule')
|
|
check_relative()
|
|
|
|
# Check relative import fails with only __package__ wrong
|
|
ns = dict(__package__='foo', __name__='test.notarealmodule')
|
|
self.assertRaises(ModuleNotFoundError, check_relative)
|
|
|
|
# Check relative import fails with __package__ and __name__ wrong
|
|
ns = dict(__package__='foo', __name__='notarealpkg.notarealmodule')
|
|
self.assertRaises(ModuleNotFoundError, check_relative)
|
|
|
|
# Check relative import fails with package set to a non-string
|
|
ns = dict(__package__=object())
|
|
self.assertRaises(TypeError, check_relative)
|
|
|
|
def test_parentless_import_shadowed_by_global(self):
|
|
# Test as if this were done from the REPL where this error most commonly occurs (bpo-37409).
|
|
script_helper.assert_python_failure('-W', 'ignore', '-c',
|
|
"foo = 1; from . import foo")
|
|
|
|
def test_absolute_import_without_future(self):
|
|
# If explicit relative import syntax is used, then do not try
|
|
# to perform an absolute import in the face of failure.
|
|
# Issue #7902.
|
|
with self.assertRaises(ImportError):
|
|
from .os import sep
|
|
self.fail("explicit relative import triggered an "
|
|
"implicit absolute import")
|
|
|
|
def test_import_from_non_package(self):
|
|
path = os.path.join(os.path.dirname(__file__), 'data', 'package2')
|
|
with uncache('submodule1', 'submodule2'), DirsOnSysPath(path):
|
|
with self.assertRaises(ImportError):
|
|
import submodule1
|
|
self.assertNotIn('submodule1', sys.modules)
|
|
self.assertNotIn('submodule2', sys.modules)
|
|
|
|
def test_import_from_unloaded_package(self):
|
|
with uncache('package2', 'package2.submodule1', 'package2.submodule2'), \
|
|
DirsOnSysPath(os.path.join(os.path.dirname(__file__), 'data')):
|
|
import package2.submodule1
|
|
package2.submodule1.submodule2
|
|
|
|
def test_rebinding(self):
|
|
# The same data is also used for testing pkgutil.resolve_name()
|
|
# in test_pkgutil and mock.patch in test_unittest.
|
|
path = os.path.join(os.path.dirname(__file__), 'data')
|
|
with uncache('package3', 'package3.submodule'), DirsOnSysPath(path):
|
|
from package3 import submodule
|
|
self.assertEqual(submodule.attr, 'rebound')
|
|
import package3.submodule as submodule
|
|
self.assertEqual(submodule.attr, 'rebound')
|
|
with uncache('package3', 'package3.submodule'), DirsOnSysPath(path):
|
|
import package3.submodule as submodule
|
|
self.assertEqual(submodule.attr, 'rebound')
|
|
from package3 import submodule
|
|
self.assertEqual(submodule.attr, 'rebound')
|
|
|
|
def test_rebinding2(self):
|
|
path = os.path.join(os.path.dirname(__file__), 'data')
|
|
with uncache('package4', 'package4.submodule'), DirsOnSysPath(path):
|
|
import package4.submodule as submodule
|
|
self.assertEqual(submodule.attr, 'submodule')
|
|
from package4 import submodule
|
|
self.assertEqual(submodule.attr, 'submodule')
|
|
with uncache('package4', 'package4.submodule'), DirsOnSysPath(path):
|
|
from package4 import submodule
|
|
self.assertEqual(submodule.attr, 'origin')
|
|
import package4.submodule as submodule
|
|
self.assertEqual(submodule.attr, 'submodule')
|
|
|
|
|
|
class OverridingImportBuiltinTests(unittest.TestCase):
|
|
def test_override_builtin(self):
|
|
# Test that overriding builtins.__import__ can bypass sys.modules.
|
|
import os
|
|
|
|
def foo():
|
|
import os
|
|
return os
|
|
self.assertEqual(foo(), os) # Quick sanity check.
|
|
|
|
with swap_attr(builtins, "__import__", lambda *x: 5):
|
|
self.assertEqual(foo(), 5)
|
|
|
|
# Test what happens when we shadow __import__ in globals(); this
|
|
# currently does not impact the import process, but if this changes,
|
|
# other code will need to change, so keep this test as a tripwire.
|
|
with swap_item(globals(), "__import__", lambda *x: 5):
|
|
self.assertEqual(foo(), os)
|
|
|
|
|
|
class PycacheTests(unittest.TestCase):
|
|
# Test the various PEP 3147/488-related behaviors.
|
|
|
|
def _clean(self):
|
|
forget(TESTFN)
|
|
rmtree('__pycache__')
|
|
unlink(self.source)
|
|
|
|
def setUp(self):
|
|
self.source = TESTFN + '.py'
|
|
self._clean()
|
|
with open(self.source, 'w', encoding='utf-8') as fp:
|
|
print('# This is a test file written by test_import.py', file=fp)
|
|
sys.path.insert(0, os.curdir)
|
|
importlib.invalidate_caches()
|
|
|
|
def tearDown(self):
|
|
assert sys.path[0] == os.curdir, 'Unexpected sys.path[0]'
|
|
del sys.path[0]
|
|
self._clean()
|
|
|
|
@skip_if_dont_write_bytecode
|
|
def test_import_pyc_path(self):
|
|
self.assertFalse(os.path.exists('__pycache__'))
|
|
__import__(TESTFN)
|
|
self.assertTrue(os.path.exists('__pycache__'))
|
|
pyc_path = importlib.util.cache_from_source(self.source)
|
|
self.assertTrue(os.path.exists(pyc_path),
|
|
'bytecode file {!r} for {!r} does not '
|
|
'exist'.format(pyc_path, TESTFN))
|
|
|
|
@unittest.skipUnless(os.name == 'posix',
|
|
"test meaningful only on posix systems")
|
|
@skip_if_dont_write_bytecode
|
|
@os_helper.skip_unless_working_chmod
|
|
@os_helper.skip_if_dac_override
|
|
@unittest.skipIf(is_emscripten, "umask is a stub")
|
|
def test_unwritable_directory(self):
|
|
# When the umask causes the new __pycache__ directory to be
|
|
# unwritable, the import still succeeds but no .pyc file is written.
|
|
with temp_umask(0o222):
|
|
__import__(TESTFN)
|
|
self.assertTrue(os.path.exists('__pycache__'))
|
|
pyc_path = importlib.util.cache_from_source(self.source)
|
|
self.assertFalse(os.path.exists(pyc_path),
|
|
'bytecode file {!r} for {!r} '
|
|
'exists'.format(pyc_path, TESTFN))
|
|
|
|
@skip_if_dont_write_bytecode
|
|
def test_missing_source(self):
|
|
# With PEP 3147 cache layout, removing the source but leaving the pyc
|
|
# file does not satisfy the import.
|
|
__import__(TESTFN)
|
|
pyc_file = importlib.util.cache_from_source(self.source)
|
|
self.assertTrue(os.path.exists(pyc_file))
|
|
os.remove(self.source)
|
|
forget(TESTFN)
|
|
importlib.invalidate_caches()
|
|
self.assertRaises(ImportError, __import__, TESTFN)
|
|
|
|
@skip_if_dont_write_bytecode
|
|
def test_missing_source_legacy(self):
|
|
# Like test_missing_source() except that for backward compatibility,
|
|
# when the pyc file lives where the py file would have been (and named
|
|
# without the tag), it is importable. The __file__ of the imported
|
|
# module is the pyc location.
|
|
__import__(TESTFN)
|
|
# pyc_file gets removed in _clean() via tearDown().
|
|
pyc_file = make_legacy_pyc(self.source)
|
|
os.remove(self.source)
|
|
unload(TESTFN)
|
|
importlib.invalidate_caches()
|
|
m = __import__(TESTFN)
|
|
try:
|
|
self.assertEqual(m.__file__,
|
|
os.path.join(os.getcwd(), os.path.relpath(pyc_file)))
|
|
finally:
|
|
os.remove(pyc_file)
|
|
|
|
def test___cached__(self):
|
|
# Modules now also have an __cached__ that points to the pyc file.
|
|
m = __import__(TESTFN)
|
|
pyc_file = importlib.util.cache_from_source(TESTFN + '.py')
|
|
self.assertEqual(m.__cached__, os.path.join(os.getcwd(), pyc_file))
|
|
|
|
@skip_if_dont_write_bytecode
|
|
def test___cached___legacy_pyc(self):
|
|
# Like test___cached__() except that for backward compatibility,
|
|
# when the pyc file lives where the py file would have been (and named
|
|
# without the tag), it is importable. The __cached__ of the imported
|
|
# module is the pyc location.
|
|
__import__(TESTFN)
|
|
# pyc_file gets removed in _clean() via tearDown().
|
|
pyc_file = make_legacy_pyc(self.source)
|
|
os.remove(self.source)
|
|
unload(TESTFN)
|
|
importlib.invalidate_caches()
|
|
m = __import__(TESTFN)
|
|
self.assertEqual(m.__cached__,
|
|
os.path.join(os.getcwd(), os.path.relpath(pyc_file)))
|
|
|
|
@skip_if_dont_write_bytecode
|
|
def test_package___cached__(self):
|
|
# Like test___cached__ but for packages.
|
|
def cleanup():
|
|
rmtree('pep3147')
|
|
unload('pep3147.foo')
|
|
unload('pep3147')
|
|
os.mkdir('pep3147')
|
|
self.addCleanup(cleanup)
|
|
# Touch the __init__.py
|
|
with open(os.path.join('pep3147', '__init__.py'), 'wb'):
|
|
pass
|
|
with open(os.path.join('pep3147', 'foo.py'), 'wb'):
|
|
pass
|
|
importlib.invalidate_caches()
|
|
m = __import__('pep3147.foo')
|
|
init_pyc = importlib.util.cache_from_source(
|
|
os.path.join('pep3147', '__init__.py'))
|
|
self.assertEqual(m.__cached__, os.path.join(os.getcwd(), init_pyc))
|
|
foo_pyc = importlib.util.cache_from_source(os.path.join('pep3147', 'foo.py'))
|
|
self.assertEqual(sys.modules['pep3147.foo'].__cached__,
|
|
os.path.join(os.getcwd(), foo_pyc))
|
|
|
|
def test_package___cached___from_pyc(self):
|
|
# Like test___cached__ but ensuring __cached__ when imported from a
|
|
# PEP 3147 pyc file.
|
|
def cleanup():
|
|
rmtree('pep3147')
|
|
unload('pep3147.foo')
|
|
unload('pep3147')
|
|
os.mkdir('pep3147')
|
|
self.addCleanup(cleanup)
|
|
# Touch the __init__.py
|
|
with open(os.path.join('pep3147', '__init__.py'), 'wb'):
|
|
pass
|
|
with open(os.path.join('pep3147', 'foo.py'), 'wb'):
|
|
pass
|
|
importlib.invalidate_caches()
|
|
m = __import__('pep3147.foo')
|
|
unload('pep3147.foo')
|
|
unload('pep3147')
|
|
importlib.invalidate_caches()
|
|
m = __import__('pep3147.foo')
|
|
init_pyc = importlib.util.cache_from_source(
|
|
os.path.join('pep3147', '__init__.py'))
|
|
self.assertEqual(m.__cached__, os.path.join(os.getcwd(), init_pyc))
|
|
foo_pyc = importlib.util.cache_from_source(os.path.join('pep3147', 'foo.py'))
|
|
self.assertEqual(sys.modules['pep3147.foo'].__cached__,
|
|
os.path.join(os.getcwd(), foo_pyc))
|
|
|
|
def test_recompute_pyc_same_second(self):
|
|
# Even when the source file doesn't change timestamp, a change in
|
|
# source size is enough to trigger recomputation of the pyc file.
|
|
__import__(TESTFN)
|
|
unload(TESTFN)
|
|
with open(self.source, 'a', encoding='utf-8') as fp:
|
|
print("x = 5", file=fp)
|
|
m = __import__(TESTFN)
|
|
self.assertEqual(m.x, 5)
|
|
|
|
|
|
class TestSymbolicallyLinkedPackage(unittest.TestCase):
|
|
package_name = 'sample'
|
|
tagged = package_name + '-tagged'
|
|
|
|
def setUp(self):
|
|
os_helper.rmtree(self.tagged)
|
|
os_helper.rmtree(self.package_name)
|
|
self.orig_sys_path = sys.path[:]
|
|
|
|
# create a sample package; imagine you have a package with a tag and
|
|
# you want to symbolically link it from its untagged name.
|
|
os.mkdir(self.tagged)
|
|
self.addCleanup(os_helper.rmtree, self.tagged)
|
|
init_file = os.path.join(self.tagged, '__init__.py')
|
|
os_helper.create_empty_file(init_file)
|
|
assert os.path.exists(init_file)
|
|
|
|
# now create a symlink to the tagged package
|
|
# sample -> sample-tagged
|
|
os.symlink(self.tagged, self.package_name, target_is_directory=True)
|
|
self.addCleanup(os_helper.unlink, self.package_name)
|
|
importlib.invalidate_caches()
|
|
|
|
self.assertEqual(os.path.isdir(self.package_name), True)
|
|
|
|
assert os.path.isfile(os.path.join(self.package_name, '__init__.py'))
|
|
|
|
def tearDown(self):
|
|
sys.path[:] = self.orig_sys_path
|
|
|
|
# regression test for issue6727
|
|
@unittest.skipUnless(
|
|
not hasattr(sys, 'getwindowsversion')
|
|
or sys.getwindowsversion() >= (6, 0),
|
|
"Windows Vista or later required")
|
|
@os_helper.skip_unless_symlink
|
|
def test_symlinked_dir_importable(self):
|
|
# make sure sample can only be imported from the current directory.
|
|
sys.path[:] = ['.']
|
|
assert os.path.exists(self.package_name)
|
|
assert os.path.exists(os.path.join(self.package_name, '__init__.py'))
|
|
|
|
# Try to import the package
|
|
importlib.import_module(self.package_name)
|
|
|
|
|
|
@cpython_only
|
|
class ImportlibBootstrapTests(unittest.TestCase):
|
|
# These tests check that importlib is bootstrapped.
|
|
|
|
def test_frozen_importlib(self):
|
|
mod = sys.modules['_frozen_importlib']
|
|
self.assertTrue(mod)
|
|
|
|
def test_frozen_importlib_is_bootstrap(self):
|
|
from importlib import _bootstrap
|
|
mod = sys.modules['_frozen_importlib']
|
|
self.assertIs(mod, _bootstrap)
|
|
self.assertEqual(mod.__name__, 'importlib._bootstrap')
|
|
self.assertEqual(mod.__package__, 'importlib')
|
|
self.assertEndsWith(mod.__file__, '_bootstrap.py')
|
|
|
|
def test_frozen_importlib_external_is_bootstrap_external(self):
|
|
from importlib import _bootstrap_external
|
|
mod = sys.modules['_frozen_importlib_external']
|
|
self.assertIs(mod, _bootstrap_external)
|
|
self.assertEqual(mod.__name__, 'importlib._bootstrap_external')
|
|
self.assertEqual(mod.__package__, 'importlib')
|
|
self.assertEndsWith(mod.__file__, '_bootstrap_external.py')
|
|
|
|
def test_there_can_be_only_one(self):
|
|
# Issue #15386 revealed a tricky loophole in the bootstrapping
|
|
# This test is technically redundant, since the bug caused importing
|
|
# this test module to crash completely, but it helps prove the point
|
|
from importlib import machinery
|
|
mod = sys.modules['_frozen_importlib']
|
|
self.assertIs(machinery.ModuleSpec, mod.ModuleSpec)
|
|
|
|
|
|
@cpython_only
|
|
class GetSourcefileTests(unittest.TestCase):
|
|
|
|
"""Test importlib._bootstrap_external._get_sourcefile() as used by the C API.
|
|
|
|
Because of the peculiarities of the need of this function, the tests are
|
|
knowingly whitebox tests.
|
|
|
|
"""
|
|
|
|
def test_get_sourcefile(self):
|
|
# Given a valid bytecode path, return the path to the corresponding
|
|
# source file if it exists.
|
|
with mock.patch('importlib._bootstrap_external._path_isfile') as _path_isfile:
|
|
_path_isfile.return_value = True
|
|
path = TESTFN + '.pyc'
|
|
expect = TESTFN + '.py'
|
|
self.assertEqual(_get_sourcefile(path), expect)
|
|
|
|
def test_get_sourcefile_no_source(self):
|
|
# Given a valid bytecode path without a corresponding source path,
|
|
# return the original bytecode path.
|
|
with mock.patch('importlib._bootstrap_external._path_isfile') as _path_isfile:
|
|
_path_isfile.return_value = False
|
|
path = TESTFN + '.pyc'
|
|
self.assertEqual(_get_sourcefile(path), path)
|
|
|
|
def test_get_sourcefile_bad_ext(self):
|
|
# Given a path with an invalid bytecode extension, return the
|
|
# bytecode path passed as the argument.
|
|
path = TESTFN + '.bad_ext'
|
|
self.assertEqual(_get_sourcefile(path), path)
|
|
|
|
|
|
class ImportTracebackTests(unittest.TestCase):
|
|
|
|
def setUp(self):
|
|
os.mkdir(TESTFN)
|
|
self.old_path = sys.path[:]
|
|
sys.path.insert(0, TESTFN)
|
|
|
|
def tearDown(self):
|
|
sys.path[:] = self.old_path
|
|
rmtree(TESTFN)
|
|
|
|
def create_module(self, mod, contents, ext=".py"):
|
|
fname = os.path.join(TESTFN, mod + ext)
|
|
with open(fname, "w", encoding='utf-8') as f:
|
|
f.write(contents)
|
|
self.addCleanup(unload, mod)
|
|
importlib.invalidate_caches()
|
|
return fname
|
|
|
|
def assert_traceback(self, tb, files):
|
|
deduped_files = []
|
|
while tb:
|
|
code = tb.tb_frame.f_code
|
|
fn = code.co_filename
|
|
if not deduped_files or fn != deduped_files[-1]:
|
|
deduped_files.append(fn)
|
|
tb = tb.tb_next
|
|
self.assertEqual(len(deduped_files), len(files), deduped_files)
|
|
for fn, pat in zip(deduped_files, files):
|
|
self.assertIn(pat, fn)
|
|
|
|
def test_nonexistent_module(self):
|
|
try:
|
|
# assertRaises() clears __traceback__
|
|
import nonexistent_xyzzy
|
|
except ImportError as e:
|
|
tb = e.__traceback__
|
|
else:
|
|
self.fail("ImportError should have been raised")
|
|
self.assert_traceback(tb, [__file__])
|
|
|
|
def test_nonexistent_module_nested(self):
|
|
self.create_module("foo", "import nonexistent_xyzzy")
|
|
try:
|
|
import foo
|
|
except ImportError as e:
|
|
tb = e.__traceback__
|
|
else:
|
|
self.fail("ImportError should have been raised")
|
|
self.assert_traceback(tb, [__file__, 'foo.py'])
|
|
|
|
def test_exec_failure(self):
|
|
self.create_module("foo", "1/0")
|
|
try:
|
|
import foo
|
|
except ZeroDivisionError as e:
|
|
tb = e.__traceback__
|
|
else:
|
|
self.fail("ZeroDivisionError should have been raised")
|
|
self.assert_traceback(tb, [__file__, 'foo.py'])
|
|
|
|
def test_exec_failure_nested(self):
|
|
self.create_module("foo", "import bar")
|
|
self.create_module("bar", "1/0")
|
|
try:
|
|
import foo
|
|
except ZeroDivisionError as e:
|
|
tb = e.__traceback__
|
|
else:
|
|
self.fail("ZeroDivisionError should have been raised")
|
|
self.assert_traceback(tb, [__file__, 'foo.py', 'bar.py'])
|
|
|
|
# A few more examples from issue #15425
|
|
def test_syntax_error(self):
|
|
self.create_module("foo", "invalid syntax is invalid")
|
|
try:
|
|
import foo
|
|
except SyntaxError as e:
|
|
tb = e.__traceback__
|
|
else:
|
|
self.fail("SyntaxError should have been raised")
|
|
self.assert_traceback(tb, [__file__])
|
|
|
|
def _setup_broken_package(self, parent, child):
|
|
pkg_name = "_parent_foo"
|
|
self.addCleanup(unload, pkg_name)
|
|
pkg_path = os.path.join(TESTFN, pkg_name)
|
|
os.mkdir(pkg_path)
|
|
# Touch the __init__.py
|
|
init_path = os.path.join(pkg_path, '__init__.py')
|
|
with open(init_path, 'w', encoding='utf-8') as f:
|
|
f.write(parent)
|
|
bar_path = os.path.join(pkg_path, 'bar.py')
|
|
with open(bar_path, 'w', encoding='utf-8') as f:
|
|
f.write(child)
|
|
importlib.invalidate_caches()
|
|
return init_path, bar_path
|
|
|
|
def test_broken_submodule(self):
|
|
init_path, bar_path = self._setup_broken_package("", "1/0")
|
|
try:
|
|
import _parent_foo.bar
|
|
except ZeroDivisionError as e:
|
|
tb = e.__traceback__
|
|
else:
|
|
self.fail("ZeroDivisionError should have been raised")
|
|
self.assert_traceback(tb, [__file__, bar_path])
|
|
|
|
def test_broken_from(self):
|
|
init_path, bar_path = self._setup_broken_package("", "1/0")
|
|
try:
|
|
from _parent_foo import bar
|
|
except ZeroDivisionError as e:
|
|
tb = e.__traceback__
|
|
else:
|
|
self.fail("ImportError should have been raised")
|
|
self.assert_traceback(tb, [__file__, bar_path])
|
|
|
|
def test_broken_parent(self):
|
|
init_path, bar_path = self._setup_broken_package("1/0", "")
|
|
try:
|
|
import _parent_foo.bar
|
|
except ZeroDivisionError as e:
|
|
tb = e.__traceback__
|
|
else:
|
|
self.fail("ZeroDivisionError should have been raised")
|
|
self.assert_traceback(tb, [__file__, init_path])
|
|
|
|
def test_broken_parent_from(self):
|
|
init_path, bar_path = self._setup_broken_package("1/0", "")
|
|
try:
|
|
from _parent_foo import bar
|
|
except ZeroDivisionError as e:
|
|
tb = e.__traceback__
|
|
else:
|
|
self.fail("ZeroDivisionError should have been raised")
|
|
self.assert_traceback(tb, [__file__, init_path])
|
|
|
|
@cpython_only
|
|
def test_import_bug(self):
|
|
# We simulate a bug in importlib and check that it's not stripped
|
|
# away from the traceback.
|
|
self.create_module("foo", "")
|
|
importlib = sys.modules['_frozen_importlib_external']
|
|
if 'load_module' in vars(importlib.SourceLoader):
|
|
old_exec_module = importlib.SourceLoader.exec_module
|
|
else:
|
|
old_exec_module = None
|
|
try:
|
|
def exec_module(*args):
|
|
1/0
|
|
importlib.SourceLoader.exec_module = exec_module
|
|
try:
|
|
import foo
|
|
except ZeroDivisionError as e:
|
|
tb = e.__traceback__
|
|
else:
|
|
self.fail("ZeroDivisionError should have been raised")
|
|
self.assert_traceback(tb, [__file__, '<frozen importlib', __file__])
|
|
finally:
|
|
if old_exec_module is None:
|
|
del importlib.SourceLoader.exec_module
|
|
else:
|
|
importlib.SourceLoader.exec_module = old_exec_module
|
|
|
|
@unittest.expectedFailure # TODO: RUSTPYTHON; subprocess fails on Windows
|
|
@unittest.skipUnless(TESTFN_UNENCODABLE, 'need TESTFN_UNENCODABLE')
|
|
def test_unencodable_filename(self):
|
|
# Issue #11619: The Python parser and the import machinery must not
|
|
# encode filenames, especially on Windows
|
|
pyname = script_helper.make_script('', TESTFN_UNENCODABLE, 'pass')
|
|
self.addCleanup(unlink, pyname)
|
|
name = pyname[:-3]
|
|
script_helper.assert_python_ok("-c", "mod = __import__(%a)" % name,
|
|
__isolated=False)
|
|
|
|
|
|
class CircularImportTests(unittest.TestCase):
|
|
|
|
"""See the docstrings of the modules being imported for the purpose of the
|
|
test."""
|
|
|
|
def tearDown(self):
|
|
"""Make sure no modules pre-exist in sys.modules which are being used to
|
|
test."""
|
|
for key in list(sys.modules.keys()):
|
|
if key.startswith('test.test_import.data.circular_imports'):
|
|
del sys.modules[key]
|
|
|
|
def test_direct(self):
|
|
try:
|
|
import test.test_import.data.circular_imports.basic
|
|
except ImportError:
|
|
self.fail('circular import through relative imports failed')
|
|
|
|
def test_indirect(self):
|
|
try:
|
|
import test.test_import.data.circular_imports.indirect
|
|
except ImportError:
|
|
self.fail('relative import in module contributing to circular '
|
|
'import failed')
|
|
|
|
def test_subpackage(self):
|
|
try:
|
|
import test.test_import.data.circular_imports.subpackage
|
|
except ImportError:
|
|
self.fail('circular import involving a subpackage failed')
|
|
|
|
def test_rebinding(self):
|
|
try:
|
|
import test.test_import.data.circular_imports.rebinding as rebinding
|
|
except ImportError:
|
|
self.fail('circular import with rebinding of module attribute failed')
|
|
from test.test_import.data.circular_imports.subpkg import util
|
|
self.assertIs(util.util, rebinding.util)
|
|
|
|
def test_binding(self):
|
|
try:
|
|
import test.test_import.data.circular_imports.binding
|
|
except ImportError:
|
|
self.fail('circular import with binding a submodule to a name failed')
|
|
|
|
def test_crossreference1(self):
|
|
import test.test_import.data.circular_imports.use
|
|
import test.test_import.data.circular_imports.source
|
|
|
|
def test_crossreference2(self):
|
|
with self.assertRaises(AttributeError) as cm:
|
|
import test.test_import.data.circular_imports.source
|
|
errmsg = str(cm.exception)
|
|
self.assertIn('test.test_import.data.circular_imports.source', errmsg)
|
|
self.assertIn('spam', errmsg)
|
|
self.assertIn('partially initialized module', errmsg)
|
|
self.assertIn('circular import', errmsg)
|
|
|
|
def test_circular_from_import(self):
|
|
with self.assertRaises(ImportError) as cm:
|
|
import test.test_import.data.circular_imports.from_cycle1
|
|
self.assertIn(
|
|
"cannot import name 'b' from partially initialized module "
|
|
"'test.test_import.data.circular_imports.from_cycle1' "
|
|
"(most likely due to a circular import)",
|
|
str(cm.exception),
|
|
)
|
|
|
|
def test_circular_import(self):
|
|
with self.assertRaisesRegex(
|
|
AttributeError,
|
|
r"partially initialized module 'test.test_import.data.circular_imports.import_cycle' "
|
|
r"from '.*' has no attribute 'some_attribute' \(most likely due to a circular import\)"
|
|
):
|
|
import test.test_import.data.circular_imports.import_cycle
|
|
|
|
def test_absolute_circular_submodule(self):
|
|
with self.assertRaises(AttributeError) as cm:
|
|
import test.test_import.data.circular_imports.subpkg2.parent
|
|
self.assertIn(
|
|
"cannot access submodule 'parent' of module "
|
|
"'test.test_import.data.circular_imports.subpkg2' "
|
|
"(most likely due to a circular import)",
|
|
str(cm.exception),
|
|
)
|
|
|
|
@requires_singlephase_init
|
|
@unittest.skipIf(_testsinglephase is None, "test requires _testsinglephase module")
|
|
def test_singlephase_circular(self):
|
|
"""Regression test for gh-123950
|
|
|
|
Import a single-phase-init module that imports itself
|
|
from the PyInit_* function (before it's added to sys.modules).
|
|
Manages its own cache (which is `static`, and so incompatible
|
|
with multiple interpreters or interpreter reset).
|
|
"""
|
|
name = '_testsinglephase_circular'
|
|
helper_name = 'test.test_import.data.circular_imports.singlephase'
|
|
with uncache(name, helper_name):
|
|
filename = _testsinglephase.__file__
|
|
# We don't put the module in sys.modules: that the *inner*
|
|
# import should do that.
|
|
mod = import_extension_from_file(name, filename,
|
|
put_in_sys_modules=False)
|
|
|
|
self.assertEqual(mod.helper_mod_name, helper_name)
|
|
self.assertIn(name, sys.modules)
|
|
self.assertIn(helper_name, sys.modules)
|
|
|
|
self.assertIn(name, sys.modules)
|
|
self.assertIn(helper_name, sys.modules)
|
|
self.assertNotIn(name, sys.modules)
|
|
self.assertNotIn(helper_name, sys.modules)
|
|
self.assertIs(mod.clear_static_var(), mod)
|
|
_testinternalcapi.clear_extension('_testsinglephase_circular',
|
|
mod.__spec__.origin)
|
|
|
|
def test_unwritable_module(self):
|
|
self.addCleanup(unload, "test.test_import.data.unwritable")
|
|
self.addCleanup(unload, "test.test_import.data.unwritable.x")
|
|
|
|
import test.test_import.data.unwritable as unwritable
|
|
with self.assertWarns(ImportWarning):
|
|
from test.test_import.data.unwritable import x
|
|
|
|
self.assertNotEqual(type(unwritable), ModuleType)
|
|
self.assertEqual(type(x), ModuleType)
|
|
with self.assertRaises(AttributeError):
|
|
unwritable.x = 42
|
|
|
|
|
|
class SubinterpImportTests(unittest.TestCase):
|
|
|
|
RUN_KWARGS = dict(
|
|
allow_fork=False,
|
|
allow_exec=False,
|
|
allow_threads=True,
|
|
allow_daemon_threads=False,
|
|
# Isolation-related config values aren't included here.
|
|
)
|
|
ISOLATED = dict(
|
|
use_main_obmalloc=False,
|
|
gil=2,
|
|
)
|
|
NOT_ISOLATED = {k: not v for k, v in ISOLATED.items()}
|
|
NOT_ISOLATED['gil'] = 1
|
|
|
|
@unittest.skipUnless(hasattr(os, "pipe"), "requires os.pipe()")
|
|
def pipe(self):
|
|
r, w = os.pipe()
|
|
self.addCleanup(os.close, r)
|
|
self.addCleanup(os.close, w)
|
|
if hasattr(os, 'set_blocking'):
|
|
os.set_blocking(r, False)
|
|
return (r, w)
|
|
|
|
def import_script(self, name, fd, filename=None, check_override=None):
|
|
override_text = ''
|
|
if check_override is not None:
|
|
override_text = f'''
|
|
import _imp
|
|
_imp._override_multi_interp_extensions_check({check_override})
|
|
'''
|
|
if filename:
|
|
# Apple extensions must be distributed as frameworks. This requires
|
|
# a specialist loader.
|
|
if is_apple_mobile:
|
|
loader = "AppleFrameworkLoader"
|
|
else:
|
|
loader = "ExtensionFileLoader"
|
|
|
|
return textwrap.dedent(f'''
|
|
from importlib.util import spec_from_loader, module_from_spec
|
|
from importlib.machinery import {loader}
|
|
import os, sys
|
|
{override_text}
|
|
loader = {loader}({name!r}, {filename!r})
|
|
spec = spec_from_loader({name!r}, loader)
|
|
try:
|
|
module = module_from_spec(spec)
|
|
loader.exec_module(module)
|
|
except ImportError as exc:
|
|
text = 'ImportError: ' + str(exc)
|
|
else:
|
|
text = 'okay'
|
|
os.write({fd}, text.encode('utf-8'))
|
|
''')
|
|
else:
|
|
return textwrap.dedent(f'''
|
|
import os, sys
|
|
{override_text}
|
|
try:
|
|
import {name}
|
|
except ImportError as exc:
|
|
text = 'ImportError: ' + str(exc)
|
|
else:
|
|
text = 'okay'
|
|
os.write({fd}, text.encode('utf-8'))
|
|
''')
|
|
|
|
def run_here(self, name, filename=None, *,
|
|
check_singlephase_setting=False,
|
|
check_singlephase_override=None,
|
|
isolated=False,
|
|
):
|
|
"""
|
|
Try importing the named module in a subinterpreter.
|
|
|
|
The subinterpreter will be in the current process.
|
|
The module will have already been imported in the main interpreter.
|
|
Thus, for extension/builtin modules, the module definition will
|
|
have been loaded already and cached globally.
|
|
|
|
"check_singlephase_setting" determines whether or not
|
|
the interpreter will be configured to check for modules
|
|
that are not compatible with use in multiple interpreters.
|
|
|
|
This should always return "okay" for all modules if the
|
|
setting is False (with no override).
|
|
"""
|
|
__import__(name)
|
|
|
|
kwargs = dict(
|
|
**self.RUN_KWARGS,
|
|
**(self.ISOLATED if isolated else self.NOT_ISOLATED),
|
|
check_multi_interp_extensions=check_singlephase_setting,
|
|
)
|
|
|
|
r, w = self.pipe()
|
|
script = self.import_script(name, w, filename,
|
|
check_singlephase_override)
|
|
|
|
ret = run_in_subinterp_with_config(script, **kwargs)
|
|
self.assertEqual(ret, 0)
|
|
return os.read(r, 100)
|
|
|
|
def check_compatible_here(self, name, filename=None, *,
|
|
strict=False,
|
|
isolated=False,
|
|
):
|
|
# Verify that the named module may be imported in a subinterpreter.
|
|
# (See run_here() for more info.)
|
|
out = self.run_here(name, filename,
|
|
check_singlephase_setting=strict,
|
|
isolated=isolated,
|
|
)
|
|
self.assertEqual(out, b'okay')
|
|
|
|
def check_incompatible_here(self, name, filename=None, *, isolated=False):
|
|
# Differences from check_compatible_here():
|
|
# * verify that import fails
|
|
# * "strict" is always True
|
|
out = self.run_here(name, filename,
|
|
check_singlephase_setting=True,
|
|
isolated=isolated,
|
|
)
|
|
self.assertEqual(
|
|
out.decode('utf-8'),
|
|
f'ImportError: module {name} does not support loading in subinterpreters',
|
|
)
|
|
|
|
def check_compatible_fresh(self, name, *, strict=False, isolated=False):
|
|
# Differences from check_compatible_here():
|
|
# * subinterpreter in a new process
|
|
# * module has never been imported before in that process
|
|
# * this tests importing the module for the first time
|
|
kwargs = dict(
|
|
**self.RUN_KWARGS,
|
|
**(self.ISOLATED if isolated else self.NOT_ISOLATED),
|
|
check_multi_interp_extensions=strict,
|
|
)
|
|
gil = kwargs['gil']
|
|
kwargs['gil'] = 'default' if gil == 0 else (
|
|
'shared' if gil == 1 else 'own' if gil == 2 else gil)
|
|
_, out, err = script_helper.assert_python_ok('-c', textwrap.dedent(f'''
|
|
import _testinternalcapi, sys
|
|
assert (
|
|
{name!r} in sys.builtin_module_names or
|
|
{name!r} not in sys.modules
|
|
), repr({name!r})
|
|
config = type(sys.implementation)(**{kwargs})
|
|
ret = _testinternalcapi.run_in_subinterp_with_config(
|
|
{self.import_script(name, "sys.stdout.fileno()")!r},
|
|
config,
|
|
)
|
|
assert ret == 0, ret
|
|
'''))
|
|
self.assertEqual(err, b'')
|
|
self.assertEqual(out, b'okay')
|
|
|
|
def check_incompatible_fresh(self, name, *, isolated=False):
|
|
# Differences from check_compatible_fresh():
|
|
# * verify that import fails
|
|
# * "strict" is always True
|
|
kwargs = dict(
|
|
**self.RUN_KWARGS,
|
|
**(self.ISOLATED if isolated else self.NOT_ISOLATED),
|
|
check_multi_interp_extensions=True,
|
|
)
|
|
gil = kwargs['gil']
|
|
kwargs['gil'] = 'default' if gil == 0 else (
|
|
'shared' if gil == 1 else 'own' if gil == 2 else gil)
|
|
_, out, err = script_helper.assert_python_ok('-c', textwrap.dedent(f'''
|
|
import _testinternalcapi, sys
|
|
assert {name!r} not in sys.modules, {name!r}
|
|
config = type(sys.implementation)(**{kwargs})
|
|
ret = _testinternalcapi.run_in_subinterp_with_config(
|
|
{self.import_script(name, "sys.stdout.fileno()")!r},
|
|
config,
|
|
)
|
|
assert ret == 0, ret
|
|
'''))
|
|
self.assertEqual(err, b'')
|
|
self.assertEqual(
|
|
out.decode('utf-8'),
|
|
f'ImportError: module {name} does not support loading in subinterpreters',
|
|
)
|
|
|
|
@unittest.skipIf(_testinternalcapi is None, "requires _testinternalcapi")
|
|
def test_builtin_compat(self):
|
|
# For now we avoid using sys or builtins
|
|
# since they still don't implement multi-phase init.
|
|
module = '_imp'
|
|
require_builtin(module)
|
|
if not Py_GIL_DISABLED:
|
|
with self.subTest(f'{module}: not strict'):
|
|
self.check_compatible_here(module, strict=False)
|
|
with self.subTest(f'{module}: strict, not fresh'):
|
|
self.check_compatible_here(module, strict=True)
|
|
|
|
@cpython_only
|
|
@unittest.skipIf(_testinternalcapi is None, "requires _testinternalcapi")
|
|
def test_frozen_compat(self):
|
|
module = '_frozen_importlib'
|
|
require_frozen(module, skip=True)
|
|
if __import__(module).__spec__.origin != 'frozen':
|
|
raise unittest.SkipTest(f'{module} is unexpectedly not frozen')
|
|
if not Py_GIL_DISABLED:
|
|
with self.subTest(f'{module}: not strict'):
|
|
self.check_compatible_here(module, strict=False)
|
|
with self.subTest(f'{module}: strict, not fresh'):
|
|
self.check_compatible_here(module, strict=True)
|
|
|
|
@requires_singlephase_init
|
|
def test_single_init_extension_compat(self):
|
|
module = '_testsinglephase'
|
|
require_extension(module)
|
|
with self.subTest(f'{module}: not strict'):
|
|
self.check_compatible_here(module, strict=False)
|
|
with self.subTest(f'{module}: strict, not fresh'):
|
|
self.check_incompatible_here(module)
|
|
with self.subTest(f'{module}: strict, fresh'):
|
|
self.check_incompatible_fresh(module)
|
|
with self.subTest(f'{module}: isolated, fresh'):
|
|
self.check_incompatible_fresh(module, isolated=True)
|
|
|
|
@unittest.skipIf(_testmultiphase is None, "test requires _testmultiphase module")
|
|
def test_multi_init_extension_compat(self):
|
|
# Module with Py_MOD_PER_INTERPRETER_GIL_SUPPORTED
|
|
module = '_testmultiphase'
|
|
require_extension(module)
|
|
|
|
if not Py_GIL_DISABLED:
|
|
with self.subTest(f'{module}: not strict'):
|
|
self.check_compatible_here(module, strict=False)
|
|
with self.subTest(f'{module}: strict, not fresh'):
|
|
self.check_compatible_here(module, strict=True)
|
|
with self.subTest(f'{module}: strict, fresh'):
|
|
self.check_compatible_fresh(module, strict=True)
|
|
|
|
@unittest.skipIf(_testmultiphase is None, "test requires _testmultiphase module")
|
|
def test_multi_init_extension_non_isolated_compat(self):
|
|
# Module with Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED
|
|
# and Py_MOD_GIL_NOT_USED
|
|
modname = '_test_non_isolated'
|
|
filename = _testmultiphase.__file__
|
|
module = import_extension_from_file(modname, filename)
|
|
|
|
require_extension(module)
|
|
with self.subTest(f'{modname}: isolated'):
|
|
self.check_incompatible_here(modname, filename, isolated=True)
|
|
with self.subTest(f'{modname}: not isolated'):
|
|
self.check_incompatible_here(modname, filename, isolated=False)
|
|
if not Py_GIL_DISABLED:
|
|
with self.subTest(f'{modname}: not strict'):
|
|
self.check_compatible_here(modname, filename, strict=False)
|
|
|
|
@unittest.skipIf(_testmultiphase is None, "test requires _testmultiphase module")
|
|
def test_multi_init_extension_per_interpreter_gil_compat(self):
|
|
|
|
# _test_shared_gil_only:
|
|
# Explicit Py_MOD_MULTIPLE_INTERPRETERS_SUPPORTED (default)
|
|
# and Py_MOD_GIL_NOT_USED
|
|
# _test_no_multiple_interpreter_slot:
|
|
# No Py_mod_multiple_interpreters slot
|
|
# and Py_MOD_GIL_NOT_USED
|
|
for modname in ('_test_shared_gil_only',
|
|
'_test_no_multiple_interpreter_slot'):
|
|
with self.subTest(modname=modname):
|
|
|
|
filename = _testmultiphase.__file__
|
|
module = import_extension_from_file(modname, filename)
|
|
|
|
require_extension(module)
|
|
with self.subTest(f'{modname}: isolated, strict'):
|
|
self.check_incompatible_here(modname, filename,
|
|
isolated=True)
|
|
with self.subTest(f'{modname}: not isolated, strict'):
|
|
self.check_compatible_here(modname, filename,
|
|
strict=True, isolated=False)
|
|
if not Py_GIL_DISABLED:
|
|
with self.subTest(f'{modname}: not isolated, not strict'):
|
|
self.check_compatible_here(
|
|
modname, filename, strict=False, isolated=False)
|
|
|
|
@unittest.skipIf(_testinternalcapi is None, "requires _testinternalcapi")
|
|
def test_python_compat(self):
|
|
module = 'threading'
|
|
require_pure_python(module)
|
|
if not Py_GIL_DISABLED:
|
|
with self.subTest(f'{module}: not strict'):
|
|
self.check_compatible_here(module, strict=False)
|
|
with self.subTest(f'{module}: strict, not fresh'):
|
|
self.check_compatible_here(module, strict=True)
|
|
with self.subTest(f'{module}: strict, fresh'):
|
|
self.check_compatible_fresh(module, strict=True)
|
|
|
|
@requires_singlephase_init
|
|
def test_singlephase_check_with_setting_and_override(self):
|
|
module = '_testsinglephase'
|
|
require_extension(module)
|
|
|
|
def check_compatible(setting, override):
|
|
out = self.run_here(
|
|
module,
|
|
check_singlephase_setting=setting,
|
|
check_singlephase_override=override,
|
|
)
|
|
self.assertEqual(out, b'okay')
|
|
|
|
def check_incompatible(setting, override):
|
|
out = self.run_here(
|
|
module,
|
|
check_singlephase_setting=setting,
|
|
check_singlephase_override=override,
|
|
)
|
|
self.assertNotEqual(out, b'okay')
|
|
|
|
with self.subTest('config: check enabled; override: enabled'):
|
|
check_incompatible(True, 1)
|
|
with self.subTest('config: check enabled; override: use config'):
|
|
check_incompatible(True, 0)
|
|
with self.subTest('config: check enabled; override: disabled'):
|
|
check_compatible(True, -1)
|
|
|
|
with self.subTest('config: check disabled; override: enabled'):
|
|
check_incompatible(False, 1)
|
|
with self.subTest('config: check disabled; override: use config'):
|
|
check_compatible(False, 0)
|
|
with self.subTest('config: check disabled; override: disabled'):
|
|
check_compatible(False, -1)
|
|
|
|
@unittest.skipIf(_testinternalcapi is None, "requires _testinternalcapi")
|
|
def test_isolated_config(self):
|
|
module = 'threading'
|
|
require_pure_python(module)
|
|
with self.subTest(f'{module}: strict, not fresh'):
|
|
self.check_compatible_here(module, strict=True, isolated=True)
|
|
with self.subTest(f'{module}: strict, fresh'):
|
|
self.check_compatible_fresh(module, strict=True, isolated=True)
|
|
|
|
@requires_subinterpreters
|
|
@requires_singlephase_init
|
|
def test_disallowed_reimport(self):
|
|
# See https://github.com/python/cpython/issues/104621.
|
|
script = textwrap.dedent('''
|
|
import _testsinglephase
|
|
print(_testsinglephase)
|
|
''')
|
|
interpid = _interpreters.create()
|
|
self.addCleanup(lambda: _interpreters.destroy(interpid))
|
|
|
|
excsnap = _interpreters.run_string(interpid, script)
|
|
self.assertIsNot(excsnap, None)
|
|
|
|
excsnap = _interpreters.run_string(interpid, script)
|
|
self.assertIsNot(excsnap, None)
|
|
|
|
@requires_subinterpreters
|
|
@unittest.skip("TODO: RUSTPYTHON; test requires _testsinglephase module")
|
|
def test_pyinit_function_raises_exception(self):
|
|
# gh-144601: PyInit functions that raised exceptions would cause a
|
|
# crash when imported from a subinterpreter.
|
|
import _testsinglephase
|
|
filename = _testsinglephase.__file__
|
|
script = f"""if True:
|
|
from test.test_import import import_extension_from_file
|
|
|
|
import_extension_from_file('_testsinglephase_raise_exception', {filename!r})"""
|
|
|
|
interp = _interpreters.create()
|
|
try:
|
|
with catch_unraisable_exception() as cm:
|
|
exception = _interpreters.run_string(interp, script)
|
|
unraisable = cm.unraisable
|
|
finally:
|
|
_interpreters.destroy(interp)
|
|
|
|
self.assertIsNotNone(exception)
|
|
self.assertIsNotNone(exception.type.__name__, "ImportError")
|
|
self.assertIsNotNone(exception.msg, "failed to import from subinterpreter due to exception")
|
|
self.assertIsNotNone(unraisable)
|
|
self.assertIs(unraisable.exc_type, RuntimeError)
|
|
self.assertEqual(str(unraisable.exc_value), "evil")
|
|
|
|
|
|
class TestSinglePhaseSnapshot(ModuleSnapshot):
|
|
"""A representation of a single-phase init module for testing.
|
|
|
|
Fields from ModuleSnapshot:
|
|
|
|
* id - id(mod)
|
|
* module - mod or a SimpleNamespace with __file__ & __spec__
|
|
* ns - a shallow copy of mod.__dict__
|
|
* ns_id - id(mod.__dict__)
|
|
* cached - sys.modules[name] (or None if not there or not snapshotable)
|
|
* cached_id - id(sys.modules[name]) (or None if not there)
|
|
|
|
Extra fields:
|
|
|
|
* summed - the result of calling "mod.sum(1, 2)"
|
|
* lookedup - the result of calling "mod.look_up_self()"
|
|
* lookedup_id - the object ID of self.lookedup
|
|
* state_initialized - the result of calling "mod.state_initialized()"
|
|
* init_count - (optional) the result of calling "mod.initialized_count()"
|
|
|
|
Overridden methods from ModuleSnapshot:
|
|
|
|
* from_module()
|
|
* parse()
|
|
|
|
Other methods from ModuleSnapshot:
|
|
|
|
* build_script()
|
|
* from_subinterp()
|
|
|
|
----
|
|
|
|
There are 5 modules in Modules/_testsinglephase.c:
|
|
|
|
* _testsinglephase
|
|
* has global state
|
|
* extra loads skip the init function, copy def.m_base.m_copy
|
|
* counts calls to init function
|
|
* _testsinglephase_basic_wrapper
|
|
* _testsinglephase by another name (and separate init function symbol)
|
|
* _testsinglephase_basic_copy
|
|
* same as _testsinglephase but with own def (and init func)
|
|
* _testsinglephase_with_reinit
|
|
* has no global or module state
|
|
* mod.state_initialized returns None
|
|
* an extra load in the main interpreter calls the cached init func
|
|
* an extra load in legacy subinterpreters does a full load
|
|
* _testsinglephase_with_state
|
|
* has module state
|
|
* an extra load in the main interpreter calls the cached init func
|
|
* an extra load in legacy subinterpreters does a full load
|
|
|
|
(See Modules/_testsinglephase.c for more info.)
|
|
|
|
For all those modules, the snapshot after the initial load (not in
|
|
the global extensions cache) would look like the following:
|
|
|
|
* initial load
|
|
* id: ID of nww module object
|
|
* ns: exactly what the module init put there
|
|
* ns_id: ID of new module's __dict__
|
|
* cached_id: same as self.id
|
|
* summed: 3 (never changes)
|
|
* lookedup_id: same as self.id
|
|
* state_initialized: a timestamp between the time of the load
|
|
and the time of the snapshot
|
|
* init_count: 1 (None for _testsinglephase_with_reinit)
|
|
|
|
For the other scenarios it varies.
|
|
|
|
For the _testsinglephase, _testsinglephase_basic_wrapper, and
|
|
_testsinglephase_basic_copy modules, the snapshot should look
|
|
like the following:
|
|
|
|
* reloaded
|
|
* id: no change
|
|
* ns: matches what the module init function put there,
|
|
including the IDs of all contained objects,
|
|
plus any extra attributes added before the reload
|
|
* ns_id: no change
|
|
* cached_id: no change
|
|
* lookedup_id: no change
|
|
* state_initialized: no change
|
|
* init_count: no change
|
|
* already loaded
|
|
* (same as initial load except for ns and state_initialized)
|
|
* ns: matches the initial load, incl. IDs of contained objects
|
|
* state_initialized: no change from initial load
|
|
|
|
For _testsinglephase_with_reinit:
|
|
|
|
* reloaded: same as initial load (old module & ns is discarded)
|
|
* already loaded: same as initial load (old module & ns is discarded)
|
|
|
|
For _testsinglephase_with_state:
|
|
|
|
* reloaded
|
|
* (same as initial load (old module & ns is discarded),
|
|
except init_count)
|
|
* init_count: increase by 1
|
|
* already loaded: same as reloaded
|
|
"""
|
|
|
|
@classmethod
|
|
def from_module(cls, mod):
|
|
self = super().from_module(mod)
|
|
self.summed = mod.sum(1, 2)
|
|
self.lookedup = mod.look_up_self()
|
|
self.lookedup_id = id(self.lookedup)
|
|
self.state_initialized = mod.state_initialized()
|
|
if hasattr(mod, 'initialized_count'):
|
|
self.init_count = mod.initialized_count()
|
|
return self
|
|
|
|
SCRIPT_BODY = ModuleSnapshot.SCRIPT_BODY + textwrap.dedent('''
|
|
snapshot['module'].update(dict(
|
|
int_const=mod.int_const,
|
|
str_const=mod.str_const,
|
|
_module_initialized=mod._module_initialized,
|
|
))
|
|
snapshot.update(dict(
|
|
summed=mod.sum(1, 2),
|
|
lookedup_id=id(mod.look_up_self()),
|
|
state_initialized=mod.state_initialized(),
|
|
init_count=mod.initialized_count(),
|
|
has_spam=hasattr(mod, 'spam'),
|
|
spam=getattr(mod, 'spam', None),
|
|
))
|
|
''').rstrip()
|
|
|
|
@classmethod
|
|
def parse(cls, text):
|
|
self = super().parse(text)
|
|
if not self.has_spam:
|
|
del self.spam
|
|
del self.has_spam
|
|
return self
|
|
|
|
|
|
@requires_singlephase_init
|
|
class SinglephaseInitTests(unittest.TestCase):
|
|
|
|
NAME = '_testsinglephase'
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
spec = importlib.util.find_spec(cls.NAME)
|
|
cls.LOADER = type(spec.loader)
|
|
|
|
# Apple extensions must be distributed as frameworks. This requires
|
|
# a specialist loader, and we need to differentiate between the
|
|
# spec.origin and the original file location.
|
|
if is_apple_mobile:
|
|
assert cls.LOADER is AppleFrameworkLoader
|
|
|
|
cls.ORIGIN = spec.origin
|
|
with open(spec.origin + ".origin", "r") as f:
|
|
cls.FILE = os.path.join(
|
|
os.path.dirname(sys.executable),
|
|
f.read().strip()
|
|
)
|
|
else:
|
|
assert cls.LOADER is ExtensionFileLoader
|
|
|
|
cls.ORIGIN = spec.origin
|
|
cls.FILE = spec.origin
|
|
|
|
# Start fresh.
|
|
cls.clean_up()
|
|
|
|
def tearDown(self):
|
|
# Clean up the module.
|
|
self.clean_up()
|
|
|
|
@classmethod
|
|
def clean_up(cls):
|
|
name = cls.NAME
|
|
if name in sys.modules:
|
|
if hasattr(sys.modules[name], '_clear_globals'):
|
|
assert sys.modules[name].__file__ == cls.FILE, \
|
|
f"{sys.modules[name].__file__} != {cls.FILE}"
|
|
|
|
sys.modules[name]._clear_globals()
|
|
del sys.modules[name]
|
|
# Clear all internally cached data for the extension.
|
|
_testinternalcapi.clear_extension(name, cls.ORIGIN)
|
|
|
|
#########################
|
|
# helpers
|
|
|
|
def add_module_cleanup(self, name):
|
|
def clean_up():
|
|
# Clear all internally cached data for the extension.
|
|
_testinternalcapi.clear_extension(name, self.ORIGIN)
|
|
self.addCleanup(clean_up)
|
|
|
|
def _load_dynamic(self, name, path):
|
|
"""
|
|
Load an extension module.
|
|
"""
|
|
# This is essentially copied from the old imp module.
|
|
from importlib._bootstrap import _load
|
|
loader = self.LOADER(name, path)
|
|
|
|
# Issue bpo-24748: Skip the sys.modules check in _load_module_shim;
|
|
# always load new extension.
|
|
spec = importlib.util.spec_from_file_location(name, path,
|
|
loader=loader)
|
|
return _load(spec)
|
|
|
|
def load(self, name):
|
|
try:
|
|
already_loaded = self.already_loaded
|
|
except AttributeError:
|
|
already_loaded = self.already_loaded = {}
|
|
assert name not in already_loaded
|
|
mod = self._load_dynamic(name, self.ORIGIN)
|
|
self.assertNotIn(mod, already_loaded.values())
|
|
already_loaded[name] = mod
|
|
return types.SimpleNamespace(
|
|
name=name,
|
|
module=mod,
|
|
snapshot=TestSinglePhaseSnapshot.from_module(mod),
|
|
)
|
|
|
|
def re_load(self, name, mod):
|
|
assert sys.modules[name] is mod
|
|
assert mod.__dict__ == mod.__dict__
|
|
reloaded = self._load_dynamic(name, self.ORIGIN)
|
|
return types.SimpleNamespace(
|
|
name=name,
|
|
module=reloaded,
|
|
snapshot=TestSinglePhaseSnapshot.from_module(reloaded),
|
|
)
|
|
|
|
# subinterpreters
|
|
|
|
def add_subinterpreter(self):
|
|
interpid = _interpreters.create('legacy')
|
|
def ensure_destroyed():
|
|
try:
|
|
_interpreters.destroy(interpid)
|
|
except _interpreters.InterpreterNotFoundError:
|
|
pass
|
|
self.addCleanup(ensure_destroyed)
|
|
_interpreters.exec(interpid, textwrap.dedent('''
|
|
import sys
|
|
import _testinternalcapi
|
|
'''))
|
|
def clean_up():
|
|
_interpreters.exec(interpid, textwrap.dedent(f'''
|
|
name = {self.NAME!r}
|
|
if name in sys.modules:
|
|
sys.modules.pop(name)._clear_globals()
|
|
_testinternalcapi.clear_extension(name, {self.ORIGIN!r})
|
|
'''))
|
|
_interpreters.destroy(interpid)
|
|
self.addCleanup(clean_up)
|
|
return interpid
|
|
|
|
def import_in_subinterp(self, interpid=None, *,
|
|
postscript=None,
|
|
postcleanup=False,
|
|
):
|
|
name = self.NAME
|
|
|
|
if postcleanup:
|
|
import_ = 'import _testinternalcapi' if interpid is None else ''
|
|
postcleanup = f'''
|
|
{import_}
|
|
mod._clear_globals()
|
|
_testinternalcapi.clear_extension(name, {self.ORIGIN!r})
|
|
'''
|
|
|
|
try:
|
|
pipe = self._pipe
|
|
except AttributeError:
|
|
r, w = pipe = self._pipe = os.pipe()
|
|
self.addCleanup(os.close, r)
|
|
self.addCleanup(os.close, w)
|
|
|
|
snapshot = TestSinglePhaseSnapshot.from_subinterp(
|
|
name,
|
|
interpid,
|
|
pipe=pipe,
|
|
import_first=True,
|
|
postscript=postscript,
|
|
postcleanup=postcleanup,
|
|
)
|
|
|
|
return types.SimpleNamespace(
|
|
name=name,
|
|
module=None,
|
|
snapshot=snapshot,
|
|
)
|
|
|
|
# checks
|
|
|
|
def check_common(self, loaded):
|
|
isolated = False
|
|
|
|
mod = loaded.module
|
|
if not mod:
|
|
# It came from a subinterpreter.
|
|
isolated = True
|
|
mod = loaded.snapshot.module
|
|
# mod.__name__ might not match, but the spec will.
|
|
self.assertEqual(mod.__spec__.name, loaded.name)
|
|
self.assertEqual(mod.__file__, self.FILE)
|
|
self.assertEqual(mod.__spec__.origin, self.ORIGIN)
|
|
if not isolated:
|
|
self.assertIsSubclass(mod.error, Exception)
|
|
self.assertEqual(mod.int_const, 1969)
|
|
self.assertEqual(mod.str_const, 'something different')
|
|
self.assertIsInstance(mod._module_initialized, float)
|
|
self.assertGreater(mod._module_initialized, 0)
|
|
|
|
snap = loaded.snapshot
|
|
self.assertEqual(snap.summed, 3)
|
|
if snap.state_initialized is not None:
|
|
self.assertIsInstance(snap.state_initialized, float)
|
|
self.assertGreater(snap.state_initialized, 0)
|
|
if isolated:
|
|
# The "looked up" module is interpreter-specific
|
|
# (interp->imports.modules_by_index was set for the module).
|
|
self.assertEqual(snap.lookedup_id, snap.id)
|
|
self.assertEqual(snap.cached_id, snap.id)
|
|
with self.assertRaises(AttributeError):
|
|
snap.spam
|
|
else:
|
|
self.assertIs(snap.lookedup, mod)
|
|
self.assertIs(snap.cached, mod)
|
|
|
|
def check_direct(self, loaded):
|
|
# The module has its own PyModuleDef, with a matching name.
|
|
self.assertEqual(loaded.module.__name__, loaded.name)
|
|
self.assertIs(loaded.snapshot.lookedup, loaded.module)
|
|
|
|
def check_indirect(self, loaded, orig):
|
|
# The module re-uses another's PyModuleDef, with a different name.
|
|
assert orig is not loaded.module
|
|
assert orig.__name__ != loaded.name
|
|
self.assertNotEqual(loaded.module.__name__, loaded.name)
|
|
self.assertIs(loaded.snapshot.lookedup, loaded.module)
|
|
|
|
def check_basic(self, loaded, expected_init_count):
|
|
# m_size == -1
|
|
# The module loads fresh the first time and copies m_copy after.
|
|
snap = loaded.snapshot
|
|
self.assertIsNot(snap.state_initialized, None)
|
|
self.assertIsInstance(snap.init_count, int)
|
|
self.assertGreater(snap.init_count, 0)
|
|
self.assertEqual(snap.init_count, expected_init_count)
|
|
|
|
def check_with_reinit(self, loaded):
|
|
# m_size >= 0
|
|
# The module loads fresh every time.
|
|
pass
|
|
|
|
def check_fresh(self, loaded):
|
|
"""
|
|
The module had not been loaded before (at least since fully reset).
|
|
"""
|
|
snap = loaded.snapshot
|
|
# The module's init func was run.
|
|
# A copy of the module's __dict__ was stored in def->m_base.m_copy.
|
|
# The previous m_copy was deleted first.
|
|
# _PyRuntime.imports.extensions was set.
|
|
self.assertEqual(snap.init_count, 1)
|
|
# The global state was initialized.
|
|
# The module attrs were initialized from that state.
|
|
self.assertEqual(snap.module._module_initialized,
|
|
snap.state_initialized)
|
|
|
|
def check_semi_fresh(self, loaded, base, prev):
|
|
"""
|
|
The module had been loaded before and then reset
|
|
(but the module global state wasn't).
|
|
"""
|
|
snap = loaded.snapshot
|
|
# The module's init func was run again.
|
|
# A copy of the module's __dict__ was stored in def->m_base.m_copy.
|
|
# The previous m_copy was deleted first.
|
|
# The module globals did not get reset.
|
|
self.assertNotEqual(snap.id, base.snapshot.id)
|
|
self.assertNotEqual(snap.id, prev.snapshot.id)
|
|
self.assertEqual(snap.init_count, prev.snapshot.init_count + 1)
|
|
# The global state was updated.
|
|
# The module attrs were initialized from that state.
|
|
self.assertEqual(snap.module._module_initialized,
|
|
snap.state_initialized)
|
|
self.assertNotEqual(snap.state_initialized,
|
|
base.snapshot.state_initialized)
|
|
self.assertNotEqual(snap.state_initialized,
|
|
prev.snapshot.state_initialized)
|
|
|
|
def check_copied(self, loaded, base):
|
|
"""
|
|
The module had been loaded before and never reset.
|
|
"""
|
|
snap = loaded.snapshot
|
|
# The module's init func was not run again.
|
|
# The interpreter copied m_copy, as set by the other interpreter,
|
|
# with objects owned by the other interpreter.
|
|
# The module globals did not get reset.
|
|
self.assertNotEqual(snap.id, base.snapshot.id)
|
|
self.assertEqual(snap.init_count, base.snapshot.init_count)
|
|
# The global state was not updated since the init func did not run.
|
|
# The module attrs were not directly initialized from that state.
|
|
# The state and module attrs still match the previous loading.
|
|
self.assertEqual(snap.module._module_initialized,
|
|
snap.state_initialized)
|
|
self.assertEqual(snap.state_initialized,
|
|
base.snapshot.state_initialized)
|
|
|
|
#########################
|
|
# the tests
|
|
|
|
def test_cleared_globals(self):
|
|
loaded = self.load(self.NAME)
|
|
_testsinglephase = loaded.module
|
|
init_before = _testsinglephase.state_initialized()
|
|
|
|
_testsinglephase._clear_globals()
|
|
init_after = _testsinglephase.state_initialized()
|
|
init_count = _testsinglephase.initialized_count()
|
|
|
|
self.assertGreater(init_before, 0)
|
|
self.assertEqual(init_after, 0)
|
|
self.assertEqual(init_count, -1)
|
|
|
|
def test_variants(self):
|
|
# Exercise the most meaningful variants described in Python/import.c.
|
|
self.maxDiff = None
|
|
|
|
# Check the "basic" module.
|
|
|
|
name = self.NAME
|
|
expected_init_count = 1
|
|
with self.subTest(name):
|
|
loaded = self.load(name)
|
|
|
|
self.check_common(loaded)
|
|
self.check_direct(loaded)
|
|
self.check_basic(loaded, expected_init_count)
|
|
basic = loaded.module
|
|
|
|
# Check its indirect variants.
|
|
|
|
name = f'{self.NAME}_basic_wrapper'
|
|
self.add_module_cleanup(name)
|
|
expected_init_count += 1
|
|
with self.subTest(name):
|
|
loaded = self.load(name)
|
|
|
|
self.check_common(loaded)
|
|
self.check_indirect(loaded, basic)
|
|
self.check_basic(loaded, expected_init_count)
|
|
|
|
# Currently PyState_AddModule() always replaces the cached module.
|
|
self.assertIs(basic.look_up_self(), loaded.module)
|
|
self.assertEqual(basic.initialized_count(), expected_init_count)
|
|
|
|
# The cached module shouldn't change after this point.
|
|
basic_lookedup = loaded.module
|
|
|
|
# Check its direct variant.
|
|
|
|
name = f'{self.NAME}_basic_copy'
|
|
self.add_module_cleanup(name)
|
|
expected_init_count += 1
|
|
with self.subTest(name):
|
|
loaded = self.load(name)
|
|
|
|
self.check_common(loaded)
|
|
self.check_direct(loaded)
|
|
self.check_basic(loaded, expected_init_count)
|
|
|
|
# This should change the cached module for _testsinglephase.
|
|
self.assertIs(basic.look_up_self(), basic_lookedup)
|
|
self.assertEqual(basic.initialized_count(), expected_init_count)
|
|
|
|
# Check the non-basic variant that has no state.
|
|
|
|
name = f'{self.NAME}_with_reinit'
|
|
self.add_module_cleanup(name)
|
|
with self.subTest(name):
|
|
loaded = self.load(name)
|
|
|
|
self.check_common(loaded)
|
|
self.assertIs(loaded.snapshot.state_initialized, None)
|
|
self.check_direct(loaded)
|
|
self.check_with_reinit(loaded)
|
|
|
|
# This should change the cached module for _testsinglephase.
|
|
self.assertIs(basic.look_up_self(), basic_lookedup)
|
|
self.assertEqual(basic.initialized_count(), expected_init_count)
|
|
|
|
# Check the basic variant that has state.
|
|
|
|
name = f'{self.NAME}_with_state'
|
|
self.add_module_cleanup(name)
|
|
with self.subTest(name):
|
|
loaded = self.load(name)
|
|
self.addCleanup(loaded.module._clear_module_state)
|
|
|
|
self.check_common(loaded)
|
|
self.assertIsNot(loaded.snapshot.state_initialized, None)
|
|
self.check_direct(loaded)
|
|
self.check_with_reinit(loaded)
|
|
|
|
# This should change the cached module for _testsinglephase.
|
|
self.assertIs(basic.look_up_self(), basic_lookedup)
|
|
self.assertEqual(basic.initialized_count(), expected_init_count)
|
|
|
|
def test_basic_reloaded(self):
|
|
# m_copy is copied into the existing module object.
|
|
# Global state is not changed.
|
|
self.maxDiff = None
|
|
|
|
for name in [
|
|
self.NAME, # the "basic" module
|
|
f'{self.NAME}_basic_wrapper', # the indirect variant
|
|
f'{self.NAME}_basic_copy', # the direct variant
|
|
]:
|
|
self.add_module_cleanup(name)
|
|
with self.subTest(name):
|
|
loaded = self.load(name)
|
|
reloaded = self.re_load(name, loaded.module)
|
|
|
|
self.check_common(loaded)
|
|
self.check_common(reloaded)
|
|
|
|
# Make sure the original __dict__ did not get replaced.
|
|
self.assertEqual(id(loaded.module.__dict__),
|
|
loaded.snapshot.ns_id)
|
|
self.assertEqual(loaded.snapshot.ns.__dict__,
|
|
loaded.module.__dict__)
|
|
|
|
self.assertEqual(reloaded.module.__spec__.name, reloaded.name)
|
|
self.assertEqual(reloaded.module.__name__,
|
|
reloaded.snapshot.ns.__name__)
|
|
|
|
self.assertIs(reloaded.module, loaded.module)
|
|
self.assertIs(reloaded.module.__dict__, loaded.module.__dict__)
|
|
# It only happens to be the same but that's good enough here.
|
|
# We really just want to verify that the re-loaded attrs
|
|
# didn't change.
|
|
self.assertIs(reloaded.snapshot.lookedup,
|
|
loaded.snapshot.lookedup)
|
|
self.assertEqual(reloaded.snapshot.state_initialized,
|
|
loaded.snapshot.state_initialized)
|
|
self.assertEqual(reloaded.snapshot.init_count,
|
|
loaded.snapshot.init_count)
|
|
|
|
self.assertIs(reloaded.snapshot.cached, reloaded.module)
|
|
|
|
def test_with_reinit_reloaded(self):
|
|
# The module's m_init func is run again.
|
|
self.maxDiff = None
|
|
|
|
# Keep a reference around.
|
|
basic = self.load(self.NAME)
|
|
|
|
for name, has_state in [
|
|
(f'{self.NAME}_with_reinit', False), # m_size == 0
|
|
(f'{self.NAME}_with_state', True), # m_size > 0
|
|
]:
|
|
self.add_module_cleanup(name)
|
|
with self.subTest(name=name, has_state=has_state):
|
|
loaded = self.load(name)
|
|
if has_state:
|
|
self.addCleanup(loaded.module._clear_module_state)
|
|
|
|
reloaded = self.re_load(name, loaded.module)
|
|
if has_state:
|
|
self.addCleanup(reloaded.module._clear_module_state)
|
|
|
|
self.check_common(loaded)
|
|
self.check_common(reloaded)
|
|
|
|
# Make sure the original __dict__ did not get replaced.
|
|
self.assertEqual(id(loaded.module.__dict__),
|
|
loaded.snapshot.ns_id)
|
|
self.assertEqual(loaded.snapshot.ns.__dict__,
|
|
loaded.module.__dict__)
|
|
|
|
self.assertEqual(reloaded.module.__spec__.name, reloaded.name)
|
|
self.assertEqual(reloaded.module.__name__,
|
|
reloaded.snapshot.ns.__name__)
|
|
|
|
self.assertIsNot(reloaded.module, loaded.module)
|
|
self.assertNotEqual(reloaded.module.__dict__,
|
|
loaded.module.__dict__)
|
|
self.assertIs(reloaded.snapshot.lookedup, reloaded.module)
|
|
if loaded.snapshot.state_initialized is None:
|
|
self.assertIs(reloaded.snapshot.state_initialized, None)
|
|
else:
|
|
self.assertGreater(reloaded.snapshot.state_initialized,
|
|
loaded.snapshot.state_initialized)
|
|
|
|
self.assertIs(reloaded.snapshot.cached, reloaded.module)
|
|
|
|
@unittest.skipIf(_testinternalcapi is None, "requires _testinternalcapi")
|
|
def test_check_state_first(self):
|
|
for variant in ['', '_with_reinit', '_with_state']:
|
|
name = f'{self.NAME}{variant}_check_cache_first'
|
|
with self.subTest(name):
|
|
mod = self._load_dynamic(name, self.ORIGIN)
|
|
self.assertEqual(mod.__name__, name)
|
|
sys.modules.pop(name, None)
|
|
_testinternalcapi.clear_extension(name, self.ORIGIN)
|
|
|
|
# Currently, for every single-phrase init module loaded
|
|
# in multiple interpreters, those interpreters share a
|
|
# PyModuleDef for that object, which can be a problem.
|
|
# Also, we test with a single-phase module that has global state,
|
|
# which is shared by all interpreters.
|
|
|
|
@no_rerun(reason="module state is not cleared (see gh-140657)")
|
|
@requires_subinterpreters
|
|
def test_basic_multiple_interpreters_main_no_reset(self):
|
|
# without resetting; already loaded in main interpreter
|
|
|
|
# At this point:
|
|
# * alive in 0 interpreters
|
|
# * module def may or may not be loaded already
|
|
# * module def not in _PyRuntime.imports.extensions
|
|
# * mod init func has not run yet (since reset, at least)
|
|
# * m_copy not set (hasn't been loaded yet or already cleared)
|
|
# * module's global state has not been initialized yet
|
|
# (or already cleared)
|
|
|
|
main_loaded = self.load(self.NAME)
|
|
_testsinglephase = main_loaded.module
|
|
# Attrs set after loading are not in m_copy.
|
|
_testsinglephase.spam = 'spam, spam, spam, spam, eggs, and spam'
|
|
|
|
self.check_common(main_loaded)
|
|
self.check_fresh(main_loaded)
|
|
|
|
interpid1 = self.add_subinterpreter()
|
|
interpid2 = self.add_subinterpreter()
|
|
|
|
# At this point:
|
|
# * alive in 1 interpreter (main)
|
|
# * module def in _PyRuntime.imports.extensions
|
|
# * mod init func ran for the first time (since reset, at least)
|
|
# * m_copy was copied from the main interpreter (was NULL)
|
|
# * module's global state was initialized
|
|
|
|
# Use an interpreter that gets destroyed right away.
|
|
loaded = self.import_in_subinterp()
|
|
self.check_common(loaded)
|
|
self.check_copied(loaded, main_loaded)
|
|
|
|
# At this point:
|
|
# * alive in 1 interpreter (main)
|
|
# * module def still in _PyRuntime.imports.extensions
|
|
# * mod init func ran again
|
|
# * m_copy is NULL (cleared when the interpreter was destroyed)
|
|
# (was from main interpreter)
|
|
# * module's global state was updated, not reset
|
|
|
|
# Use a subinterpreter that sticks around.
|
|
loaded = self.import_in_subinterp(interpid1)
|
|
self.check_common(loaded)
|
|
self.check_copied(loaded, main_loaded)
|
|
|
|
# At this point:
|
|
# * alive in 2 interpreters (main, interp1)
|
|
# * module def still in _PyRuntime.imports.extensions
|
|
# * mod init func ran again
|
|
# * m_copy was copied from interp1
|
|
# * module's global state was updated, not reset
|
|
|
|
# Use a subinterpreter while the previous one is still alive.
|
|
loaded = self.import_in_subinterp(interpid2)
|
|
self.check_common(loaded)
|
|
self.check_copied(loaded, main_loaded)
|
|
|
|
# At this point:
|
|
# * alive in 3 interpreters (main, interp1, interp2)
|
|
# * module def still in _PyRuntime.imports.extensions
|
|
# * mod init func ran again
|
|
# * m_copy was copied from interp2 (was from interp1)
|
|
# * module's global state was updated, not reset
|
|
|
|
@no_rerun(reason="rerun not possible; module state is never cleared (see gh-102251)")
|
|
@requires_subinterpreters
|
|
def test_basic_multiple_interpreters_deleted_no_reset(self):
|
|
# without resetting; already loaded in a deleted interpreter
|
|
|
|
if Py_TRACE_REFS:
|
|
# It's a Py_TRACE_REFS build.
|
|
# This test breaks interpreter isolation a little,
|
|
# which causes problems on Py_TRACE_REF builds.
|
|
raise unittest.SkipTest('crashes on Py_TRACE_REFS builds')
|
|
|
|
# At this point:
|
|
# * alive in 0 interpreters
|
|
# * module def may or may not be loaded already
|
|
# * module def not in _PyRuntime.imports.extensions
|
|
# * mod init func has not run yet (since reset, at least)
|
|
# * m_copy not set (hasn't been loaded yet or already cleared)
|
|
# * module's global state has not been initialized yet
|
|
# (or already cleared)
|
|
|
|
interpid1 = self.add_subinterpreter()
|
|
interpid2 = self.add_subinterpreter()
|
|
|
|
# First, load in the main interpreter but then completely clear it.
|
|
loaded_main = self.load(self.NAME)
|
|
loaded_main.module._clear_globals()
|
|
_testinternalcapi.clear_extension(self.NAME, self.ORIGIN)
|
|
|
|
# At this point:
|
|
# * alive in 0 interpreters
|
|
# * module def loaded already
|
|
# * module def was in _PyRuntime.imports.extensions, but cleared
|
|
# * mod init func ran for the first time (since reset, at least)
|
|
# * m_copy was set, but cleared (was NULL)
|
|
# * module's global state was initialized but cleared
|
|
|
|
# Start with an interpreter that gets destroyed right away.
|
|
base = self.import_in_subinterp(
|
|
postscript='''
|
|
# Attrs set after loading are not in m_copy.
|
|
mod.spam = 'spam, spam, mash, spam, eggs, and spam'
|
|
''')
|
|
self.check_common(base)
|
|
self.check_fresh(base)
|
|
|
|
# At this point:
|
|
# * alive in 0 interpreters
|
|
# * module def in _PyRuntime.imports.extensions
|
|
# * mod init func ran for the first time (since reset)
|
|
# * m_copy is still set (owned by main interpreter)
|
|
# * module's global state was initialized, not reset
|
|
|
|
# Use a subinterpreter that sticks around.
|
|
loaded_interp1 = self.import_in_subinterp(interpid1)
|
|
self.check_common(loaded_interp1)
|
|
self.check_copied(loaded_interp1, base)
|
|
|
|
# At this point:
|
|
# * alive in 1 interpreter (interp1)
|
|
# * module def still in _PyRuntime.imports.extensions
|
|
# * mod init func did not run again
|
|
# * m_copy was not changed
|
|
# * module's global state was not touched
|
|
|
|
# Use a subinterpreter while the previous one is still alive.
|
|
loaded_interp2 = self.import_in_subinterp(interpid2)
|
|
self.check_common(loaded_interp2)
|
|
self.check_copied(loaded_interp2, loaded_interp1)
|
|
|
|
# At this point:
|
|
# * alive in 2 interpreters (interp1, interp2)
|
|
# * module def still in _PyRuntime.imports.extensions
|
|
# * mod init func did not run again
|
|
# * m_copy was not changed
|
|
# * module's global state was not touched
|
|
|
|
@requires_subinterpreters
|
|
def test_basic_multiple_interpreters_reset_each(self):
|
|
# resetting between each interpreter
|
|
|
|
# At this point:
|
|
# * alive in 0 interpreters
|
|
# * module def may or may not be loaded already
|
|
# * module def not in _PyRuntime.imports.extensions
|
|
# * mod init func has not run yet (since reset, at least)
|
|
# * m_copy not set (hasn't been loaded yet or already cleared)
|
|
# * module's global state has not been initialized yet
|
|
# (or already cleared)
|
|
|
|
interpid1 = self.add_subinterpreter()
|
|
interpid2 = self.add_subinterpreter()
|
|
|
|
# Use an interpreter that gets destroyed right away.
|
|
loaded = self.import_in_subinterp(
|
|
postscript='''
|
|
# Attrs set after loading are not in m_copy.
|
|
mod.spam = 'spam, spam, mash, spam, eggs, and spam'
|
|
''',
|
|
postcleanup=True,
|
|
)
|
|
self.check_common(loaded)
|
|
self.check_fresh(loaded)
|
|
|
|
# At this point:
|
|
# * alive in 0 interpreters
|
|
# * module def in _PyRuntime.imports.extensions
|
|
# * mod init func ran for the first time (since reset, at least)
|
|
# * m_copy is NULL (cleared when the interpreter was destroyed)
|
|
# * module's global state was initialized, not reset
|
|
|
|
# Use a subinterpreter that sticks around.
|
|
loaded = self.import_in_subinterp(interpid1, postcleanup=True)
|
|
self.check_common(loaded)
|
|
self.check_fresh(loaded)
|
|
|
|
# At this point:
|
|
# * alive in 1 interpreter (interp1)
|
|
# * module def still in _PyRuntime.imports.extensions
|
|
# * mod init func ran again
|
|
# * m_copy was copied from interp1 (was NULL)
|
|
# * module's global state was initialized, not reset
|
|
|
|
# Use a subinterpreter while the previous one is still alive.
|
|
loaded = self.import_in_subinterp(interpid2, postcleanup=True)
|
|
self.check_common(loaded)
|
|
self.check_fresh(loaded)
|
|
|
|
# At this point:
|
|
# * alive in 2 interpreters (interp2, interp2)
|
|
# * module def still in _PyRuntime.imports.extensions
|
|
# * mod init func ran again
|
|
# * m_copy was copied from interp2 (was from interp1)
|
|
# * module's global state was initialized, not reset
|
|
|
|
|
|
@cpython_only
|
|
class TestMagicNumber(unittest.TestCase):
|
|
def test_magic_number_endianness(self):
|
|
magic_number_bytes = _imp.pyc_magic_number_token.to_bytes(4, 'little')
|
|
self.assertEqual(magic_number_bytes[2:], b'\r\n')
|
|
# Starting with Python 3.11, Python 3.n starts with magic number 2900+50n.
|
|
magic_number = int.from_bytes(magic_number_bytes[:2], 'little')
|
|
start = 2900 + sys.version_info.minor * 50
|
|
self.assertIn(magic_number, range(start, start + 50))
|
|
|
|
|
|
if __name__ == '__main__':
|
|
# Test needs to be a package, so we can do relative imports.
|
|
unittest.main()
|