x3x3x3x_5h3ll
— 53cur3 — 5h3ll_1d —
Linux vps-10654784.cedaps.org.br 3.10.0-1160.119.1.el7.x86_64 #1 SMP Tue Jun 4 14:43:51 UTC 2024 x86_64
  INFO SERVER : Apache PHP : 7.4.33
/opt/alt/python38/lib64/python3.8/importlib/
162.240.100.168

 
[ NAME ] [ SIZE ] [ PERM ] [ DATE ] [ ACTN ]
+FILE +DIR
__pycache__ dir drwxr-xr-x 2023-04-05 00:29 R D
  __init__.py 5.919 KB -rw-r--r-- 2021-08-30 14:26 R E G D
  _bootstrap.py 38.715 KB -rw-r--r-- 2021-08-30 14:26 R E G D
  _bootstrap_external.py 63.006 KB -rw-r--r-- 2021-08-30 14:26 R E G D
  abc.py 12.571 KB -rw-r--r-- 2021-08-30 14:26 R E G D
  machinery.py 0.824 KB -rw-r--r-- 2021-08-30 14:26 R E G D
  metadata.py 17.213 KB -rw-r--r-- 2021-08-30 14:26 R E G D
  resources.py 9.313 KB -rw-r--r-- 2021-08-30 14:26 R E G D
  util.py 11.054 KB -rw-r--r-- 2021-08-30 14:26 R E G D
