cpython/Lib/runpy.py at 3.5 · python/cpython · GitHub

Repository navigation

History

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

282

283

284

285

286

287

288

289

290

291

292

293

294

"""runpy.py - locating and running Python code using the module namespace

Provides support for locating and running Python scripts using the Python

module namespace instead of the native filesystem.

This allows Python code to play nicely with non-filesystem based PEP 302

importers when locating support scripts as well as when importing modules.

"""

# Written by Nick Coghlan <ncoghlan at gmail.com>

# to implement PEP 338 (Executing Modules as Scripts)

import sys

import importlib.machinery # importlib first so we can test #15386 via -m

import importlib.util

import types

from pkgutil import read_code, get_importer

__all__ = [

"run_module", "run_path",

]

class _TempModule(object):

"""Temporarily replace a module in sys.modules with an empty namespace"""

def __init__(self, mod_name):

self.mod_name = mod_name

self.module = types.ModuleType(mod_name)

self._saved_module = []

def __enter__(self):

mod_name = self.mod_name

try:

self._saved_module.append(sys.modules[mod_name])

except KeyError:

pass

sys.modules[mod_name] = self.module

return self

def __exit__(self, *args):

if self._saved_module:

sys.modules[self.mod_name] = self._saved_module[0]

else:

del sys.modules[self.mod_name]

self._saved_module = []

class _ModifiedArgv0(object):

def __init__(self, value):

self.value = value

self._saved_value = self._sentinel = object()

def __enter__(self):

if self._saved_value is not self._sentinel:

raise RuntimeError("Already preserving saved value")

self._saved_value = sys.argv[0]

sys.argv[0] = self.value

def __exit__(self, *args):

self.value = self._sentinel

sys.argv[0] = self._saved_value

# TODO: Replace these helpers with importlib._bootstrap_external functions.

def _run_code(code, run_globals, init_globals=None,

mod_name=None, mod_spec=None,

pkg_name=None, script_name=None):

"""Helper to run code in nominated namespace"""

if init_globals is not None:

run_globals.update(init_globals)

if mod_spec is None:

loader = None

fname = script_name

cached = None

else:

loader = mod_spec.loader

fname = mod_spec.origin

cached = mod_spec.cached

if pkg_name is None:

pkg_name = mod_spec.parent

run_globals.update(__name__ = mod_name,

__file__ = fname,

__cached__ = cached,

__doc__ = None,

__loader__ = loader,

__package__ = pkg_name,

__spec__ = mod_spec)

exec(code, run_globals)

return run_globals

def _run_module_code(code, init_globals=None,

mod_name=None, mod_spec=None,

pkg_name=None, script_name=None):

"""Helper to run code in new namespace with sys modified"""

fname = script_name if mod_spec is None else mod_spec.origin

with _TempModule(mod_name) as temp_module, _ModifiedArgv0(fname):

mod_globals = temp_module.module.__dict__

_run_code(code, mod_globals, init_globals,

mod_name, mod_spec, pkg_name, script_name)

# Copy the globals of the temporary module, as they

# may be cleared when the temporary module goes away

return mod_globals.copy()

# Helper to get the full name, spec and code for a module

def _get_module_details(mod_name, error=ImportError):

if mod_name.startswith("."):

raise error("Relative module names not supported")

pkg_name, _, _ = mod_name.rpartition(".")

if pkg_name:

# Try importing the parent to avoid catching initialization errors

try:

__import__(pkg_name)

except ImportError as e:

# If the parent or higher ancestor package is missing, let the

# error be raised by find_spec() below and then be caught. But do

# not allow other errors to be caught.

if e.name is None or (e.name != pkg_name and

not pkg_name.startswith(e.name + ".")):

raise

# Warn if the module has already been imported under its normal name

existing = sys.modules.get(mod_name)

if existing is not None and not hasattr(existing, "__path__"):

from warnings import warn

msg = "{mod_name!r} found in sys.modules after import of " \

"package {pkg_name!r}, but prior to execution of " \

"{mod_name!r}; this may result in unpredictable " \

"behaviour".format(mod_name=mod_name, pkg_name=pkg_name)

warn(RuntimeWarning(msg))

try:

spec = importlib.util.find_spec(mod_name)

except (ImportError, AttributeError, TypeError, ValueError) as ex:

# This hack fixes an impedance mismatch between pkgutil and

# importlib, where the latter raises other errors for cases where

# pkgutil previously raised ImportError

msg = "Error while finding module specification for {!r} ({}: {})"

raise error(msg.format(mod_name, type(ex).__name__, ex)) from ex

if spec is None:

raise error("No module named %s" % mod_name)

if spec.submodule_search_locations is not None:

if mod_name == "__main__" or mod_name.endswith(".__main__"):

raise error("Cannot use package as __main__ module")

try:

pkg_main_name = mod_name + ".__main__"

return _get_module_details(pkg_main_name, error)

except error as e:

if mod_name not in sys.modules:

raise # No module loaded; being a package is irrelevant

raise error(("%s; %r is a package and cannot " +

"be directly executed") %(e, mod_name))

