← Back to branch summary

~ubuntu-branches/ubuntu/trusty/python3.4/trusty-proposed

« back to all changes in this revision

Viewing changes to Lib/runpy.py

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2013-11-25 09:44:27 UTC
  • Revision ID: package-import@ubuntu.com-20131125094427-lzxj8ap5w01lmo7f
Tags: upstream-3.4~b1
Import upstream version 3.4~b1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Lib/runpy.py
 
1
"""runpy.py - locating and running Python code using the module namespace
 
2
 
 
3
Provides support for locating and running Python scripts using the Python
 
4
module namespace instead of the native filesystem.
 
5
 
 
6
This allows Python code to play nicely with non-filesystem based PEP 302
 
7
importers when locating support scripts as well as when importing modules.
 
8
"""
 
9
# Written by Nick Coghlan <ncoghlan at gmail.com>
 
10
#    to implement PEP 338 (Executing Modules as Scripts)
 
11
 
 
12
 
 
13
import os
 
14
import sys
 
15
import importlib.machinery # importlib first so we can test #15386 via -m
 
16
import types
 
17
from pkgutil import read_code, get_loader, get_importer
 
18
 
 
19
__all__ = [
 
20
    "run_module", "run_path",
 
21
]
 
22
 
 
23
class _TempModule(object):
 
24
    """Temporarily replace a module in sys.modules with an empty namespace"""
 
25
    def __init__(self, mod_name):
 
26
        self.mod_name = mod_name
 
27
        self.module = types.ModuleType(mod_name)
 
28
        self._saved_module = []
 
29
 
 
30
    def __enter__(self):
 
31
        mod_name = self.mod_name
 
32
        try:
 
33
            self._saved_module.append(sys.modules[mod_name])
 
34
        except KeyError:
 
35
            pass
 
36
        sys.modules[mod_name] = self.module
 
37
        return self
 
38
 
 
39
    def __exit__(self, *args):
 
40
        if self._saved_module:
 
41
            sys.modules[self.mod_name] = self._saved_module[0]
 
42
        else:
 
43
            del sys.modules[self.mod_name]
 
44
        self._saved_module = []
 
45
 
 
46
class _ModifiedArgv0(object):
 
47
    def __init__(self, value):
 
48
        self.value = value
 
49
        self._saved_value = self._sentinel = object()
 
50
 
 
51
    def __enter__(self):
 
52
        if self._saved_value is not self._sentinel:
 
53
            raise RuntimeError("Already preserving saved value")
 
54
        self._saved_value = sys.argv[0]
 
55
        sys.argv[0] = self.value
 
56
 
 
57
    def __exit__(self, *args):
 
58
        self.value = self._sentinel
 
59
        sys.argv[0] = self._saved_value
 
60
 
 
61
def _run_code(code, run_globals, init_globals=None,
 
62
              mod_name=None, mod_fname=None,
 
63
              mod_loader=None, pkg_name=None):
 
64
    """Helper to run code in nominated namespace"""
 
65
    if init_globals is not None:
 
66
        run_globals.update(init_globals)
 
67
    run_globals.update(__name__ = mod_name,
 
68
                       __file__ = mod_fname,
 
69
                       __cached__ = None,
 
70
                       __doc__ = None,
 
71
                       __loader__ = mod_loader,
 
72
                       __package__ = pkg_name)
 
73
    exec(code, run_globals)
 
74
    return run_globals
 
75
 
 
76
def _run_module_code(code, init_globals=None,
 
77
                    mod_name=None, mod_fname=None,
 
78
                    mod_loader=None, pkg_name=None):
 
79
    """Helper to run code in new namespace with sys modified"""
 
80
    with _TempModule(mod_name) as temp_module, _ModifiedArgv0(mod_fname):
 
81
        mod_globals = temp_module.module.__dict__
 
82
        _run_code(code, mod_globals, init_globals,
 
83
                  mod_name, mod_fname, mod_loader, pkg_name)
 
84
    # Copy the globals of the temporary module, as they
 
85
    # may be cleared when the temporary module goes away
 
86
    return mod_globals.copy()
 
87
 
 
88
 
 
89
# This helper is needed due to a missing component in the PEP 302
 
