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}
)
