diff -r d28b92dabc2b -r bc64243b7672 DebugClients/Python/coverage/execfile.py
--- a/DebugClients/Python/coverage/execfile.py Fri Sep 02 19:08:02 2016 +0200
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,242 +0,0 @@
-# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
-# For details: https://bitbucket.org/ned/coveragepy/src/default/NOTICE.txt
-
-"""Execute files of Python code."""
-
-import marshal
-import os
-import sys
-import types
-
-from coverage.backward import BUILTINS
-from coverage.backward import PYC_MAGIC_NUMBER, imp, importlib_util_find_spec
-from coverage.misc import ExceptionDuringRun, NoCode, NoSource, isolate_module
-from coverage.phystokens import compile_unicode
-from coverage.python import get_python_source
-
-os = isolate_module(os)
-
-
-class DummyLoader(object):
- """A shim for the pep302 __loader__, emulating pkgutil.ImpLoader.
-
- Currently only implements the .fullname attribute
- """
- def __init__(self, fullname, *_args):
- self.fullname = fullname
-
-
-if importlib_util_find_spec:
- def find_module(modulename):
- """Find the module named `modulename`.
-
- Returns the file path of the module, and the name of the enclosing
- package.
- """
- try:
- spec = importlib_util_find_spec(modulename)
- except ImportError as err:
- raise NoSource(str(err))
- if not spec:
- raise NoSource("No module named %r" % (modulename,))
- pathname = spec.origin
- packagename = spec.name
- if pathname.endswith("__init__.py") and not modulename.endswith("__init__"):
- mod_main = modulename + ".__main__"
- spec = importlib_util_find_spec(mod_main)
- if not spec:
- raise NoSource(
- "No module named %s; "
- "%r is a package and cannot be directly executed"
- % (mod_main, modulename)
- )
- pathname = spec.origin
- packagename = spec.name
- packagename = packagename.rpartition(".")[0]
- return pathname, packagename
-else:
- def find_module(modulename):
- """Find the module named `modulename`.
-
- Returns the file path of the module, and the name of the enclosing
- package.
- """
- openfile = None
- glo, loc = globals(), locals()
- try:
- # Search for the module - inside its parent package, if any - using
- # standard import mechanics.
- if '.' in modulename:
- packagename, name = modulename.rsplit('.', 1)
- package = __import__(packagename, glo, loc, ['__path__'])
- searchpath = package.__path__
- else:
- packagename, name = None, modulename
- searchpath = None # "top-level search" in imp.find_module()
- openfile, pathname, _ = imp.find_module(name, searchpath)
-
- # Complain if this is a magic non-file module.
- if openfile is None and pathname is None:
- raise NoSource(
- "module does not live in a file: %r" % modulename
- )
-
- # If `modulename` is actually a package, not a mere module, then we
- # pretend to be Python 2.7 and try running its __main__.py script.
- if openfile is None:
- packagename = modulename
- name = '__main__'
- package = __import__(packagename, glo, loc, ['__path__'])
- searchpath = package.__path__
- openfile, pathname, _ = imp.find_module(name, searchpath)
- except ImportError as err:
- raise NoSource(str(err))
- finally:
- if openfile:
- openfile.close()
-
- return pathname, packagename
-
-
-def run_python_module(modulename, args):
- """Run a Python module, as though with ``python -m name args...``.
-
- `modulename` is the name of the module, possibly a dot-separated name.
- `args` is the argument array to present as sys.argv, including the first
- element naming the module being executed.
-
- """
- pathname, packagename = find_module(modulename)
-
- pathname = os.path.abspath(pathname)
- args[0] = pathname
- run_python_file(pathname, args, package=packagename, modulename=modulename, path0="")
-
-
-def run_python_file(filename, args, package=None, modulename=None, path0=None):
- """Run a Python file as if it were the main program on the command line.
-
- `filename` is the path to the file to execute, it need not be a .py file.
- `args` is the argument array to present as sys.argv, including the first
- element naming the file being executed. `package` is the name of the
- enclosing package, if any.
-
- `modulename` is the name of the module the file was run as.
-
- `path0` is the value to put into sys.path[0]. If it's None, then this
- function will decide on a value.
-
- """
- if modulename is None and sys.version_info >= (3, 3):
- modulename = '__main__'
-
- # Create a module to serve as __main__
- old_main_mod = sys.modules['__main__']
- main_mod = types.ModuleType('__main__')
- sys.modules['__main__'] = main_mod
- main_mod.__file__ = filename
- if package:
- main_mod.__package__ = package
- if modulename:
- main_mod.__loader__ = DummyLoader(modulename)
-
- main_mod.__builtins__ = BUILTINS
-
- # Set sys.argv properly.
- old_argv = sys.argv
- sys.argv = args
-
- if os.path.isdir(filename):
- # Running a directory means running the __main__.py file in that
- # directory.
- my_path0 = filename
-
- for ext in [".py", ".pyc", ".pyo"]:
- try_filename = os.path.join(filename, "__main__" + ext)
- if os.path.exists(try_filename):
- filename = try_filename
- break
- else:
- raise NoSource("Can't find '__main__' module in '%s'" % filename)
- else:
- my_path0 = os.path.abspath(os.path.dirname(filename))
-
- # Set sys.path correctly.
- old_path0 = sys.path[0]
- sys.path[0] = path0 if path0 is not None else my_path0
-
- try:
- # Make a code object somehow.
- if filename.endswith((".pyc", ".pyo")):
- code = make_code_from_pyc(filename)
- else:
- code = make_code_from_py(filename)
-
- # Execute the code object.
- try:
- exec(code, main_mod.__dict__)
- except SystemExit:
- # The user called sys.exit(). Just pass it along to the upper
- # layers, where it will be handled.
- raise
- except:
- # Something went wrong while executing the user code.
- # Get the exc_info, and pack them into an exception that we can
- # throw up to the outer loop. We peel one layer off the traceback
- # so that the coverage.py code doesn't appear in the final printed
- # traceback.
- typ, err, tb = sys.exc_info()
-
- # PyPy3 weirdness. If I don't access __context__, then somehow it
- # is non-None when the exception is reported at the upper layer,
- # and a nested exception is shown to the user. This getattr fixes
- # it somehow? https://bitbucket.org/pypy/pypy/issue/1903
- getattr(err, '__context__', None)
-
- raise ExceptionDuringRun(typ, err, tb.tb_next)
- finally:
- # Restore the old __main__, argv, and path.
- sys.modules['__main__'] = old_main_mod
- sys.argv = old_argv
- sys.path[0] = old_path0
-
-
-def make_code_from_py(filename):
- """Get source from `filename` and make a code object of it."""
- # Open the source file.
- try:
- source = get_python_source(filename)
- except (IOError, NoSource):
- raise NoSource("No file to run: '%s'" % filename)
-
- code = compile_unicode(source, filename, "exec")
- return code
-
-
-def make_code_from_pyc(filename):
- """Get a code object from a .pyc file."""
- try:
- fpyc = open(filename, "rb")
- except IOError:
- raise NoCode("No file to run: '%s'" % filename)
-
- with fpyc:
- # First four bytes are a version-specific magic number. It has to
- # match or we won't run the file.
- magic = fpyc.read(4)
- if magic != PYC_MAGIC_NUMBER:
- raise NoCode("Bad magic number in .pyc file")
-
- # Skip the junk in the header that we don't need.
- fpyc.read(4) # Skip the moddate.
- if sys.version_info >= (3, 3):
- # 3.3 added another long to the header (size), skip it.
- fpyc.read(4)
-
- # The rest of the file is the code object we want.
- code = marshal.load(fpyc)
-
- return code
-
-#
-# eflag: FileType = Python2
