def _get_code_from_file(run_name, fname=None, hy_src_check=lambda x: x.endswith('.hy')): """A patch of `runpy._get_code_from_file` that will also run and cache Hy code. """ if fname is None and run_name is not None: fname = run_name # Check for bytecode first. (This is what the `runpy` version does!) with open(fname, "rb") as f: code = pkgutil.read_code(f) if code is None: if hy_src_check(fname): code = _hy_code_from_file(fname, loader_type=HyLoader) else: # Try normal source with open(fname, "rb") as f: # This code differs from `runpy`'s only in that we # force decoding into UTF-8. source = f.read().decode('utf-8') code = compile(source, fname, 'exec') return (code, fname)
def _get_code_from_file(run_name, fname=None): """A patch of `runpy._get_code_from_file` that will also compile Hy code. This version will read and cache bytecode for Hy files. It operates normally otherwise. """ if fname is None and run_name is not None: fname = run_name if fname.endswith('.hy'): full_fname = os.path.abspath(fname) fname_path, fname_file = os.path.split(full_fname) modname = os.path.splitext(fname_file)[0] sys.path.insert(0, fname_path) try: loader = pkgutil.get_loader(modname) code = loader.get_code(modname) finally: sys.path.pop(0) else: with open(fname, "rb") as f: code = pkgutil.read_code(f) if code is None: with open(fname, "rb") as f: source = f.read().decode('utf-8') code = compile(source, fname, 'exec') return (code, fname) if PY3 else code
def _get_code_from_file(fname): with open(fname, 'rb') as f: code = read_code(f) if code is None: with open(fname, 'rU') as f: code = compile(f.read(), fname, 'exec') return code
def _get_code_from_file(fname): with open(fname, "rb") as f: code = read_code(f) if code is None: with open(fname, "rU") as f: code = compile(f.read(), fname, "exec") return code
def _LoadModule(self, name, fp, path, info, deferredImports, parent=None): """Load the module, given the information acquired by the finder.""" suffix, mode, type = info if type == imp.PKG_DIRECTORY: return self._LoadPackage(name, path, parent, deferredImports) module = self._AddModule(name, file_name=path, parent=parent) if type == imp.PY_SOURCE: logging.debug("Adding module [%s] [PY_SOURCE]", name) # Load & compile Python source code # if file opened, it already use good encoding; else detect it manually if not fp: with open(path, "rb") as f: encoding = tokenize.detect_encoding(f.readline)[0] fp = open(path, "r", encoding=encoding) codeString = fp.read() if codeString and codeString[-1] != "\n": codeString = codeString + "\n" try: module.code = compile(codeString, path, "exec", optimize=self.optimizeFlag) except SyntaxError: raise ImportError("Invalid syntax in %s" % path) elif type == imp.PY_COMPILED: logging.debug("Adding module [%s] [PY_COMPILED]", name) # Load Python bytecode if isinstance(fp, bytes): fp = io.BytesIO(fp) module.source_is_zip_file = True module.code = pkgutil.read_code(fp) if module.code is None: raise ImportError("Bad magic number in %s" % path) elif type == imp.C_EXTENSION: logging.debug("Adding module [%s] [C_EXTENSION]", name) # If there's a custom hook for this module, run it. self._RunHook("load", module.name, module) if module.code is not None: if self.replace_paths: topLevelModule = module while topLevelModule.parent is not None: topLevelModule = topLevelModule.parent module.code = self._ReplacePathsInCode(topLevelModule, module.code) # Scan the module code for import statements self._ScanCode(module.code, module, deferredImports) # Verify __package__ in use self._ReplacePackageInCode(module) module.in_import = False return module
def _get_code_from_file(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
def _get_code_from_file(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, "rU") as f: code = compile(f.read(), fname, 'exec') return code
def _get_code_from_file(run_name, fname): with open(fname, 'rb') as f: code = read_code(f) if code is None: with open(fname, 'rb') as f: code = compile(f.read(), fname, 'exec') loader = importlib.machinery.SourceFileLoader(run_name, fname) else: loader = importlib.machinery.SourcelessFileLoader(run_name, fname) return (code, loader)
def _get_code_from_file(run_name, fname): # Check for a compiled file first decoded_path = os.path.abspath(os.fsdecode(fname)) with io.open_code(decoded_path) as f: code = read_code(f) if code is None: # That didn't work, so try it as normal source code with io.open_code(decoded_path) as f: code = compile(f.read(), fname, 'exec') return code, fname
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') loader = importlib.machinery.SourceFileLoader(run_name, fname) else: loader = importlib.machinery.SourcelessFileLoader(run_name, fname) return code, loader
def run_path(filename): try: # runpy.run_path: import io from pkgutil import get_importer, read_code try: open_code = io.open_code except AttributeError: # The function is missing in Python 3.7 def open_code(path): return open(path, "rb") importer = get_importer(filename) is_NullImporter = False if type(importer).__module__ == "imp": if type(importer).__name__ == "NullImporter": is_NullImporter = True if isinstance(importer, type(None)) or is_NullImporter: # runpy._get_code_from_file: with open_code(filename) as f: code = read_code(f) if code is None: # That didn't work, so try it as normal source code with open_code(filename) as f: code = compile(f.read(), filename, "exec") else: # Run directory. code = functools.partial(runpy.run_path, filename, run_name="__main__") except FileNotFoundError as err: show_error(f"Can't open file: {err}") sys.exit(2) except (OverflowError, SyntaxError, ValueError): show_syntax_error(filename) else: run_code(code, filename)
def _get_code_from_file(run_name, fname=None, hy_src_check=lambda x: x.endswith('.hy')): """A patch of `runpy._get_code_from_file` that will also run and cache Hy code. """ if fname is None and run_name is not None: fname = run_name # Check for bytecode first. (This is what the `runpy` version does!) with open(fname, "rb") as f: code = pkgutil.read_code(f) if code is None: if hy_src_check(fname): code = _hy_code_from_file(fname, loader_type=HyLoader) else: # Try normal source with open(fname, "rb") as f: # This code differs from `runpy`'s only in that we # force decoding into UTF-8. source = f.read().decode('utf-8') code = compile(source, fname, 'exec') return (code, fname) if PY3 else code
def open_compiled_python_script(session, stream, file_name, argv=None): """Execute compiled Python script in a ChimeraX context Each script is opened in a uniquely named importable sandbox (see timeit example above). And the current ChimeraX session is available as a global variable named **session**. Parameters ---------- session : a ChimeraX :py:class:`~chimerax.core.session.Session` stream : open data stream file_name : how to identify the file """ import pkgutil try: code = pkgutil.read_code(stream) if code is None: from .errors import UserError raise UserError( "Python code was compiled for a different version of Python") _exec_python(session, code, argv) finally: stream.close() return [], "executed %s" % file_name
def execscript(path: str, *args: str) -> None: """ Execute a script. The script is executed in the same context as the caller: currently defined globals are available to the script, and globals defined by the script are added back to the calling context. This is most useful for executing scripts from interactive mode. For example, you could have a script named ``exe.py``: .. code-block:: python3 \"\"\"Get all tasks executing a given file.\"\"\" import sys from drgn.helpers.linux.fs import d_path from drgn.helpers.linux.pid import find_task def task_exe_path(task): if task.mm: return d_path(task.mm.exe_file.f_path).decode() else: return None tasks = [ task for task in for_each_task(prog) if task_exe_path(task) == sys.argv[1] ] Then, you could execute it and use the defined variables and functions: >>> execscript('exe.py', '/usr/bin/bash') >>> tasks[0].pid (pid_t)358442 >>> task_exe_path(find_task(prog, 357954)) '/usr/bin/vim' :param path: File path of the script. :param args: Zero or more additional arguments to pass to the script. This is a :ref:`variable argument list <python:tut-arbitraryargs>`. """ # This is based on runpy.run_code, which we can't use because we want to # update globals even if the script throws an exception. saved_module = [] try: saved_module.append(sys.modules["__main__"]) except KeyError: pass saved_argv = sys.argv try: module = types.ModuleType("__main__") sys.modules["__main__"] = module sys.argv = [path] sys.argv.extend(args) with _open_code(path) as f: code = pkgutil.read_code(f) # type: ignore[attr-defined] if code is None: with _open_code(path) as f: code = compile(f.read(), path, "exec") module.__spec__ = None module.__file__ = path module.__cached__ = None # type: ignore[attr-defined] caller_globals = sys._getframe(1).f_globals caller_special_globals = { name: caller_globals[name] for name in _special_globals if name in caller_globals } for name, value in caller_globals.items(): if name not in _special_globals: setattr(module, name, value) try: exec(code, vars(module)) finally: caller_globals.clear() caller_globals.update(caller_special_globals) for name, value in vars(module).items(): if name not in _special_globals: caller_globals[name] = value finally: sys.argv = saved_argv if saved_module: sys.modules["__main__"] = saved_module[0] else: del sys.modules["__main__"]
def xreload(mod): """Reload a module in place, updating classes, methods and functions. Args: mod: a module object Returns: The (updated) input object itself. """ # Get the module name, e.g. 'foo.bar.whatever' modname = mod.__name__ # Get the module namespace (dict) early; this is part of the type check modns = mod.__dict__ # Parse it into package name and module name, e.g. 'foo.bar' and 'whatever' i = modname.rfind(".") if i >= 0: pkgname, modname = modname[:i], modname[i + 1:] else: pkgname = None # Compute the search path if pkgname: # We're not reloading the package, only the module in it path = sys.modules[pkgname].__path__ # Search inside the package else: # Search the top-level module path path = None # Make find_module() uses the default search path # Find the module; may raise ImportError # TODO: port to new import logic using importlib.util.find_spec and loader (stream, filename, (suffix, mode, kind)) = imp.find_module(modname, path) # Turn it into a code object try: # Is it Python source code or byte code read from a file? if kind not in (imp.PY_COMPILED, imp.PY_SOURCE): # Fall back to built-in reload() return importlib.reload(mod) if kind == imp.PY_SOURCE: source = stream.read() code = compile(source, filename, "exec") else: code = pkgutil.read_code(stream) finally: if stream: stream.close() # Execute the code. We copy the module dict to a temporary; then # clear the module dict; then execute the new code in the module # dict; then swap things back and around. This trick (due to # Glyph Lefkowitz) ensures that the (readonly) __globals__ # attribute of methods and functions is set to the correct dict # object. tmpns = modns.copy() modns.clear() modns["__name__"] = tmpns["__name__"] for attr in ("__file__", "__path__", "__spec__", "__package__"): if attr in tmpns: modns[attr] = tmpns[attr] exec(code, modns) # Now we get to the hard part oldnames = set(tmpns) newnames = set(modns) # Update attributes in place for name in oldnames & newnames: _update(tmpns[name], modns[name]) return mod
def update_event(self, inp=-1): self.set_output_val(0, pkgutil.read_code(self.input(0)))
def execscript(path: str, *args: str) -> None: """ Execute a script. The script is executed in the same context as the caller: currently defined globals are available to the script, and globals defined by the script are added back to the calling context. This is most useful for executing scripts from interactive mode. For example, you could have a script named ``tasks.py``: .. code-block:: python3 import sys \"\"\" Get all tasks in a given state. \"\"\" # From include/linux/sched.h. def task_state_index(task): task_state = task.state.value_() if task_state == 0x402: # TASK_IDLE return 8 else: state = (task_state | task.exit_state.value_()) & 0x7f return state.bit_length() def task_state_to_char(task): return 'RSDTtXZPI'[task_state_index(task)] tasks = [ task for task in for_each_task(prog) if task_state_to_char(task) == sys.argv[1] ] Then, you could execute it and use the defined variables and functions: >>> execscript('tasks.py', 'R') >>> tasks[0].comm (char [16])"python3" >>> task_state_to_char(find_task(prog, 1)) 'S' :param path: File path of the script. :param args: Zero or more additional arguments to pass to the script. This is a :ref:`variable argument list <python:tut-arbitraryargs>`. """ # This is based on runpy.run_code, which we can't use because we want to # update globals even if the script throws an exception. saved_module = [] try: saved_module.append(sys.modules["__main__"]) except KeyError: pass saved_argv = sys.argv try: module = types.ModuleType("__main__") sys.modules["__main__"] = module sys.argv = [path] sys.argv.extend(args) with _open_code(path) as f: code = pkgutil.read_code(f) if code is None: with _open_code(path) as f: code = compile(f.read(), path, "exec") module.__spec__ = None module.__file__ = path module.__cached__ = None caller_globals = sys._getframe(1).f_globals caller_special_globals = { name: caller_globals[name] for name in _special_globals if name in caller_globals } for name, value in caller_globals.items(): if name not in _special_globals: setattr(module, name, value) try: exec(code, vars(module)) finally: caller_globals.clear() caller_globals.update(caller_special_globals) for name, value in vars(module).items(): if name not in _special_globals: caller_globals[name] = value finally: sys.argv = saved_argv if saved_module: sys.modules["__main__"] = saved_module[0] else: del sys.modules["__main__"]
import sys from pathlib import Path from pkgutil import read_code # Remove the name of the runner sys.argv.pop(0) # Read the input file script = Path(sys.argv[0]) with script.open('rb') as script_file: # If we received a source file, compile it (and leave bytecode as is) if script.suffix != ".pyc": code = compile(script_file.read(), str(script), "exec") else: code = read_code(script_file) # Run the code and convert exceptions to error codes try: try: exec(code) except: import traceback traceback.print_exc() raise except AssertionError: sys.exit(101) except TypeError: sys.exit(102) except NameError: sys.exit(103)