def _reportImplicitImports(implicit_imports, signal_change): from nuitka.importing import Recursion from nuitka.importing.Importing import getModuleNameAndKindFromFilename for full_name, module_filename in implicit_imports: _module_name2, module_kind = getModuleNameAndKindFromFilename( module_filename) # This will get back to all other plugins allowing them to inhibit it though. decision, reason = Recursion.decideRecursion( module_filename=module_filename, module_name=full_name, module_kind=module_kind, ) if decision: imported_module, added_flag = Recursion.recurseTo( module_package=full_name.getPackageName(), module_filename=module_filename, module_relpath=relpath(module_filename), module_kind=module_kind, reason=reason, ) addUsedModule(imported_module) if added_flag: signal_change( "new_code", imported_module.getSourceReference(), "Recursed to module.", )
def _reportImplicitImports(plugin, module, implicit_imports, signal_change): from nuitka.importing import Recursion from nuitka.importing.Importing import getModuleNameAndKindFromFilename for full_name, module_filename in implicit_imports: _module_name2, module_kind = getModuleNameAndKindFromFilename( module_filename) # This will get back to all other plugins allowing them to inhibit it though. decision, reason = Recursion.decideRecursion( module_filename=module_filename, module_name=full_name, module_kind=module_kind, ) if decision: imported_module = Recursion.recurseTo( signal_change=signal_change, module_name=full_name, module_filename=module_filename, module_kind=module_kind, reason=reason, ) addUsedModule( module=imported_module, using_module=module, usage_tag="plugin:" + plugin.plugin_name, reason=reason, source_ref=module.source_ref, )
def _consider(self, trace_collection, module_filename, module_package): assert module_package is None or ( type(module_package) is ModuleName and module_package != ""), repr(module_package) module_filename = os.path.normpath(module_filename) module_name, module_kind = getModuleNameAndKindFromFilename( module_filename) if module_kind is not None: module_fullpath = ModuleName.makeModuleNameInPackage( module_name, module_package) decision, reason = decideRecursion( module_filename=module_filename, module_name=module_fullpath, module_kind=module_kind, ) if decision: module_relpath = relpath(module_filename) imported_module, added_flag = recurseTo( module_package=module_package, module_filename=module_filename, module_relpath=module_relpath, module_kind=module_kind, reason=reason, ) if added_flag: trace_collection.signalChange( "new_code", imported_module.getSourceReference(), "Recursed to module.", ) return imported_module elif decision is False and module_kind == "py": uncompiled_module = getUncompiledModule( module_fullpath, module_filename) if uncompiled_module is not None: return uncompiled_module elif decision is None and module_kind == "py": if (module_filename not in self._warned_about and module_fullpath not in getModuleIgnoreList()): self._warned_about.add(module_filename) inclusion_logger.warning("""\ Not recursing to '%(full_path)s' (%(filename)s), please specify \ --nofollow-imports (do not warn), \ --follow-imports (recurse to all), \ --nofollow-import-to=%(full_path)s (ignore it), \ --follow-import-to=%(full_path)s (recurse to it) to change.""" % { "full_path": module_fullpath, "filename": module_filename })
def attemptRecursion(self): # Make sure the package is recursed to. # Return the list of newly added modules. result = [] if self.package_name is not None and self.package is None: self.package = getModuleByName(self.package_name) if self.package_name is not None and self.package is None: package_package, package_filename, finding = findModule( importing=self, module_name=self.package_name, parent_package=None, level=1, warn=python_version < 330) # TODO: Temporary, if we can't find the package for Python3.3 that # is semi-OK, maybe. if python_version >= 330 and not package_filename: return [] if self.package_name == "uniconvertor.app.modules": return [] assert package_filename is not None, (self.package_name, finding) _package_name, package_kind = getModuleNameAndKindFromFilename( package_filename) # assert _package_name == self.package_name, (package_filename, _package_name, self.package_name) decision, _reason = decideRecursion( module_filename=package_filename, module_name=self.package_name, module_package=package_package, module_kind=package_kind) if decision is not None: self.package, is_added = recurseTo( module_package=package_package, module_filename=package_filename, module_relpath=relpath(package_filename), module_kind="py", reason="Containing package of recursed module '%s'." % self.getFullName(), ) if is_added: result.append(self.package) if self.package: from nuitka.ModuleRegistry import addUsedModule addUsedModule(self.package) # print "Recursed to package", self.package_name result.extend(self.package.attemptRecursion()) return result
def considerImplicitImports(self, module, signal_change): """Provide additional modules to import implicitly when encountering the module. Notes: Better do not overload this method. The standard plugin 'ImplicitImports.py' already contains MANY of these. If you do have a new candidate, consider a PR to get it included there. Args: module: the module object signal_change: bool Returns: None """ from nuitka.importing.Importing import getModuleNameAndKindFromFilename for full_name in self.getImplicitImports(module): if type(full_name) in (tuple, list): raise NuitkaPluginError( "Plugin %s needs to be change to only return modules names, not %r" % (self, full_name)) full_name = ModuleName(full_name) try: module_filename = self.locateModule(importing=module, module_name=full_name) except Exception: self.warning("Problem locating '%s' implicit imports '%s'." % (module.getFullName(), full_name)) raise if module_filename is None: if Options.isShowInclusion(): self.info( "Implicit module '%s' suggested by '%s' not found." % (full_name, module.getFullName())) continue _module_name2, module_kind = getModuleNameAndKindFromFilename( module_filename) # TODO: This should get back to plug-ins, they should be allowed to # preempt or override the decision. decision, reason = self.decideRecursion( module_filename=module_filename, module_name=full_name, module_kind=module_kind, ) if decision: self.recurseTo( module_package=full_name.getPackageName(), module_filename=module_filename, module_kind=module_kind, reason=reason, signal_change=signal_change, )
def attemptRecursion(self): # Make sure the package is recursed to if any package_name = self.module_name.getPackageName() if package_name is None: return () # Return the list of newly added modules. package = getModuleByName(package_name) if package_name is not None and package is None: _package_name, package_filename, finding = locateModule( module_name=package_name, parent_package=None, level=0, ) # If we can't find the package for Python3.3 that is semi-OK, it might be in a # namespace package, these have no init code. if python_version >= 0x300 and not package_filename: return () if package_name == "uniconvertor.app.modules": return () assert package_filename is not None, (package_name, finding) _package_name, package_kind = getModuleNameAndKindFromFilename( package_filename ) # assert _package_name == self.package_name, (package_filename, _package_name, self.package_name) decision, _reason = decideRecursion( module_filename=package_filename, module_name=package_name, module_kind=package_kind, ) if decision is not None: package = recurseTo( signal_change=self.trace_collection.signalChange if hasattr(self, "trace_collection") else None, module_name=package_name, module_filename=package_filename, module_kind="py", reason="Containing package of '%s'." % self.getFullName(), ) if package: from nuitka.ModuleRegistry import addUsedModule addUsedModule( package, using_module=self, usage_tag="package", reason="Containing package of '%s'." % self.getFullName(), source_ref=self.source_ref, )
def attemptRecursion(self): # Make sure the package is recursed to. # Return the list of newly added modules. result = [] if self.package_name is not None and self.package is None: package_package, package_filename, _finding = findModule( importing = self, module_name = self.package_name, parent_package = None, level = 1, warn = python_version < 330 ) # TODO: Temporary, if we can't find the package for Python3.3 that # is semi-OK, maybe. if python_version >= 330 and not package_filename: return [] if self.package_name == "uniconvertor.app.modules": return [] assert package_filename is not None, self.package_name _package_name, package_kind = getModuleNameAndKindFromFilename(package_filename) # assert _package_name == self.package_name, (package_filename, _package_name, self.package_name) decision, _reason = decideRecursion( module_filename = package_filename, module_name = self.package_name, module_package = package_package, module_kind = package_kind ) if decision is not None: imported_module, is_added = recurseTo( module_package = package_package, module_filename = package_filename, module_relpath = Utils.relpath(package_filename), module_kind = "py", reason = "Containing package of recursed module '%s'." % self.getFullName(), ) self.package = imported_module if is_added: result.append(imported_module) if self.package: from nuitka.ModuleRegistry import addUsedModule addUsedModule(self.package) # print "Recursed to package", self.package_name result.extend(self.package.attemptRecursion()) return result
def _consider(self, constraint_collection, module_filename, module_package): assert module_package is None or \ (type(module_package) is str and module_package != "") module_filename = Utils.normpath(module_filename) module_name, module_kind = getModuleNameAndKindFromFilename(module_filename) if module_kind is not None: decision, reason = decideRecursion( module_filename = module_filename, module_name = module_name, module_package = module_package, module_kind = module_kind ) if decision: module_relpath = Utils.relpath(module_filename) imported_module, added_flag = recurseTo( module_package = module_package, module_filename = module_filename, module_relpath = module_relpath, module_kind = module_kind, reason = reason ) if added_flag: constraint_collection.signalChange( "new_code", imported_module.getSourceReference(), "Recursed to module." ) return imported_module elif decision is None and module_kind == "py": if module_package is None: module_fullpath = module_name else: module_fullpath = module_package + '.' + module_name if module_filename not in self._warned_about and \ module_fullpath not in getModuleWhiteList(): self._warned_about.add(module_filename) warning( """\ Not recursing to '%(full_path)s' (%(filename)s), please specify \ --recurse-none (do not warn), \ --recurse-all (recurse to all), \ --recurse-not-to=%(full_path)s (ignore it), \ --recurse-to=%(full_path)s (recurse to it) to change.""" % { "full_path" : module_fullpath, "filename" : module_filename } )
def considerImplicitImports(self, module, signal_change): """ Provide additional modules to import implicitly when encountering the module. Notes: Better do not overload this method. The standard plugin 'ImplicitImports.py' already contains MANY of these. If you do have a new candidate, consider a PR to get it included there. Args: module: the module object signal_change: bool Returns: None """ from nuitka.importing.Importing import getModuleNameAndKindFromFilename for full_name, required in self.getImplicitImports(module): module_name = full_name.split(".")[-1] module_package = ".".join(full_name.split(".")[:-1]) or None module_filename = self.locateModule( importing=module, module_name=module_name, module_package=module_package, warn=required, ) if module_filename is None: if required: sys.exit( "Error, implicit module '%s' expected by '%s' not found." % (full_name, module.getFullName())) else: continue _module_name2, module_kind = getModuleNameAndKindFromFilename( module_filename) # TODO: This should get back to plug-ins, they should be allowed to # preempt or override the decision. decision, reason = self.decideRecursion( module_filename=module_filename, module_name=module_name, module_package=module_package, module_kind=module_kind, ) if decision: self.recurseTo( module_package=module_package, module_filename=module_filename, module_kind=module_kind, reason=reason, signal_change=signal_change, )
def considerImplicitImports(self, module, signal_change): """ Provide additional modules to import implicitly when encountering the module. Notes: Better do not overload this method. The standard plugin 'ImplicitImports.py' already contains MANY of these. If you do have a new candidate, consider a PR to get it included there. Args: module: the module object signal_change: bool Returns: None """ from nuitka.importing.Importing import getModuleNameAndKindFromFilename for item in self.getImplicitImports(module): # TODO: Temporary, until all plugins are caught up, turn into an error later. if type(item) in (tuple, list): full_name, _required = item else: full_name = item full_name = ModuleName(full_name) module_filename = self.locateModule(importing=module, module_name=full_name) if module_filename is None: if Options.isShowInclusion(): self.info( "Implicit module '%s' suggested by '%s' not found." % (full_name, module.getFullName())) continue _module_name2, module_kind = getModuleNameAndKindFromFilename( module_filename) # TODO: This should get back to plug-ins, they should be allowed to # preempt or override the decision. decision, reason = self.decideRecursion( module_filename=module_filename, module_name=full_name, module_kind=module_kind, ) if decision: self.recurseTo( module_package=full_name.getPackageName(), module_filename=module_filename, module_kind=module_kind, reason=reason, signal_change=signal_change, )
def _consider(self, trace_collection, module_filename, module_package): assert module_package is None or ( type(module_package) is str and module_package != "" ), repr(module_package) module_filename = os.path.normpath(module_filename) module_name, module_kind = getModuleNameAndKindFromFilename(module_filename) if module_kind is not None: if module_package is None: module_fullpath = module_name else: module_fullpath = module_package + "." + module_name decision, reason = decideRecursion( module_filename=module_filename, module_name=module_name, module_package=module_package, module_kind=module_kind, ) if decision: module_relpath = relpath(module_filename) imported_module, added_flag = recurseTo( module_package=module_package, module_filename=module_filename, module_relpath=module_relpath, module_kind=module_kind, reason=reason, ) if added_flag: trace_collection.signalChange( "new_code", imported_module.getSourceReference(), "Recursed to module.", ) return imported_module elif decision is False and module_kind == "py": uncompiled_module = getUncompiledModule( module_fullpath, module_filename ) if uncompiled_module is not None: return uncompiled_module elif decision is None and module_kind == "py": if ( module_filename not in self._warned_about and module_fullpath not in getModuleWhiteList() ): self._warned_about.add(module_filename) warning( """\ Not recursing to '%(full_path)s' (%(filename)s), please specify \ --nofollow-imports (do not warn), \ --follow-imports (recurse to all), \ --nofollow-import-to=%(full_path)s (ignore it), \ --follow-import-to=%(full_path)s (recurse to it) to change.""" % {"full_path": module_fullpath, "filename": module_filename} )