def _addSlaveMainModule(root_module): from nuitka.tree.Building import CompiledPythonModule, readSourceCodeFromFilename, createModuleTree from nuitka.ModuleRegistry import addRootModule from nuitka.plugins.Plugins import Plugins # First, build the module node and then read again from the # source code. module_name = "__parents_main__" source_ref = root_module.getSourceReference() mode = Plugins.decideCompilation(module_name, source_ref) slave_main_module = CompiledPythonModule( name=module_name, package_name=None, mode=mode, source_ref=root_module.getSourceReference()) source_code = readSourceCodeFromFilename("__parents_main__", root_module.getFilename()) # For the call stack, this may look bad or different to what # CPython does. Using the "__import__" built-in to not spoil # or use the module namespace. source_code += """ __import__("sys").modules["__main__"] = __import__("sys").modules[__name__] __import__("multiprocessing.forking").forking.main()""" createModuleTree(module=slave_main_module, source_ref=root_module.getSourceReference(), source_code=source_code, is_main=False) # This is an alternative entry point of course. addRootModule(slave_main_module)
def _createTriggerLoadedModule(module, trigger_name, code): from nuitka.tree.Building import createModuleTree from nuitka.nodes.ModuleNodes import CompiledPythonModule from .Plugins import Plugins module_name = module.getName() + trigger_name source_ref = fromFilename(module.getCompileTimeFilename() + trigger_name) mode = Plugins.decideCompilation(module_name, source_ref) trigger_module = CompiledPythonModule( name=module_name, package_name=module.getPackage(), is_top=False, mode=mode, future_spec=None, source_ref=source_ref, ) createModuleTree( module=trigger_module, source_ref=module.getSourceReference(), source_code=code, is_main=False, ) return trigger_module
def _createTriggerLoadedModule(module, trigger_name, code): from nuitka.tree.Building import createModuleTree from nuitka.nodes.ModuleNodes import CompiledPythonModule from nuitka.plugins.Plugins import Plugins module_name = module.getName() + trigger_name source_ref = fromFilename(module.getCompileTimeFilename() + trigger_name) mode = Plugins.decideCompilation(module_name, source_ref) trigger_module = CompiledPythonModule( name = module_name, package_name = module.getPackage(), mode = mode, source_ref = source_ref ) createModuleTree( module = trigger_module, source_ref = module.getSourceReference(), source_code = code, is_main = False ) return trigger_module
def onModuleDiscovered(self, module): post_code, reason = self.createPostModuleLoadCode(module) if post_code: info( "Injecting plug-in based post load code for module '%s':" % \ module.getFullName() ) for line in reason.split('\n'): info(" " + line) from nuitka.tree.Building import createModuleTree post_module = PythonModule( name = module.getName() + "-onLoad", package_name = module.getPackage(), source_ref = fromFilename(module.getCompileTimeFilename() + "-onLoad") ) createModuleTree( module = post_module, source_ref = module.getSourceReference(), source_code = post_code, is_main = False ) post_modules[module.getFullName()] = post_module
def _createTriggerLoadedModule(module, trigger_name, code, flags): """Create a "trigger" for a module to be imported. Notes: The trigger will incorpaorate the code to be prepended / appended. Called by @onModuleDiscovered. Args: module: the module object (serves as dict key) trigger_name: string ("-preload"/"-postload") code: the code string Returns trigger_module """ from nuitka.nodes.ModuleNodes import CompiledPythonModule from nuitka.tree.Building import createModuleTree from .Plugins import Plugins module_name = ModuleName(module.getFullName() + trigger_name) source_ref = fromFilename(module.getCompileTimeFilename() + trigger_name) mode = Plugins.decideCompilation(module_name, source_ref) trigger_module = CompiledPythonModule( module_name=module_name, is_top=False, mode=mode, future_spec=None, source_ref=source_ref, ) createModuleTree( module=trigger_module, source_ref=module.getSourceReference(), source_code=code, is_main=False, ) if mode == "bytecode": trigger_module.setSourceCode(code) # In debug mode, put the files in the build folder, so they can be looked up easily. if Options.is_debug and "HIDE_SOURCE" not in flags: source_path = os.path.join( OutputDirectories.getSourceDirectoryPath(), module_name + ".py") putTextFileContents(filename=source_path, contents=code) return trigger_module
def onModuleInitialSet(self): from nuitka.importing.ImportCache import addImportedModule from nuitka.ModuleRegistry import getRootTopModule from nuitka.plugins.Plugins import Plugins from nuitka.tree.Building import ( CompiledPythonModule, createModuleTree, readSourceCodeFromFilename, ) # First, build the module node and then read again from the # source code. root_module = getRootTopModule() module_name = ModuleName("__parents_main__") source_ref = root_module.getSourceReference() mode = Plugins.decideCompilation(module_name, source_ref) slave_main_module = CompiledPythonModule( module_name=module_name, is_top=False, mode=mode, future_spec=None, source_ref=root_module.getSourceReference(), ) source_code = readSourceCodeFromFilename(module_name, root_module.getFilename()) # For the call stack, this may look bad or different to what # CPython does. Using the "__import__" built-in to not spoil # or use the module namespace. The forking module was split up # into multiple modules in Python 3.4. if python_version >= 0x340: source_code += """ __import__("sys").modules["__main__"] = __import__("sys").modules[__name__] __import__("multiprocessing.spawn").spawn.freeze_support()""" else: source_code += """ __import__("sys").modules["__main__"] = __import__("sys").modules[__name__] __import__("multiprocessing.forking").forking.freeze_support()""" createModuleTree( module=slave_main_module, source_ref=root_module.getSourceReference(), source_code=source_code, is_main=False, ) addImportedModule(imported_module=slave_main_module) yield slave_main_module
def _createTriggerLoadedModule(module, trigger_name, code): """Create a "trigger" for a module to be imported. Notes: The trigger will incorpaorate the code to be prepended / appended. Called by @onModuleDiscovered. Args: module: the module object (serves as dict key) trigger_name: string ("-preload"/"-postload") code: the code string Returns trigger_module """ from nuitka.nodes.ModuleNodes import CompiledPythonModule from nuitka.tree.Building import createModuleTree from .Plugins import Plugins module_name = ModuleName(module.getFullName() + trigger_name) source_ref = fromFilename(module.getCompileTimeFilename() + trigger_name) mode = Plugins.decideCompilation(module_name, source_ref) trigger_module = CompiledPythonModule( module_name=module_name, is_top=False, mode=mode, future_spec=None, source_ref=source_ref, ) createModuleTree( module=trigger_module, source_ref=module.getSourceReference(), source_code=code, is_main=False, ) if mode == "bytecode": trigger_module.setSourceCode(code) if Options.isDebug(): source_path = os.path.join( OutputDirectories.getSourceDirectoryPath(), module_name + ".py") with open(source_path, "w") as output: output.write(code) return trigger_module
def _addSlaveMainModule(root_module): from nuitka.tree.Building import ( CompiledPythonModule, readSourceCodeFromFilename, createModuleTree, ) from nuitka.ModuleRegistry import addRootModule from nuitka.plugins.Plugins import Plugins from sys import hexversion # First, build the module node and then read again from the # source code. module_name = "__parents_main__" source_ref = root_module.getSourceReference() mode = Plugins.decideCompilation(module_name, source_ref) slave_main_module = CompiledPythonModule( name=module_name, package_name=None, is_top=False, mode=mode, future_spec=None, source_ref=root_module.getSourceReference(), ) source_code = readSourceCodeFromFilename( "__parents_main__", root_module.getFilename() ) # For the call stack, this may look bad or different to what # CPython does. Using the "__import__" built-in to not spoil # or use the module namespace. The forking module was split up # into multiple modules in Python 3.4.0.a2 if hexversion >= 0x030400A2: source_code += """ __import__("sys").modules["__main__"] = __import__("sys").modules[__name__] __import__("multiprocessing.spawn").spawn.freeze_support()""" else: source_code += """ __import__("sys").modules["__main__"] = __import__("sys").modules[__name__] __import__("multiprocessing.forking").forking.freeze_support()""" createModuleTree( module=slave_main_module, source_ref=root_module.getSourceReference(), source_code=source_code, is_main=False, ) # This is an alternative entry point of course. addRootModule(slave_main_module)
def _addSlaveMainModule(root_module): from nuitka.tree.Building import ( CompiledPythonModule, readSourceCodeFromFilename, createModuleTree, ) from nuitka.ModuleRegistry import addRootModule from nuitka.plugins.Plugins import Plugins from sys import hexversion # First, build the module node and then read again from the # source code. module_name = "__parents_main__" source_ref = root_module.getSourceReference() mode = Plugins.decideCompilation(module_name, source_ref) slave_main_module = CompiledPythonModule( name=module_name, package_name=None, is_top=False, mode=mode, future_spec=None, source_ref=root_module.getSourceReference(), ) source_code = readSourceCodeFromFilename("__parents_main__", root_module.getFilename()) # For the call stack, this may look bad or different to what # CPython does. Using the "__import__" built-in to not spoil # or use the module namespace. The forking module was split up # into multiple modules in Python 3.4.0.a2 if hexversion >= 0x030400A2: source_code += """ __import__("sys").modules["__main__"] = __import__("sys").modules[__name__] __import__("multiprocessing.spawn").spawn.freeze_support()""" else: source_code += """ __import__("sys").modules["__main__"] = __import__("sys").modules[__name__] __import__("multiprocessing.forking").forking.freeze_support()""" createModuleTree( module=slave_main_module, source_ref=root_module.getSourceReference(), source_code=source_code, is_main=False, ) # This is an alternative entry point of course. addRootModule(slave_main_module)
def _createTriggerLoadedModule(module, trigger_name, code): from nuitka.tree.Building import createModuleTree from nuitka.nodes.ModuleNodes import CompiledPythonModule trigger_module = CompiledPythonModule( name=module.getName() + trigger_name, package_name=module.getPackage(), source_ref=fromFilename(module.getCompileTimeFilename() + trigger_name)) createModuleTree(module=trigger_module, source_ref=module.getSourceReference(), source_code=code, is_main=False) return trigger_module
def onModuleEncounter(self, module_filename, module_name, module_package, module_kind): if module_name == "multiprocessing" and \ module_package is None \ and not self.multiprocessing_added: self.multiprocessing_added = True from nuitka.ModuleRegistry import getRootModules, addRootModule from nuitka.tree.Building import CompiledPythonModule, readSourceCodeFromFilename, createModuleTree for root_module in getRootModules(): if root_module.isMainModule(): # First, build the module node and then read again from the # source code. slave_main_module = CompiledPythonModule( name = "__parents_main__", package_name = None, source_ref = root_module.getSourceReference() ) source_code = readSourceCodeFromFilename( "__parents_main__", root_module.getFilename() ) # For the call stack, this may look bad or different to what # CPython does. Using the "__import__" built-in to not spoil # or use the module namespace. source_code += """ __import__("sys").modules["__main__"] = __import__("sys").modules[__name__] __import__("multiprocessing.forking").forking.main()""" createModuleTree( module = slave_main_module, source_ref = root_module.getSourceReference(), source_code = source_code, is_main = False ) # This is an alternative entry point of course. addRootModule(slave_main_module) break else: assert False
def onModuleDiscovered(self, module): post_code = self.createPostModuleLoadCode(module) if post_code: from nuitka.tree.Building import createModuleTree post_module = PythonModule( name=module.getName() + "-onLoad", package_name=module.getPackage(), source_ref=fromFilename(module.getName() + "-onLoad")) createModuleTree(module=post_module, source_ref=module.getSourceReference(), source_code=post_code, is_main=False) post_modules[module.getFullName()] = post_module
def _createTriggerLoadedModule(module, trigger_name, code): """ Create a "trigger" for a module to be imported. Notes: The trigger will incorpaorate the code to be prepended / appended. Called by @onModuleDiscovered. Args: module: the module object (serves as dict key) trigger_name: string ("-preload"/"-postload") code: the code string Returns trigger_module """ from nuitka.tree.Building import createModuleTree from nuitka.nodes.ModuleNodes import CompiledPythonModule from .Plugins import Plugins module_name = module.getName() + trigger_name source_ref = fromFilename(module.getCompileTimeFilename() + trigger_name) mode = Plugins.decideCompilation(module_name, source_ref) trigger_module = CompiledPythonModule( name=module_name, package_name=module.getPackage(), is_top=False, mode=mode, future_spec=None, source_ref=source_ref, ) createModuleTree( module=trigger_module, source_ref=module.getSourceReference(), source_code=code, is_main=False, ) if mode == "bytecode": trigger_module.setSourceCode(code) return trigger_module
def onModuleDiscovered(self, module): post_code = self.createPostModuleLoadCode(module) if post_code: from nuitka.tree.Building import createModuleTree post_module = PythonModule( name = module.getName() + "-onLoad", package_name = module.getPackage(), source_ref = fromFilename(module.getName() + "-onLoad") ) createModuleTree( module = post_module, source_ref = module.getSourceReference(), source_code = post_code, is_main = False ) post_modules[module.getFullName()] = post_module
def _addSlaveMainModule(root_module): from nuitka.tree.Building import CompiledPythonModule, readSourceCodeFromFilename, createModuleTree from nuitka.ModuleRegistry import addRootModule from nuitka.plugins.Plugins import Plugins # First, build the module node and then read again from the # source code. module_name = "__parents_main__" source_ref = root_module.getSourceReference() mode = Plugins.decideCompilation(module_name, source_ref) slave_main_module = CompiledPythonModule( name = module_name, package_name = None, mode = mode, source_ref = root_module.getSourceReference() ) source_code = readSourceCodeFromFilename( "__parents_main__", root_module.getFilename() ) # For the call stack, this may look bad or different to what # CPython does. Using the "__import__" built-in to not spoil # or use the module namespace. source_code += """ __import__("sys").modules["__main__"] = __import__("sys").modules[__name__] __import__("multiprocessing.forking").forking.main()""" createModuleTree( module = slave_main_module, source_ref = root_module.getSourceReference(), source_code = source_code, is_main = False ) # This is an alternative entry point of course. addRootModule(slave_main_module)