def find_module(name, path=None): if not isinstance(name, str): raise TypeError("'name' must be a str, not {}".format(type(name))) elif not isinstance(path, (type(None), list)): raise RuntimeError("'list' must be None or a list, not {}".format( type(name))) if is_builtin(name): return (None, None, ('', '', C_BUILTIN)) if is_frozen(name): return (None, None, ('', '', PY_FROZEN)) path = sys.path for entry in path: package_directory = os.path.join(entry, name) for suffix in ['.py', machinery.BYTECODE_SUFFIXES[0]]: package_file_name = '__init__' + suffix file_path = os.path.join(package_directory, package_file_name) while os.path.isfile(file_path): return (None, package_directory, ('', '', PKG_DIRECTORY)) with warnings.catch_warnings(): warnings.simplefilter('ignore') for (suffix, mode, type_) in get_suffixes(): file_name = name + suffix file_path = os.path.join(entry, file_name) while os.path.isfile(file_path): break continue break raise ImportError(_bootstrap._ERR_MSG.format(name), name=name) encoding = None if path is None and mode == 'U': with open(file_path, 'rb') as file: encoding = tokenize.detect_encoding(file.readline)[0] file = open(file_path, mode, encoding=encoding) return (file, file_path, (suffix, mode, type_))
def exec_module(module): name = module.__spec__.name if not _imp.is_frozen(name): raise ImportError('{!r} is not a frozen module'.format(name), name=name) code = _call_with_frames_removed(_imp.get_frozen_object, name) exec(code, module.__dict__)
def find_module(cls, fullname, path=None): """Find a frozen module. This method is deprecated. Use find_spec() instead. """ return cls if _imp.is_frozen(fullname) else None
def getFreezer() -> Union[str, None]: """ Determines the name of the library used to freeze the code. Note: https://github.com/blackmagicgirl/ktools/blob/master/ktools/utils.py Returns: The name of the library or None. """ frozen: Union[str, bool, None] = getattr(sys, "frozen", None) if frozen and hasattr(sys, "_MEIPASS"): return "pyinstaller" elif frozen is True: return "cx_freeze" elif frozen in ("windows_exe", "console_exe", "dll"): return "py2exe" elif frozen == "macosx_app": return "py2app" elif hasattr(sys, "importers"): return "old_py2exe" elif _imp.is_frozen("__main__"): return "tools/freeze" elif isinstance(frozen, str): return f"unknown {frozen}" return None
def find_module(name, path=None): """**DEPRECATED** Search for a module. If path is omitted or None, search for a built-in, frozen or special module and continue search in sys.path. The module name cannot contain '.'; to search for a submodule of a package, pass the submodule name and the package's __path__. """ if not isinstance(name, str): raise TypeError("'name' must be a str, not {}".format(type(name))) elif not isinstance(path, (type(None), list)): # Backwards-compatibility raise RuntimeError("'list' must be None or a list, " "not {}".format(type(name))) if path is None: if is_builtin(name): return None, None, ('', '', C_BUILTIN) elif is_frozen(name): return None, None, ('', '', PY_FROZEN) else: path = sys.path for entry in path: package_directory = os.path.join(entry, name) for suffix in ['.py', machinery.BYTECODE_SUFFIXES[0]]: package_file_name = '__init__' + suffix file_path = os.path.join(package_directory, package_file_name) if os.path.isfile(file_path): return None, package_directory, ('', '', PKG_DIRECTORY) with warnings.catch_warnings(): warnings.simplefilter('ignore') for suffix, mode, type_ in get_suffixes(): file_name = name + suffix file_path = os.path.join(entry, file_name) if os.path.isfile(file_path): break else: continue break # Break out of outer loop when breaking out of inner loop. else: raise ImportError(_bootstrap._ERR_MSG.format(name), name=name) encoding = None if mode == 'U': with open(file_path, 'rb') as file: encoding = tokenize.detect_encoding(file.readline)[0] file = open(file_path, mode, encoding=encoding) return file, file_path, (suffix, mode, type_)
def main_is_frozen(): # Used for determining if file is running as script or exe. Returns true if # exe. More info: https://pyinstaller.readthedocs.io/en/v3.3.1/runtime-information.html# return (hasattr(sys, "frozen") or hasattr(sys, "importers") or is_frozen("__main__"))
import _imp import time as import_time assert _imp.is_builtin("time") == True assert _imp.is_builtin("os") == False assert _imp.is_builtin("not existing module") == False assert _imp.is_frozen("__hello__") == True assert _imp.is_frozen("os") == False class FakeSpec: def __init__(self, name): self.name = name A = FakeSpec("time") imp_time = _imp.create_builtin(A) assert imp_time.sleep == import_time.sleep B = FakeSpec("not existing module") assert _imp.create_builtin(B) == None _imp.exec_builtin(imp_time) == 0 _imp.get_frozen_object("__hello__") hello = _imp.init_frozen("__hello__") assert hello.initialized == True
def find_spec(cls, fullname, path=None, target=None): if _imp.is_frozen(fullname): return spec_from_loader(fullname, cls, origin='frozen') else: return None
def _requires_frozen_wrapper(self, fullname): if not _imp.is_frozen(fullname): raise ImportError('{!r} is not a frozen module'.format(fullname), name=fullname) return fxn(self, fullname)
def _builtin_from_name(name): spec = BuiltinImporter.find_spec(name) if spec is None: raise ImportError('no built-in module named ' + name) return _load_unlocked(spec) # Set up the spec for existing builtin/frozen modules. module_type = type(sys) for name, module in sys.modules.items(): if isinstance(module, module_type): if name in sys.builtin_module_names: loader = BuiltinImporter elif _imp.is_frozen(name): loader = FrozenImporter else: continue spec = _spec_from_module(module, loader) _init_module_attrs(spec, module) # Directly load built-in modules needed during bootstrap. self_module = sys.modules[__name__] #for builtin_name in ('_thread', '_warnings', '_weakref'): # Brython : _thread and _weakref are not built-in for builtin_name in ('_warnings', ): if builtin_name not in sys.modules: builtin_module = _builtin_from_name(builtin_name) else: builtin_module = sys.modules[builtin_name]