loader = spec.loader

if loader is None:

raise error("%r is a namespace package and cannot be executed"

% mod_name)

try:

code = loader.get_code(mod_name)

except ImportError as e:

raise error(format(e)) from e

if code is None:

raise error("No code object available for %s" % mod_name)

return mod_name, spec, code

class _Error(Exception):

"""Error that _run_module_as_main() should report without a traceback"""

# XXX ncoghlan: Should this be documented and made public?

# (Current thoughts: don't repeat the mistake that lead to its

# creation when run_module() no longer met the needs of

# mainmodule.c, but couldn't be changed because it was public)

def _run_module_as_main(mod_name, alter_argv=True):

"""Runs the designated module in the __main__ namespace

Note that the executed module will have full access to the

__main__ namespace. If this is not desirable, the run_module()

function should be used to run the module code in a fresh namespace.

At the very least, these variables in __main__ will be overwritten:

__name__

__file__

__cached__

__loader__

__package__

"""

try:

if alter_argv or mod_name != "__main__": # i.e. -m switch

mod_name, mod_spec, code = _get_module_details(mod_name, _Error)

else: # i.e. directory or zipfile execution

mod_name, mod_spec, code = _get_main_module_details(_Error)

except _Error as exc:

msg = "%s: %s" % (sys.executable, exc)

sys.exit(msg)

main_globals = sys.modules["__main__"].__dict__

if alter_argv:

sys.argv[0] = mod_spec.origin

return _run_code(code, main_globals, None,

"__main__", mod_spec)

def run_module(mod_name, init_globals=None,

run_name=None, alter_sys=False):

"""Execute a module's code without importing it

Returns the resulting top level namespace dictionary

"""

mod_name, mod_spec, code = _get_module_details(mod_name)

if run_name is None:

run_name = mod_name

if alter_sys:

return _run_module_code(code, init_globals, run_name, mod_spec)

else:

# Leave the sys module alone

return _run_code(code, {}, init_globals, run_name, mod_spec)

def _get_main_module_details(error=ImportError):

# Helper that gives a nicer error message when attempting to

# execute a zipfile or directory by invoking __main__.py

# Also moves the standard __main__ out of the way so that the

# preexisting __loader__ entry doesn't cause issues

main_name = "__main__"

saved_main = sys.modules[main_name]

del sys.modules[main_name]

try:

return _get_module_details(main_name)

except ImportError as exc:

if main_name in str(exc):

raise error("can't find %r module in %r" %

(main_name, sys.path[0])) from exc

raise

finally:

sys.modules[main_name] = saved_main

def _get_code_from_file(run_name, fname):

# Check for a compiled file first

with open(fname, "rb") as f:

code = read_code(f)

if code is None:

# That didn't work, so try it as normal source code

with open(fname, "rb") as f:

code = compile(f.read(), fname, 'exec')

return code, fname

def run_path(path_name, init_globals=None, run_name=None):

"""Execute code located at the specified filesystem location

Returns the resulting top level namespace dictionary

The file path may refer directly to a Python script (i.e.

one that could be directly executed with execfile) or else

it may refer to a zipfile or directory containing a top

level __main__.py script.

"""

if run_name is None:

run_name = "<run_path>"

pkg_name = run_name.rpartition(".")[0]

importer = get_importer(path_name)

# Trying to avoid importing imp so as to not consume the deprecation warning.

is_NullImporter = False

if type(importer).__module__ == 'imp':

if type(importer).__name__ == 'NullImporter':

is_NullImporter = True

if isinstance(importer, type(None)) or is_NullImporter:

# Not a valid sys.path entry, so run the code directly

# execfile() doesn't help as we want to allow compiled files

code, fname = _get_code_from_file(run_name, path_name)

return _run_module_code(code, init_globals, run_name,

pkg_name=pkg_name, script_name=fname)

else:

# Finder is defined for path, so add it to

# the start of sys.path

sys.path.insert(0, path_name)

try:

# Here's where things are a little different from the run_module

# case. There, we only had to replace the module in sys while the

# code was running and doing so was somewhat optional. Here, we

# have no choice and we have to remove it even while we read the

# code. If we don't do this, a __loader__ attribute in the

# existing __main__ module may prevent location of the new module.

mod_name, mod_spec, code = _get_main_module_details()

with _TempModule(run_name) as temp_module, \

_ModifiedArgv0(path_name):

mod_globals = temp_module.module.__dict__

return _run_code(code, mod_globals, init_globals,

run_name, mod_spec, pkg_name).copy()

finally:

try:

sys.path.remove(path_name)

except ValueError:

pass

if __name__ == "__main__":

# Run the module specified as the next command line argument

if len(sys.argv) < 2:

print("No module specified for execution", file=sys.stderr)

else:

del sys.argv[0] # Make the requested module sys.argv[0]

_run_module_as_main(sys.argv[0])

cpython/Lib/runpy.py at 3.5 · python/cpython · GitHub

Repository navigation

Expand file tree

Breadcrumbs

runpy.py

Latest commit

History

Breadcrumbs

runpy.py

File metadata and controls