90
# loader protocol (specifically, "get_filename" is non-standard)
 
91
# Since we can't introduce new features in maintenance releases,
 
92
# support was added to zipimporter under the name '_get_filename'
 
93
def _get_filename(loader, mod_name):
 
94
    for attr in ("get_filename", "_get_filename"):
 
95
        meth = getattr(loader, attr, None)
 
96
        if meth is not None:
 
97
            return os.path.abspath(meth(mod_name))
 
98
    return None
 
99
 
 
100
# Helper to get the loader, code and filename for a module
 
101
def _get_module_details(mod_name):
 
102
    loader = get_loader(mod_name)
 
103
    if loader is None:
 
104
        raise ImportError("No module named %s" % mod_name)
 
105
    if loader.is_package(mod_name):
 
106
        if mod_name == "__main__" or mod_name.endswith(".__main__"):
 
107
            raise ImportError("Cannot use package as __main__ module")
 
108
        try:
 
109
            pkg_main_name = mod_name + ".__main__"
 
110
            return _get_module_details(pkg_main_name)
 
111
        except ImportError as e:
 
112
            raise ImportError(("%s; %r is a package and cannot " +
 
113
                               "be directly executed") %(e, mod_name))
 
114
    code = loader.get_code(mod_name)
 
115
    if code is None:
 
116
        raise ImportError("No code object available for %s" % mod_name)
 
117
    filename = _get_filename(loader, mod_name)
 
118
    return mod_name, loader, code, filename
 
119
 
 
120
# XXX ncoghlan: Should this be documented and made public?
 
121
# (Current thoughts: don't repeat the mistake that lead to its
 
122
# creation when run_module() no longer met the needs of
 
123
# mainmodule.c, but couldn't be changed because it was public)
 
124
def _run_module_as_main(mod_name, alter_argv=True):
 
125
    """Runs the designated module in the __main__ namespace
 
126
 
 
127
       Note that the executed module will have full access to the
 
128
       __main__ namespace. If this is not desirable, the run_module()
 
129
       function should be used to run the module code in a fresh namespace.
 
130
 
 
131
       At the very least, these variables in __main__ will be overwritten:
 
132
           __name__
 
133
           __file__
 
134
           __cached__
 
135
           __loader__
 
136
           __package__
 
137
    """
 
138
    try:
 
139
        if alter_argv or mod_name != "__main__": # i.e. -m switch
 
140
            mod_name, loader, code, fname = _get_module_details(mod_name)
 
141
        else:          # i.e. directory or zipfile execution
 
142
            mod_name, loader, code, fname = _get_main_module_details()
 
143
    except ImportError as exc:
 
144
        # Try to provide a good error message
 
145
        # for directories, zip files and the -m switch
 
146
        if alter_argv:
 
147
            # For -m switch, just display the exception
 
148
            info = str(exc)
 
149
        else:
 
150
            # For directories/zipfiles, let the user
 
151
            # know what the code was looking for
 
152
            info = "can't find '__main__' module in %r" % sys.argv[0]
 
153
        msg = "%s: %s" % (sys.executable, info)
 
154
        sys.exit(msg)
 
155
    pkg_name = mod_name.rpartition('.')[0]
 
156
    main_globals = sys.modules["__main__"].__dict__
 
157
    if alter_argv:
 
158
        sys.argv[0] = fname
 
159
    return _run_code(code, main_globals, None,
 
160
                     "__main__", fname, loader, pkg_name)
 
161
 
 
162
def run_module(mod_name, init_globals=None,
 
163
               run_name=None, alter_sys=False):
 
164
    """Execute a module's code without importing it
 
165
 
 
166
       Returns the resulting top level namespace dictionary
 
167
    """
 
168
    mod_name, loader, code, fname = _get_module_details(mod_name)
 
169
    if run_name is None:
 
170
        run_name = mod_name
 
171
    pkg_name = mod_name.rpartition('.')[0]
 
172
    if alter_sys:
 
173
        return _run_module_code(code, init_globals, run_name,
 
174
                                fname, loader, pkg_name)
 
175
    else:
 
176
        # Leave the sys module alone
 
177
        return _run_code(code, {}, init_globals, run_name,
 
178
                         fname, loader, pkg_name)
 
