Restoring authorship annotation for <orivej@yandex-team.ru>. Commit 1 of 2.

1 files changed, 387 insertions, 387 deletions

diff --git a/contrib/tools/python3/src/Lib/importlib/abc.py b/contrib/tools/python3/src/Lib/importlib/abc.py
index b8a9bb1a21..1bda0c7a85 100644
--- a/contrib/tools/python3/src/Lib/importlib/abc.py
+++ b/contrib/tools/python3/src/Lib/importlib/abc.py
@@ -1,392 +1,392 @@
-"""Abstract base classes related to import."""
-from . import _bootstrap
-from . import _bootstrap_external
-from . import machinery
-try:
-    import _frozen_importlib
-except ImportError as exc:
-    if exc.name != '_frozen_importlib':
-        raise
-    _frozen_importlib = None
-try:
-    import _frozen_importlib_external
+"""Abstract base classes related to import.""" 
+from . import _bootstrap 
+from . import _bootstrap_external 
+from . import machinery 
+try: 
+    import _frozen_importlib 
+except ImportError as exc: 
+    if exc.name != '_frozen_importlib': 
+        raise 
+    _frozen_importlib = None 
+try: 
+    import _frozen_importlib_external 
 except ImportError:
-    _frozen_importlib_external = _bootstrap_external
-import abc
-import warnings
+    _frozen_importlib_external = _bootstrap_external 
+import abc 
+import warnings 
 from typing import Protocol, runtime_checkable
