File size: 10,161 Bytes
059cd4a |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 |
#!/usr/bin/env python
# Author: Leonardo Gama (@leogama)
# Copyright (c) 2022-2024 The Uncertainty Quantification Foundation.
# License: 3-clause BSD. The full license text is available at:
# - https://github.com/uqfoundation/dill/blob/master/LICENSE
import atexit
import os
import sys
import __main__
from contextlib import suppress
from io import BytesIO
import dill
session_file = os.path.join(os.path.dirname(__file__), 'session-refimported-%s.pkl')
###################
# Child process #
###################
def _error_line(error, obj, refimported):
import traceback
line = traceback.format_exc().splitlines()[-2].replace('[obj]', '['+repr(obj)+']')
return "while testing (with refimported=%s): %s" % (refimported, line.lstrip())
if __name__ == '__main__' and len(sys.argv) >= 3 and sys.argv[1] == '--child':
# Test session loading in a fresh interpreter session.
refimported = (sys.argv[2] == 'True')
dill.load_module(session_file % refimported, module='__main__')
def test_modules(refimported):
# FIXME: In this test setting with CPython 3.7, 'calendar' is not included
# in sys.modules, independent of the value of refimported. Tried to
# run garbage collection just before loading the session with no luck. It
# fails even when preceding them with 'import calendar'. Needed to run
# these kinds of tests in a supbrocess. Failing test sample:
# assert globals()['day_name'] is sys.modules['calendar'].__dict__['day_name']
try:
for obj in ('json', 'url', 'local_mod', 'sax', 'dom'):
assert globals()[obj].__name__ in sys.modules
assert 'calendar' in sys.modules and 'cmath' in sys.modules
import calendar, cmath
for obj in ('Calendar', 'isleap'):
assert globals()[obj] is sys.modules['calendar'].__dict__[obj]
assert __main__.day_name.__module__ == 'calendar'
if refimported:
assert __main__.day_name is calendar.day_name
assert __main__.complex_log is cmath.log
except AssertionError as error:
error.args = (_error_line(error, obj, refimported),)
raise
test_modules(refimported)
sys.exit()
####################
# Parent process #
####################
# Create various kinds of objects to test different internal logics.
## Modules.
import json # top-level module
import urllib as url # top-level module under alias
from xml import sax # submodule
import xml.dom.minidom as dom # submodule under alias
import test_dictviews as local_mod # non-builtin top-level module
## Imported objects.
from calendar import Calendar, isleap, day_name # class, function, other object
from cmath import log as complex_log # imported with alias
## Local objects.
x = 17
empty = None
names = ['Alice', 'Bob', 'Carol']
def squared(x): return x**2
cubed = lambda x: x**3
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
person = Person(names[0], x)
class CalendarSubclass(Calendar):
def weekdays(self):
return [day_name[i] for i in self.iterweekdays()]
cal = CalendarSubclass()
selfref = __main__
# Setup global namespace for session saving tests.
class TestNamespace:
test_globals = globals().copy()
def __init__(self, **extra):
self.extra = extra
def __enter__(self):
self.backup = globals().copy()
globals().clear()
globals().update(self.test_globals)
globals().update(self.extra)
return self
def __exit__(self, *exc_info):
globals().clear()
globals().update(self.backup)
def _clean_up_cache(module):
cached = module.__file__.split('.', 1)[0] + '.pyc'
cached = module.__cached__ if hasattr(module, '__cached__') else cached
pycache = os.path.join(os.path.dirname(module.__file__), '__pycache__')
for remove, file in [(os.remove, cached), (os.removedirs, pycache)]:
with suppress(OSError):
remove(file)
atexit.register(_clean_up_cache, local_mod)
def _test_objects(main, globals_copy, refimported):
try:
main_dict = __main__.__dict__
global Person, person, Calendar, CalendarSubclass, cal, selfref
for obj in ('json', 'url', 'local_mod', 'sax', 'dom'):
assert globals()[obj].__name__ == globals_copy[obj].__name__
for obj in ('x', 'empty', 'names'):
assert main_dict[obj] == globals_copy[obj]
for obj in ['squared', 'cubed']:
assert main_dict[obj].__globals__ is main_dict
assert main_dict[obj](3) == globals_copy[obj](3)
assert Person.__module__ == __main__.__name__
assert isinstance(person, Person)
assert person.age == globals_copy['person'].age
assert issubclass(CalendarSubclass, Calendar)
assert isinstance(cal, CalendarSubclass)
assert cal.weekdays() == globals_copy['cal'].weekdays()
assert selfref is __main__
except AssertionError as error:
error.args = (_error_line(error, obj, refimported),)
raise
def test_session_main(refimported):
"""test dump/load_module() for __main__, both in this process and in a subprocess"""
extra_objects = {}
if refimported:
# Test unpickleable imported object in main.
from sys import flags
extra_objects['flags'] = flags
with TestNamespace(**extra_objects) as ns:
try:
# Test session loading in a new session.
dill.dump_module(session_file % refimported, refimported=refimported)
from dill.tests.__main__ import python, shell, sp
error = sp.call([python, __file__, '--child', str(refimported)], shell=shell)
if error: sys.exit(error)
finally:
with suppress(OSError):
os.remove(session_file % refimported)
# Test session loading in the same session.
session_buffer = BytesIO()
dill.dump_module(session_buffer, refimported=refimported)
session_buffer.seek(0)
dill.load_module(session_buffer, module='__main__')
ns.backup['_test_objects'](__main__, ns.backup, refimported)
def test_session_other():
"""test dump/load_module() for a module other than __main__"""
import test_classdef as module
atexit.register(_clean_up_cache, module)
module.selfref = module
dict_objects = [obj for obj in module.__dict__.keys() if not obj.startswith('__')]
session_buffer = BytesIO()
dill.dump_module(session_buffer, module)
for obj in dict_objects:
del module.__dict__[obj]
session_buffer.seek(0)
dill.load_module(session_buffer, module)
assert all(obj in module.__dict__ for obj in dict_objects)
assert module.selfref is module
def test_runtime_module():
from types import ModuleType
modname = '__runtime__'
runtime = ModuleType(modname)
runtime.x = 42
mod = dill.session._stash_modules(runtime)
if mod is not runtime:
print("There are objects to save by referenece that shouldn't be:",
mod.__dill_imported, mod.__dill_imported_as, mod.__dill_imported_top_level,
file=sys.stderr)
# This is also for code coverage, tests the use case of dump_module(refimported=True)
# without imported objects in the namespace. It's a contrived example because
# even dill can't be in it. This should work after fixing #462.
session_buffer = BytesIO()
dill.dump_module(session_buffer, module=runtime, refimported=True)
session_dump = session_buffer.getvalue()
# Pass a new runtime created module with the same name.
runtime = ModuleType(modname) # empty
return_val = dill.load_module(BytesIO(session_dump), module=runtime)
assert return_val is None
assert runtime.__name__ == modname
assert runtime.x == 42
assert runtime not in sys.modules.values()
# Pass nothing as main. load_module() must create it.
session_buffer.seek(0)
runtime = dill.load_module(BytesIO(session_dump))
assert runtime.__name__ == modname
assert runtime.x == 42
assert runtime not in sys.modules.values()
def test_refimported_imported_as():
import collections
import concurrent.futures
import types
import typing
mod = sys.modules['__test__'] = types.ModuleType('__test__')
dill.executor = concurrent.futures.ThreadPoolExecutor(max_workers=1)
mod.Dict = collections.UserDict # select by type
mod.AsyncCM = typing.AsyncContextManager # select by __module__
mod.thread_exec = dill.executor # select by __module__ with regex
session_buffer = BytesIO()
dill.dump_module(session_buffer, mod, refimported=True)
session_buffer.seek(0)
mod = dill.load(session_buffer)
del sys.modules['__test__']
assert set(mod.__dill_imported_as) == {
('collections', 'UserDict', 'Dict'),
('typing', 'AsyncContextManager', 'AsyncCM'),
('dill', 'executor', 'thread_exec'),
}
def test_load_module_asdict():
with TestNamespace():
session_buffer = BytesIO()
dill.dump_module(session_buffer)
global empty, names, x, y
x = y = 0 # change x and create y
del empty
globals_state = globals().copy()
session_buffer.seek(0)
main_vars = dill.load_module_asdict(session_buffer)
assert main_vars is not globals()
assert globals() == globals_state
assert main_vars['__name__'] == '__main__'
assert main_vars['names'] == names
assert main_vars['names'] is not names
assert main_vars['x'] != x
assert 'y' not in main_vars
assert 'empty' in main_vars
if __name__ == '__main__':
test_session_main(refimported=False)
test_session_main(refimported=True)
test_session_other()
test_runtime_module()
test_refimported_imported_as()
test_load_module_asdict()
|