179
 
 
180
def _get_main_module_details():
 
181
    # Helper that gives a nicer error message when attempting to
 
182
    # execute a zipfile or directory by invoking __main__.py
 
183
    # Also moves the standard __main__ out of the way so that the
 
184
    # preexisting __loader__ entry doesn't cause issues
 
185
    main_name = "__main__"
 
186
    saved_main = sys.modules[main_name]
 
187
    del sys.modules[main_name]
 
188
    try:
 
189
        return _get_module_details(main_name)
 
190
    except ImportError as exc:
 
191
        if main_name in str(exc):
 
192
            raise ImportError("can't find %r module in %r" %
 
193
                              (main_name, sys.path[0])) from exc
 
194
        raise
 
195
    finally:
 
196
        sys.modules[main_name] = saved_main
 
197
 
 
198
 
 
199
def _get_code_from_file(run_name, fname):
 
200
    # Check for a compiled file first
 
201
    with open(fname, "rb") as f:
 
202
        code = read_code(f)
 
203
    if code is None:
 
204
        # That didn't work, so try it as normal source code
 
205
        with open(fname, "rb") as f:
 
206
            code = compile(f.read(), fname, 'exec')
 
207
            loader = importlib.machinery.SourceFileLoader(run_name, fname)
 
208
    else:
 
209
        loader = importlib.machinery.SourcelessFileLoader(run_name, fname)
 
210
    return code, loader
 
211
 
 
212
def run_path(path_name, init_globals=None, run_name=None):
 
213
    """Execute code located at the specified filesystem location
 
214
 
 
215
       Returns the resulting top level namespace dictionary
 
216
 
 
217
       The file path may refer directly to a Python script (i.e.
 
218
       one that could be directly executed with execfile) or else
 
219
       it may refer to a zipfile or directory containing a top
 
220
       level __main__.py script.
 
221
    """
 
222
    if run_name is None:
 
223
        run_name = "<run_path>"
 
224
    pkg_name = run_name.rpartition(".")[0]
 
225
    importer = get_importer(path_name)
 
226
    # Trying to avoid importing imp so as to not consume the deprecation warning.
 
227
    is_NullImporter = False
 
228
    if type(importer).__module__ == 'imp':
 
229
        if type(importer).__name__ == 'NullImporter':
 
230
            is_NullImporter = True
 
231
    if isinstance(importer, type(None)) or is_NullImporter:
 
232
        # Not a valid sys.path entry, so run the code directly
 
233
        # execfile() doesn't help as we want to allow compiled files
 
234
        code, mod_loader = _get_code_from_file(run_name, path_name)
 
235
        return _run_module_code(code, init_globals, run_name, path_name,
 
236
                                mod_loader, pkg_name)
 
237
    else:
 
238
        # Importer is defined for path, so add it to
 
239
        # the start of sys.path
 
240
        sys.path.insert(0, path_name)
 
241
        try:
 
242
            # Here's where things are a little different from the run_module
 
243
            # case. There, we only had to replace the module in sys while the
 
244
            # code was running and doing so was somewhat optional. Here, we
 
245
            # have no choice and we have to remove it even while we read the
 
246
            # code. If we don't do this, a __loader__ attribute in the
 
247
            # existing __main__ module may prevent location of the new module.
 
248
            mod_name, loader, code, fname = _get_main_module_details()
 
249
            with _TempModule(run_name) as temp_module, \
 
250
                 _ModifiedArgv0(path_name):
 
251
                mod_globals = temp_module.module.__dict__
 
252
                return _run_code(code, mod_globals, init_globals,
 
253
                                    run_name, fname, loader, pkg_name).copy()
 
254
        finally:
 
255
            try:
 
256
                sys.path.remove(path_name)
 
257
            except ValueError:
 
258
                pass
 
259
 
 
260
 
 
261
if __name__ == "__main__":
 
262
    # Run the module specified as the next command line argument
 
263
    if len(sys.argv) < 2:
 
264
        print("No module specified for execution", file=sys.stderr)
 
265
    else:
 
266
        del sys.argv[0] # Make the requested module sys.argv[0]
 
267
        _run_module_as_main(sys.argv[0])