-
-
-def _register(abstract_cls, *classes):
-    for cls in classes:
-        abstract_cls.register(cls)
-        if _frozen_importlib is not None:
-            try:
-                frozen_cls = getattr(_frozen_importlib, cls.__name__)
-            except AttributeError:
-                frozen_cls = getattr(_frozen_importlib_external, cls.__name__)
-            abstract_cls.register(frozen_cls)
-
-
-class Finder(metaclass=abc.ABCMeta):
-
-    """Legacy abstract base class for import finders.
-
-    It may be subclassed for compatibility with legacy third party
-    reimplementations of the import system.  Otherwise, finder
-    implementations should derive from the more specific MetaPathFinder
-    or PathEntryFinder ABCs.
-
-    Deprecated since Python 3.3
-    """
-
-    @abc.abstractmethod
-    def find_module(self, fullname, path=None):
-        """An abstract method that should find a module.
-        The fullname is a str and the optional path is a str or None.
-        Returns a Loader object or None.
-        """
-
-
-class MetaPathFinder(Finder):
-
-    """Abstract base class for import finders on sys.meta_path."""
-
-    # We don't define find_spec() here since that would break
-    # hasattr checks we do to support backward compatibility.
-
-    def find_module(self, fullname, path):
-        """Return a loader for the module.
-
-        If no module is found, return None.  The fullname is a str and
-        the path is a list of strings or None.
-
-        This method is deprecated since Python 3.4 in favor of
-        finder.find_spec(). If find_spec() exists then backwards-compatible
-        functionality is provided for this method.
-
-        """
-        warnings.warn("MetaPathFinder.find_module() is deprecated since Python "
-                      "3.4 in favor of MetaPathFinder.find_spec() "
-                      "(available since 3.4)",
-                      DeprecationWarning,
-                      stacklevel=2)
-        if not hasattr(self, 'find_spec'):
-            return None
-        found = self.find_spec(fullname, path)
-        return found.loader if found is not None else None
-
-    def invalidate_caches(self):
-        """An optional method for clearing the finder's cache, if any.
-        This method is used by importlib.invalidate_caches().
-        """
-
-_register(MetaPathFinder, machinery.BuiltinImporter, machinery.FrozenImporter,
-          machinery.PathFinder, machinery.WindowsRegistryFinder)
-
-
-class PathEntryFinder(Finder):
-
-    """Abstract base class for path entry finders used by PathFinder."""
-
-    # We don't define find_spec() here since that would break
-    # hasattr checks we do to support backward compatibility.
-
-    def find_loader(self, fullname):
-        """Return (loader, namespace portion) for the path entry.
-
-        The fullname is a str.  The namespace portion is a sequence of
-        path entries contributing to part of a namespace package. The
-        sequence may be empty.  If loader is not None, the portion will
-        be ignored.
-
-        The portion will be discarded if another path entry finder
-        locates the module as a normal module or package.
-
-        This method is deprecated since Python 3.4 in favor of
-        finder.find_spec(). If find_spec() is provided than backwards-compatible
-        functionality is provided.
-        """
-        warnings.warn("PathEntryFinder.find_loader() is deprecated since Python "
-                      "3.4 in favor of PathEntryFinder.find_spec() "
-                      "(available since 3.4)",
-                      DeprecationWarning,
-                      stacklevel=2)
-        if not hasattr(self, 'find_spec'):
-            return None, []
-        found = self.find_spec(fullname)
-        if found is not None:
-            if not found.submodule_search_locations:
-                portions = []
-            else:
-                portions = found.submodule_search_locations
-            return found.loader, portions
-        else:
-            return None, []
-
-    find_module = _bootstrap_external._find_module_shim
-
-    def invalidate_caches(self):
-        """An optional method for clearing the finder's cache, if any.
-        This method is used by PathFinder.invalidate_caches().
-        """
-
-_register(PathEntryFinder, machinery.FileFinder)
-
-
-class Loader(metaclass=abc.ABCMeta):
-
-    """Abstract base class for import loaders."""
-
-    def create_module(self, spec):
-        """Return a module to initialize and into which to load.
-
-        This method should raise ImportError if anything prevents it
-        from creating a new module.  It may return None to indicate
-        that the spec should create the new module.
-        """
-        # By default, defer to default semantics for the new module.
-        return None
-
-    # We don't define exec_module() here since that would break
-    # hasattr checks we do to support backward compatibility.
-
-    def load_module(self, fullname):
-        """Return the loaded module.
-
-        The module must be added to sys.modules and have import-related
-        attributes set properly.  The fullname is a str.
-
-        ImportError is raised on failure.
-
-        This method is deprecated in favor of loader.exec_module(). If
-        exec_module() exists then it is used to provide a backwards-compatible
-        functionality for this method.
-
-        """
-        if not hasattr(self, 'exec_module'):
-            raise ImportError
-        return _bootstrap._load_module_shim(self, fullname)
-
-    def module_repr(self, module):
-        """Return a module's repr.
-
-        Used by the module type when the method does not raise
-        NotImplementedError.
-
-        This method is deprecated.
-
-        """
-        # The exception will cause ModuleType.__repr__ to ignore this method.
-        raise NotImplementedError
-
-
-class ResourceLoader(Loader):
-
-    """Abstract base class for loaders which can return data from their
-    back-end storage.
-
-    This ABC represents one of the optional protocols specified by PEP 302.
-
-    """
-
-    @abc.abstractmethod
-    def get_data(self, path):
-        """Abstract method which when implemented should return the bytes for
-        the specified path.  The path must be a str."""
-        raise OSError
-
-
-class InspectLoader(Loader):
-
-    """Abstract base class for loaders which support inspection about the
-    modules they can load.
-
-    This ABC represents one of the optional protocols specified by PEP 302.
-
-    """
-
-    def is_package(self, fullname):
-        """Optional method which when implemented should return whether the
-        module is a package.  The fullname is a str.  Returns a bool.
-
-        Raises ImportError if the module cannot be found.
-        """
-        raise ImportError
-
-    def get_code(self, fullname):
-        """Method which returns the code object for the module.
-
-        The fullname is a str.  Returns a types.CodeType if possible, else
-        returns None if a code object does not make sense
-        (e.g. built-in module). Raises ImportError if the module cannot be
-        found.
-        """
-        source = self.get_source(fullname)
-        if source is None:
-            return None
-        return self.source_to_code(source)
-
-    @abc.abstractmethod
-    def get_source(self, fullname):
-        """Abstract method which should return the source code for the
-        module.  The fullname is a str.  Returns a str.
-
-        Raises ImportError if the module cannot be found.
-        """
-        raise ImportError
-
-    @staticmethod
-    def source_to_code(data, path='<string>'):
-        """Compile 'data' into a code object.
-
-        The 'data' argument can be anything that compile() can handle. The'path'
-        argument should be where the data was retrieved (when applicable)."""
-        return compile(data, path, 'exec', dont_inherit=True)
-
-    exec_module = _bootstrap_external._LoaderBasics.exec_module
-    load_module = _bootstrap_external._LoaderBasics.load_module
-
-_register(InspectLoader, machinery.BuiltinImporter, machinery.FrozenImporter)
-
-
-class ExecutionLoader(InspectLoader):
-
-    """Abstract base class for loaders that wish to support the execution of
-    modules as scripts.
-
-    This ABC represents one of the optional protocols specified in PEP 302.
-
-    """
-
-    @abc.abstractmethod
-    def get_filename(self, fullname):
-        """Abstract method which should return the value that __file__ is to be
-        set to.
-
-        Raises ImportError if the module cannot be found.
-        """
-        raise ImportError
-
-    def get_code(self, fullname):
-        """Method to return the code object for fullname.
-
-        Should return None if not applicable (e.g. built-in module).
-        Raise ImportError if the module cannot be found.
-        """
-        source = self.get_source(fullname)
-        if source is None:
-            return None
-        try:
-            path = self.get_filename(fullname)
-        except ImportError:
-            return self.source_to_code(source)
-        else:
-            return self.source_to_code(source, path)
-
-_register(ExecutionLoader, machinery.ExtensionFileLoader)
-
-
-class FileLoader(_bootstrap_external.FileLoader, ResourceLoader, ExecutionLoader):
-
-    """Abstract base class partially implementing the ResourceLoader and
-    ExecutionLoader ABCs."""
-
-_register(FileLoader, machinery.SourceFileLoader,
-            machinery.SourcelessFileLoader)
-
-
-class SourceLoader(_bootstrap_external.SourceLoader, ResourceLoader, ExecutionLoader):
-
-    """Abstract base class for loading source code (and optionally any
-    corresponding bytecode).
-
-    To support loading from source code, the abstractmethods inherited from
-    ResourceLoader and ExecutionLoader need to be implemented. To also support
-    loading from bytecode, the optional methods specified directly by this ABC
-    is required.
-
-    Inherited abstractmethods not implemented in this ABC:
-
-        * ResourceLoader.get_data
-        * ExecutionLoader.get_filename
-
-    """
-
-    def path_mtime(self, path):
-        """Return the (int) modification time for the path (str)."""
-        if self.path_stats.__func__ is SourceLoader.path_stats:
-            raise OSError
-        return int(self.path_stats(path)['mtime'])
-
-    def path_stats(self, path):
-        """Return a metadata dict for the source pointed to by the path (str).
-        Possible keys:
-        - 'mtime' (mandatory) is the numeric timestamp of last source
-          code modification;
-        - 'size' (optional) is the size in bytes of the source code.
-        """
-        if self.path_mtime.__func__ is SourceLoader.path_mtime:
-            raise OSError
-        return {'mtime': self.path_mtime(path)}
-
-    def set_data(self, path, data):
-        """Write the bytes to the path (if possible).
-
-        Accepts a str path and data as bytes.
-
-        Any needed intermediary directories are to be created. If for some
-        reason the file cannot be written because of permissions, fail
-        silently.
-        """
-
-_register(SourceLoader, machinery.SourceFileLoader)
-
-
-class ResourceReader(metaclass=abc.ABCMeta):
-
-    """Abstract base class to provide resource-reading support.
-
-    Loaders that support resource reading are expected to implement
-    the ``get_resource_reader(fullname)`` method and have it either return None
-    or an object compatible with this ABC.
-    """
-
-    @abc.abstractmethod
-    def open_resource(self, resource):
-        """Return an opened, file-like object for binary reading.
-
-        The 'resource' argument is expected to represent only a file name
-        and thus not contain any subdirectory components.
-
-        If the resource cannot be found, FileNotFoundError is raised.
-        """
-        raise FileNotFoundError
-
-    @abc.abstractmethod
-    def resource_path(self, resource):
-        """Return the file system path to the specified resource.
-
-        The 'resource' argument is expected to represent only a file name
-        and thus not contain any subdirectory components.
-
-        If the resource does not exist on the file system, raise
-        FileNotFoundError.
-        """
-        raise FileNotFoundError
-
-    @abc.abstractmethod
-    def is_resource(self, name):
-        """Return True if the named 'name' is consider a resource."""
-        raise FileNotFoundError
-
-    @abc.abstractmethod
-    def contents(self):
-        """Return an iterable of strings over the contents of the package."""
-        return []
-
-
-_register(ResourceReader, machinery.SourceFileLoader)
+ 
+ 
+def _register(abstract_cls, *classes): 
+    for cls in classes: 
+        abstract_cls.register(cls) 
+        if _frozen_importlib is not None: 
+            try: 
+                frozen_cls = getattr(_frozen_importlib, cls.__name__) 
+            except AttributeError: 
+                frozen_cls = getattr(_frozen_importlib_external, cls.__name__) 
+            abstract_cls.register(frozen_cls) 
+ 
+ 
+class Finder(metaclass=abc.ABCMeta): 
+ 
+    """Legacy abstract base class for import finders. 
+ 
+    It may be subclassed for compatibility with legacy third party 
+    reimplementations of the import system.  Otherwise, finder 
+    implementations should derive from the more specific MetaPathFinder 
+    or PathEntryFinder ABCs. 
+ 
+    Deprecated since Python 3.3 
+    """ 
+ 
+    @abc.abstractmethod 
+    def find_module(self, fullname, path=None): 
+        """An abstract method that should find a module. 
+        The fullname is a str and the optional path is a str or None. 
+        Returns a Loader object or None. 
+        """ 
+ 
+ 
+class MetaPathFinder(Finder): 
+ 
+    """Abstract base class for import finders on sys.meta_path.""" 
+ 
+    # We don't define find_spec() here since that would break 
+    # hasattr checks we do to support backward compatibility. 
+ 
+    def find_module(self, fullname, path): 
+        """Return a loader for the module. 
+ 
+        If no module is found, return None.  The fullname is a str and 
+        the path is a list of strings or None. 
+ 
+        This method is deprecated since Python 3.4 in favor of 
+        finder.find_spec(). If find_spec() exists then backwards-compatible 
+        functionality is provided for this method. 
+ 
+        """ 
+        warnings.warn("MetaPathFinder.find_module() is deprecated since Python " 
+                      "3.4 in favor of MetaPathFinder.find_spec() " 
+                      "(available since 3.4)", 
+                      DeprecationWarning, 
+                      stacklevel=2) 
+        if not hasattr(self, 'find_spec'): 
+            return None 
+        found = self.find_spec(fullname, path) 
+        return found.loader if found is not None else None 
+ 
+    def invalidate_caches(self): 
+        """An optional method for clearing the finder's cache, if any. 
+        This method is used by importlib.invalidate_caches(). 
+        """ 
+ 
+_register(MetaPathFinder, machinery.BuiltinImporter, machinery.FrozenImporter, 
+          machinery.PathFinder, machinery.WindowsRegistryFinder) 
+ 
+ 
+class PathEntryFinder(Finder): 
+ 
+    """Abstract base class for path entry finders used by PathFinder.""" 
+ 
+    # We don't define find_spec() here since that would break 
+    # hasattr checks we do to support backward compatibility. 
+ 
+    def find_loader(self, fullname): 
+        """Return (loader, namespace portion) for the path entry. 
+ 
+        The fullname is a str.  The namespace portion is a sequence of 
+        path entries contributing to part of a namespace package. The 
+        sequence may be empty.  If loader is not None, the portion will 
+        be ignored. 
+ 
+        The portion will be discarded if another path entry finder 
+        locates the module as a normal module or package. 
+ 
+        This method is deprecated since Python 3.4 in favor of 
+        finder.find_spec(). If find_spec() is provided than backwards-compatible 
+        functionality is provided. 
+        """ 
+        warnings.warn("PathEntryFinder.find_loader() is deprecated since Python " 
+                      "3.4 in favor of PathEntryFinder.find_spec() " 
+                      "(available since 3.4)", 
+                      DeprecationWarning, 
+                      stacklevel=2) 
+        if not hasattr(self, 'find_spec'): 
+            return None, [] 
+        found = self.find_spec(fullname) 
+        if found is not None: 
+            if not found.submodule_search_locations: 
+                portions = [] 
+            else: 
+                portions = found.submodule_search_locations 
+            return found.loader, portions 
+        else: 
+            return None, [] 
+ 
+    find_module = _bootstrap_external._find_module_shim 
+ 
+    def invalidate_caches(self): 
+        """An optional method for clearing the finder's cache, if any. 
+        This method is used by PathFinder.invalidate_caches(). 
+        """ 
+ 
+_register(PathEntryFinder, machinery.FileFinder) 
+ 
+ 
+class Loader(metaclass=abc.ABCMeta): 
+ 
+    """Abstract base class for import loaders.""" 
+ 
+    def create_module(self, spec): 
+        """Return a module to initialize and into which to load. 
+ 
+        This method should raise ImportError if anything prevents it 
+        from creating a new module.  It may return None to indicate 
+        that the spec should create the new module. 
+        """ 
+        # By default, defer to default semantics for the new module. 
+        return None 
+ 
+    # We don't define exec_module() here since that would break 
+    # hasattr checks we do to support backward compatibility. 
+ 
+    def load_module(self, fullname): 
+        """Return the loaded module. 
+ 
+        The module must be added to sys.modules and have import-related 
+        attributes set properly.  The fullname is a str. 
+ 
+        ImportError is raised on failure. 
+ 
+        This method is deprecated in favor of loader.exec_module(). If 
+        exec_module() exists then it is used to provide a backwards-compatible 
+        functionality for this method. 
+ 
+        """ 
+        if not hasattr(self, 'exec_module'): 
+            raise ImportError 
+        return _bootstrap._load_module_shim(self, fullname) 
+ 
+    def module_repr(self, module): 
+        """Return a module's repr. 
+ 
+        Used by the module type when the method does not raise 
+        NotImplementedError. 
+ 
+        This method is deprecated. 
+ 
+        """ 
+        # The exception will cause ModuleType.__repr__ to ignore this method. 
+        raise NotImplementedError 
+ 
+ 
+class ResourceLoader(Loader): 
+ 
+    """Abstract base class for loaders which can return data from their 
+    back-end storage. 
+ 
+    This ABC represents one of the optional protocols specified by PEP 302. 
+ 
+    """ 
+ 
+    @abc.abstractmethod 
+    def get_data(self, path): 
+        """Abstract method which when implemented should return the bytes for 
+        the specified path.  The path must be a str.""" 
+        raise OSError 
+ 
+ 
+class InspectLoader(Loader): 
+ 
+    """Abstract base class for loaders which support inspection about the 
+    modules they can load. 
+ 
+    This ABC represents one of the optional protocols specified by PEP 302. 
+ 
+    """ 
+ 
+    def is_package(self, fullname): 
+        """Optional method which when implemented should return whether the 
+        module is a package.  The fullname is a str.  Returns a bool. 
+ 
+        Raises ImportError if the module cannot be found. 
+        """ 
+        raise ImportError 
+ 
+    def get_code(self, fullname): 
+        """Method which returns the code object for the module. 
+ 
+        The fullname is a str.  Returns a types.CodeType if possible, else 
+        returns None if a code object does not make sense 
+        (e.g. built-in module). Raises ImportError if the module cannot be 
+        found. 
+        """ 
+        source = self.get_source(fullname) 
+        if source is None: 
+            return None 
+        return self.source_to_code(source) 
+ 
+    @abc.abstractmethod 
+    def get_source(self, fullname): 
+        """Abstract method which should return the source code for the 
+        module.  The fullname is a str.  Returns a str. 
+ 
+        Raises ImportError if the module cannot be found. 
+        """ 
+        raise ImportError 
+ 
+    @staticmethod 
+    def source_to_code(data, path='<string>'): 
+        """Compile 'data' into a code object. 
+ 
+        The 'data' argument can be anything that compile() can handle. The'path' 
+        argument should be where the data was retrieved (when applicable).""" 
+        return compile(data, path, 'exec', dont_inherit=True) 
+ 
+    exec_module = _bootstrap_external._LoaderBasics.exec_module 
+    load_module = _bootstrap_external._LoaderBasics.load_module 
+ 
+_register(InspectLoader, machinery.BuiltinImporter, machinery.FrozenImporter) 
+ 
+ 
+class ExecutionLoader(InspectLoader): 
+ 
+    """Abstract base class for loaders that wish to support the execution of 
+    modules as scripts. 
+ 
+    This ABC represents one of the optional protocols specified in PEP 302. 
+ 
+    """ 
+ 
+    @abc.abstractmethod 
+    def get_filename(self, fullname): 
+        """Abstract method which should return the value that __file__ is to be 
+        set to. 
+ 
+        Raises ImportError if the module cannot be found. 
+        """ 
+        raise ImportError 
+ 
+    def get_code(self, fullname): 
+        """Method to return the code object for fullname. 
+ 
+        Should return None if not applicable (e.g. built-in module). 
+        Raise ImportError if the module cannot be found. 
+        """ 
+        source = self.get_source(fullname) 
+        if source is None: 
+            return None 
+        try: 
+            path = self.get_filename(fullname) 
+        except ImportError: 
+            return self.source_to_code(source) 
+        else: 
+            return self.source_to_code(source, path) 
+ 
+_register(ExecutionLoader, machinery.ExtensionFileLoader) 
+ 
+ 
+class FileLoader(_bootstrap_external.FileLoader, ResourceLoader, ExecutionLoader): 
+ 
+    """Abstract base class partially implementing the ResourceLoader and 
+    ExecutionLoader ABCs.""" 
+ 
+_register(FileLoader, machinery.SourceFileLoader, 
+            machinery.SourcelessFileLoader) 
+ 
+ 
+class SourceLoader(_bootstrap_external.SourceLoader, ResourceLoader, ExecutionLoader): 
+ 
+    """Abstract base class for loading source code (and optionally any 
+    corresponding bytecode). 
+ 
+    To support loading from source code, the abstractmethods inherited from 
+    ResourceLoader and ExecutionLoader need to be implemented. To also support 
+    loading from bytecode, the optional methods specified directly by this ABC 
+    is required. 
+ 
+    Inherited abstractmethods not implemented in this ABC: 
+ 
+        * ResourceLoader.get_data 
+        * ExecutionLoader.get_filename 
+ 
+    """ 
+ 
+    def path_mtime(self, path): 
+        """Return the (int) modification time for the path (str).""" 
+        if self.path_stats.__func__ is SourceLoader.path_stats: 
+            raise OSError 
+        return int(self.path_stats(path)['mtime']) 
+ 
+    def path_stats(self, path): 
+        """Return a metadata dict for the source pointed to by the path (str). 
+        Possible keys: 
+        - 'mtime' (mandatory) is the numeric timestamp of last source 
+          code modification; 
+        - 'size' (optional) is the size in bytes of the source code. 
+        """ 
+        if self.path_mtime.__func__ is SourceLoader.path_mtime: 
+            raise OSError 
+        return {'mtime': self.path_mtime(path)} 
+ 
+    def set_data(self, path, data): 
+        """Write the bytes to the path (if possible). 
+ 
+        Accepts a str path and data as bytes. 
+ 
+        Any needed intermediary directories are to be created. If for some 
+        reason the file cannot be written because of permissions, fail 
+        silently. 
+        """ 
+ 
+_register(SourceLoader, machinery.SourceFileLoader) 
+ 
+ 
+class ResourceReader(metaclass=abc.ABCMeta): 
+ 
+    """Abstract base class to provide resource-reading support. 
+ 
+    Loaders that support resource reading are expected to implement 
+    the ``get_resource_reader(fullname)`` method and have it either return None 
+    or an object compatible with this ABC. 
+    """ 
+ 
+    @abc.abstractmethod 
+    def open_resource(self, resource): 
+        """Return an opened, file-like object for binary reading. 
+ 
+        The 'resource' argument is expected to represent only a file name 
+        and thus not contain any subdirectory components. 
+ 
+        If the resource cannot be found, FileNotFoundError is raised. 
+        """ 
+        raise FileNotFoundError 
+ 
+    @abc.abstractmethod 
+    def resource_path(self, resource): 
+        """Return the file system path to the specified resource. 
+ 
+        The 'resource' argument is expected to represent only a file name 
+        and thus not contain any subdirectory components. 
+ 
+        If the resource does not exist on the file system, raise 
+        FileNotFoundError. 
+        """ 
+        raise FileNotFoundError 
+ 
+    @abc.abstractmethod 
+    def is_resource(self, name): 
+        """Return True if the named 'name' is consider a resource.""" 
+        raise FileNotFoundError 
+ 
+    @abc.abstractmethod 
+    def contents(self): 
+        """Return an iterable of strings over the contents of the package.""" 
+        return [] 
+ 
+ 
+_register(ResourceReader, machinery.SourceFileLoader) 
 
 
 @runtime_checkable