REQUEST EXIT
"""Core implementation of import. This module is NOT meant to be directly imported! It has been designed such that it can be bootstrapped into Python as the implementation of import. As such it requires the injection of specific modules and attributes in order to work. One should use importlib as the public-facing version of this module. """ # # IMPORTANT: Whenever making changes to this module, be sure to run a top-level # `make regen-importlib` followed by `make` in order to get the frozen version # of the module updated. Not doing so will result in the Makefile to fail for # all others who don't have a ./python around to freeze the module # in the early stages of compilation. # # See importlib._setup() for what is injected into the global namespace. # When editing this code be aware that code executed at import time CANNOT # reference any injected objects! This includes not only global code but also # anything specified at the class level. # Bootstrap-related code ###################################################### _bootstrap_external = None def _wrap(new, old): """Simple substitute for functools.update_wrapper.""" for replace in ['__module__', '__name__', '__qualname__', '__doc__']: if hasattr(old, replace): setattr(new, replace, getattr(old, replace)) new.__dict__.update(old.__dict__) def _new_module(name): return type(sys)(name) # Module-level locking ######################################################## # A dict mapping module names to weakrefs of _ModuleLock instances # Dictionary protected by the global import lock _module_locks = {} # A dict mapping thread ids to _ModuleLock instances _blocking_on = {} class _DeadlockError(RuntimeError): pass class _ModuleLock: """A recursive lock implementation which is able to detect deadlocks (e.g. thread 1 trying to take locks A then B, and thread 2 trying to take locks B then A). """ def __init__(self, name): self.lock = _thread.allocate_lock() self.wakeup = _thread.allocate_lock() self.name = name self.owner = None self.count = 0 self.waiters = 0 def has_deadlock(self): # Deadlock avoidance for concurrent circular imports. me = _thread.get_ident() tid = self.owner while True: lock = _blocking_on.get(tid) if lock is None: return False tid = lock.owner if tid == me: return True def acquire(self): """ Acquire the module lock. If a potential deadlock is detected, a _DeadlockError is raised. Otherwise, the lock is always acquired and True is returned. """ tid = _thread.get_ident() _blocking_on[tid] = self try: while True: with self.lock: if self.count == 0 or self.owner == tid: self.owner = tid self.count += 1 return True if self.has_deadlock(): raise _DeadlockError('deadlock detected by %r' % self) if self.wakeup.acquire(False): self.waiters += 1 # Wait for a release() call self.wakeup.acquire() self.wakeup.release() finally: del _blocking_on[tid] def release(self): tid = _thread.get_ident() with self.lock: if self.owner != tid: raise RuntimeError('cannot release un-acquired lock') assert self.count > 0 self.count -= 1 if self.count == 0: self.owner = None if self.waiters: self.waiters -= 1 self.wakeup.release() def __repr__(self): return '_ModuleLock({!r}) at {}'.format(self.name, id(self)) class _DummyModuleLock: """A simple _ModuleLock equivalent for Python builds without multi-threading support.""" def __init__(self, name): self.name = name self.count = 0 def acquire(self): self.count += 1 return True def release(self): if self.count == 0: raise RuntimeError('cannot release un-acquired lock') self.count -= 1 def __repr__(self): return '_DummyModuleLock({!r}) at {}'.format(self.name, id(self)) class _ModuleLockManager: def __init__(self, name): self._name = name self._lock = None def __enter__(self): self._lock = _get_module_lock(self._name) self._lock.acquire() def __exit__(self, *args, **kwargs): self._lock.release() # The following two functions are for consumption by Python/import.c. def _get_module_lock(name): """Get or create the module lock for a given module name. Acquire/release internally the global import lock to protect _module_locks.""" _imp.acquire_lock() try: try: lock = _module_locks[name]() except KeyError: lock = None if lock is None: if _thread is None: lock = _DummyModuleLock(name) else: lock = _ModuleLock(name) def cb(ref, name=name): _imp.acquire_lock() try: # bpo-31070: Check if another thread created a new lock # after the previous lock was destroyed # but before the weakref callback was called. if _module_locks.get(name) is ref: del _module_locks[name] finally: _imp.release_lock() _module_locks[name] = _weakref.ref(lock, cb) finally: _imp.release_lock() return lock def _lock_unlock_module(name): """Acquires then releases the module lock for a given module name. This is used to ensure a module is completely initialized, in the event it is being imported by another thread. """ lock = _get_module_lock(name) try: lock.acquire() except _DeadlockError: # Concurrent circular import, we'll accept a partially initialized # module object. pass else: lock.release() # Frame stripping magic ############################################### def _call_with_frames_removed(f, *args, **kwds): """remove_importlib_frames in import.c will always remove sequences of importlib frames that end with a call to this function Use it instead of a normal call in places where including the importlib frames introduces unwanted noise into the traceback (e.g. when executing module code) """ return f(*args, **kwds) def _verbose_message(message, *args, verbosity=1): """Print the message to stderr if -v/PYTHONVERBOSE is turned on.""" if sys.flags.verbose >= verbosity: if not message.startswith(('#', 'import ')): message = '# ' + message print(message.format(*args), file=sys.stderr) def _requires_builtin(fxn): """Decorator to verify the named module is built-in.""" def _requires_builtin_wrapper(self, fullname): if fullname not in sys.builtin_module_names: raise ImportError('{!r} is not a built-in module'.format(fullname), name=fullname) return fxn(self, fullname) _wrap(_requires_builtin_wrapper, fxn) return _requires_builtin_wrapper def _requires_frozen(fxn): """Decorator to verify the named module is frozen.""" 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) _wrap(_requires_frozen_wrapper, fxn) return _requires_frozen_wrapper # Typically used by loader classes as a method replacement. def _load_module_shim(self, fullname): """Load the specified module into sys.modules and return it. This method is deprecated. Use loader.exec_module instead. """ spec = spec_from_loader(fullname, self) if fullname in sys.modules: module = sys.modules[fullname] _exec(spec, module) return sys.modules[fullname] else: return _load(spec) # Module specifications ####################################################### def _module_repr(module): # The implementation of ModuleType.__repr__(). loader = getattr(module, '__loader__', None) if hasattr(loader, 'module_repr'): # As soon as BuiltinImporter, FrozenImporter, and NamespaceLoader # drop their implementations for module_repr. we can add a # deprecation warning here. try: return loader.module_repr(module) except Exception: pass try: spec = module.__spec__ except AttributeError: pass else: if spec is not None: return _module_repr_from_spec(spec) # We could use module.__class__.__name__ instead of 'module' in the # various repr permutations. try: name = module.__name__ except AttributeError: name = '?' try: filename = module.__file__ except AttributeError: if loader is None: return ''.format(name) else: return ''.format(name, loader) else: return ''.format(name, filename) class ModuleSpec: """The specification for a module, used for loading. A module's spec is the source for information about the module. For data associated with the module, including source, use the spec's loader. `name` is the absolute name of the module. `loader` is the loader to use when loading the module. `parent` is the name of the package the module is in. The parent is derived from the name. `is_package` determines if the module is considered a package or not. On modules this is reflected by the `__path__` attribute. `origin` is the specific location used by the loader from which to load the module, if that information is available. When filename is set, origin will match. `has_location` indicates that a spec's "origin" reflects a location. When this is True, `__file__` attribute of the module is set. `cached` is the location of the cached bytecode file, if any. It corresponds to the `__cached__` attribute. `submodule_search_locations` is the sequence of path entries to search when importing submodules. If set, is_package should be True--and False otherwise. Packages are simply modules that (may) have submodules. If a spec has a non-None value in `submodule_search_locations`, the import system will consider modules loaded from the spec as packages. Only finders (see importlib.abc.MetaPathFinder and importlib.abc.PathEntryFinder) should modify ModuleSpec instances. """ def __init__(self, name, loader, *, origin=None, loader_state=None, is_package=None): self.name = name self.loader = loader self.origin = origin self.loader_state = loader_state self.submodule_search_locations = [] if is_package else None # file-location attributes self._set_fileattr = False self._cached = None def __repr__(self): args = ['name={!r}'.format(self.name), 'loader={!r}'.format(self.loader)] if self.origin is not None: args.append('origin={!r}'.format(self.origin)) if self.submodule_search_locations is not None: args.append('submodule_search_locations={}' .format(self.submodule_search_locations)) return '{}({})'.format(self.__class__.__name__, ', '.join(args)) def __eq__(self, other): smsl = self.submodule_search_locations try: return (self.name == other.name and self.loader == other.loader and self.origin == other.origin and smsl == other.submodule_search_locations and self.cached == other.cached and self.has_location == other.has_location) except AttributeError: return False @property def cached(self): if self._cached is None: if self.origin is not None and self._set_fileattr: if _bootstrap_external is None: raise NotImplementedError self._cached = _bootstrap_external._get_cached(self.origin) return self._cached @cached.setter def cached(self, cached): self._cached = cached @property def parent(self): """The name of the module's parent.""" if self.submodule_search_locations is None: return self.name.rpartition('.')[0] else: return self.name @property def has_location(self): return self._set_fileattr @has_location.setter def has_location(self, value): self._set_fileattr = bool(value) def spec_from_loader(name, loader, *, origin=None, is_package=None): """Return a module spec based on various loader methods.""" if hasattr(loader, 'get_filename'): if _bootstrap_external is None: raise NotImplementedError spec_from_file_location = _bootstrap_external.spec_from_file_location if is_package is None: return spec_from_file_location(name, loader=loader) search = [] if is_package else None return spec_from_file_location(name, loader=loader, submodule_search_locations=search) if is_package is None: if hasattr(loader, 'is_package'): try: is_package = loader.is_package(name) except ImportError: is_package = None # aka, undefined else: # the default is_package = False return ModuleSpec(name, loader, origin=origin, is_package=is_package) def _spec_from_module(module, loader=None, origin=None): # This function is meant for use in _setup(). try: spec = module.__spec__ except AttributeError: pass else: if spec is not None: return spec name = module.__name__ if loader is None: try: loader = module.__loader__ except AttributeError: # loader will stay None. pass try: location = module.__file__ except AttributeError: location = None if origin is None: if location is None: try: origin = loader._ORIGIN except AttributeError: origin = None else: origin = location try: cached = module.__cached__ except AttributeError: cached = None try: submodule_search_locations = list(module.__path__) except AttributeError: submodule_search_locations = None spec = ModuleSpec(name, loader, origin=origin) spec._set_fileattr = False if location is None else True spec.cached = cached spec.submodule_search_locations = submodule_search_locations return spec def _init_module_attrs(spec, module, *, override=False): # The passed-in module may be not support attribute assignment, # in which case we simply don't set the attributes. # __name__ if (override or getattr(module, '__name__', None) is None): try: module.__name__ = spec.name except AttributeError: pass # __loader__ if override or getattr(module, '__loader__', None) is None: loader = spec.loader if loader is None: # A backward compatibility hack. if spec.submodule_search_locations is not None: if _bootstrap_external is None: raise NotImplementedError _NamespaceLoader = _bootstrap_external._NamespaceLoader loader = _NamespaceLoader.__new__(_NamespaceLoader) loader._path = spec.submodule_search_locations spec.loader = loader # While the docs say that module.__file__ is not set for # built-in modules, and the code below will avoid setting it if # spec.has_location is false, this is incorrect for namespace # packages. Namespace packages have no location, but their # __spec__.origin is None, and thus their module.__file__ # should also be None for consistency. While a bit of a hack, # this is the best place to ensure this consistency. # # See # https://docs.python.org/3/library/importlib.html#importlib.abc.Loader.load_module # and bpo-32305 module.__file__ = None try: module.__loader__ = loader except AttributeError: pass # __package__ if override or getattr(module, '__package__', None) is None: try: module.__package__ = spec.parent except AttributeError: pass # __spec__ try: module.__spec__ = spec except AttributeError: pass # __path__ if override or getattr(module, '__path__', None) is None: if spec.submodule_search_locations is not None: try: module.__path__ = spec.submodule_search_locations except AttributeError: pass # __file__/__cached__ if spec.has_location: if override or getattr(module, '__file__', None) is None: try: module.__file__ = spec.origin except AttributeError: pass if override or getattr(module, '__cached__', None) is None: if spec.cached is not None: try: module.__cached__ = spec.cached except AttributeError: pass return module def module_from_spec(spec): """Create a module based on the provided spec.""" # Typically loaders will not implement create_module(). module = None if hasattr(spec.loader, 'create_module'): # If create_module() returns `None` then it means default # module creation should be used. module = spec.loader.create_module(spec) elif hasattr(spec.loader, 'exec_module'): raise ImportError('loaders that define exec_module() ' 'must also define create_module()') if module is None: module = _new_module(spec.name) _init_module_attrs(spec, module) return module def _module_repr_from_spec(spec): """Return the repr to use for the module.""" # We mostly replicate _module_repr() using the spec attributes. name = '?' if spec.name is None else spec.name if spec.origin is None: if spec.loader is None: return ''.format(name) else: return ''.format(name, spec.loader) else: if spec.has_location: return ''.format(name, spec.origin) else: return ''.format(spec.name, spec.origin) # Used by importlib.reload() and _load_module_shim(). def _exec(spec, module): """Execute the spec's specified module in an existing module's namespace.""" name = spec.name with _ModuleLockManager(name): if sys.modules.get(name) is not module: msg = 'module {!r} not in sys.modules'.format(name) raise ImportError(msg, name=name) try: if spec.loader is None: if spec.submodule_search_locations is None: raise ImportError('missing loader', name=spec.name) # Namespace package. _init_module_attrs(spec, module, override=True) else: _init_module_attrs(spec, module, override=True) if not hasattr(spec.loader, 'exec_module'): # (issue19713) Once BuiltinImporter and ExtensionFileLoader # have exec_module() implemented, we can add a deprecation # warning here. spec.loader.load_module(name) else: spec.loader.exec_module(module) finally: # Update the order of insertion into sys.modules for module # clean-up at shutdown. module = sys.modules.pop(spec.name) sys.modules[spec.name] = module return module def _load_backward_compatible(spec): # (issue19713) Once BuiltinImporter and ExtensionFileLoader # have exec_module() implemented, we can add a deprecation # warning here. try: spec.loader.load_module(spec.name) except: if spec.name in sys.modules: module = sys.modules.pop(spec.name) sys.modules[spec.name] = module raise # The module must be in sys.modules at this point! # Move it to the end of sys.modules. module = sys.modules.pop(spec.name) sys.modules[spec.name] = module if getattr(module, '__loader__', None) is None: try: module.__loader__ = spec.loader except AttributeError: pass if getattr(module, '__package__', None) is None: try: # Since module.__path__ may not line up with # spec.submodule_search_paths, we can't necessarily rely # on spec.parent here. module.__package__ = module.__name__ if not hasattr(module, '__path__'): module.__package__ = spec.name.rpartition('.')[0] except AttributeError: pass if getattr(module, '__spec__', None) is None: try: module.__spec__ = spec except AttributeError: pass return module def _load_unlocked(spec): # A helper for direct use by the import system. if spec.loader is not None: # Not a namespace package. if not hasattr(spec.loader, 'exec_module'): return _load_backward_compatible(spec) module = module_from_spec(spec) # This must be done before putting the module in sys.modules # (otherwise an optimization shortcut in import.c becomes # wrong). spec._initializing = True try: sys.modules[spec.name] = module try: if spec.loader is None: if spec.submodule_search_locations is None: raise ImportError('missing loader', name=spec.name) # A namespace package so do nothing. else: spec.loader.exec_module(module) except: try: del sys.modules[spec.name] except KeyError: pass raise # Move the module to the end of sys.modules. # We don't ensure that the import-related module attributes get # set in the sys.modules replacement case. Such modules are on # their own. module = sys.modules.pop(spec.name) sys.modules[spec.name] = module _verbose_message('import {!r} # {!r}', spec.name, spec.loader) finally: spec._initializing = False return module # A method used during testing of _load_unlocked() and by # _load_module_shim(). def _load(spec): """Return a new module object, loaded by the spec's loader. The module is not added to its parent. If a module is already in sys.modules, that existing module gets clobbered. """ with _ModuleLockManager(spec.name): return _load_unlocked(spec) # Loaders ##################################################################### class BuiltinImporter: """Meta path import for built-in modules. All methods are either class or static methods to avoid the need