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

1 files changed, 169 insertions, 169 deletions

diff --git a/contrib/tools/python3/src/Lib/glob.py b/contrib/tools/python3/src/Lib/glob.py
index 1237061130..fd3e1a2fdf 100644
--- a/contrib/tools/python3/src/Lib/glob.py
+++ b/contrib/tools/python3/src/Lib/glob.py
@@ -1,178 +1,178 @@
-"""Filename globbing utility."""
-
+"""Filename globbing utility.""" 
+ 
 import contextlib
-import os
-import re
-import fnmatch
+import os 
+import re 
+import fnmatch 
 import sys
-
-__all__ = ["glob", "iglob", "escape"]
-
-def glob(pathname, *, recursive=False):
-    """Return a list of paths matching a pathname pattern.
-
-    The pattern may contain simple shell-style wildcards a la
-    fnmatch. However, unlike fnmatch, filenames starting with a
-    dot are special cases that are not matched by '*' and '?'
-    patterns.
-
-    If recursive is true, the pattern '**' will match any files and
-    zero or more directories and subdirectories.
-    """
-    return list(iglob(pathname, recursive=recursive))
-
-def iglob(pathname, *, recursive=False):
-    """Return an iterator which yields the paths matching a pathname pattern.
-
-    The pattern may contain simple shell-style wildcards a la
-    fnmatch. However, unlike fnmatch, filenames starting with a
-    dot are special cases that are not matched by '*' and '?'
-    patterns.
-
-    If recursive is true, the pattern '**' will match any files and
-    zero or more directories and subdirectories.
-    """
+ 
+__all__ = ["glob", "iglob", "escape"] 
+ 
+def glob(pathname, *, recursive=False): 
+    """Return a list of paths matching a pathname pattern. 
+ 
+    The pattern may contain simple shell-style wildcards a la 
+    fnmatch. However, unlike fnmatch, filenames starting with a 
+    dot are special cases that are not matched by '*' and '?' 
+    patterns. 
+ 
+    If recursive is true, the pattern '**' will match any files and 
+    zero or more directories and subdirectories. 
+    """ 
+    return list(iglob(pathname, recursive=recursive)) 
+ 
+def iglob(pathname, *, recursive=False): 
+    """Return an iterator which yields the paths matching a pathname pattern. 
+ 
+    The pattern may contain simple shell-style wildcards a la 
+    fnmatch. However, unlike fnmatch, filenames starting with a 
+    dot are special cases that are not matched by '*' and '?' 
+    patterns. 
+ 
+    If recursive is true, the pattern '**' will match any files and 
+    zero or more directories and subdirectories. 
+    """ 
     sys.audit("glob.glob", pathname, recursive)
-    it = _iglob(pathname, recursive, False)
-    if recursive and _isrecursive(pathname):
-        s = next(it)  # skip empty string
-        assert not s
-    return it
-
-def _iglob(pathname, recursive, dironly):
-    dirname, basename = os.path.split(pathname)
-    if not has_magic(pathname):
-        assert not dironly
-        if basename:
-            if os.path.lexists(pathname):
-                yield pathname
-        else:
-            # Patterns ending with a slash should match only directories
-            if os.path.isdir(dirname):
-                yield pathname
-        return
-    if not dirname:
-        if recursive and _isrecursive(basename):
-            yield from _glob2(dirname, basename, dironly)
-        else:
-            yield from _glob1(dirname, basename, dironly)
-        return
-    # `os.path.split()` returns the argument itself as a dirname if it is a
-    # drive or UNC path.  Prevent an infinite recursion if a drive or UNC path
-    # contains magic characters (i.e. r'\\?\C:').
-    if dirname != pathname and has_magic(dirname):
-        dirs = _iglob(dirname, recursive, True)
-    else:
-        dirs = [dirname]
-    if has_magic(basename):
-        if recursive and _isrecursive(basename):
-            glob_in_dir = _glob2
-        else:
-            glob_in_dir = _glob1
-    else:
-        glob_in_dir = _glob0
-    for dirname in dirs:
-        for name in glob_in_dir(dirname, basename, dironly):
-            yield os.path.join(dirname, name)
-
-# These 2 helper functions non-recursively glob inside a literal directory.
-# They return a list of basenames.  _glob1 accepts a pattern while _glob0
-# takes a literal basename (so it only has to check for its existence).
-
-def _glob1(dirname, pattern, dironly):
+    it = _iglob(pathname, recursive, False) 
+    if recursive and _isrecursive(pathname): 
+        s = next(it)  # skip empty string 
+        assert not s 
+    return it 
+ 
+def _iglob(pathname, recursive, dironly): 
+    dirname, basename = os.path.split(pathname) 
+    if not has_magic(pathname): 
+        assert not dironly 
+        if basename: 
+            if os.path.lexists(pathname): 
+                yield pathname 
+        else: 
+            # Patterns ending with a slash should match only directories 
+            if os.path.isdir(dirname): 
+                yield pathname 
+        return 
+    if not dirname: 
+        if recursive and _isrecursive(basename): 
+            yield from _glob2(dirname, basename, dironly) 
+        else: 
+            yield from _glob1(dirname, basename, dironly) 
+        return 
+    # `os.path.split()` returns the argument itself as a dirname if it is a 
+    # drive or UNC path.  Prevent an infinite recursion if a drive or UNC path 
+    # contains magic characters (i.e. r'\\?\C:'). 
+    if dirname != pathname and has_magic(dirname): 
+        dirs = _iglob(dirname, recursive, True) 
+    else: 
+        dirs = [dirname] 
+    if has_magic(basename): 
+        if recursive and _isrecursive(basename): 
+            glob_in_dir = _glob2 
+        else: 
+            glob_in_dir = _glob1 
+    else: 
+        glob_in_dir = _glob0 
+    for dirname in dirs: 
+        for name in glob_in_dir(dirname, basename, dironly): 
+            yield os.path.join(dirname, name) 
+ 
+# These 2 helper functions non-recursively glob inside a literal directory. 
+# They return a list of basenames.  _glob1 accepts a pattern while _glob0 
+# takes a literal basename (so it only has to check for its existence). 
+ 
+def _glob1(dirname, pattern, dironly): 
     names = _listdir(dirname, dironly)
-    if not _ishidden(pattern):
-        names = (x for x in names if not _ishidden(x))
-    return fnmatch.filter(names, pattern)
-
-def _glob0(dirname, basename, dironly):
-    if not basename:
-        # `os.path.split()` returns an empty basename for paths ending with a
-        # directory separator.  'q*x/' should match only directories.
-        if os.path.isdir(dirname):
-            return [basename]
-    else:
-        if os.path.lexists(os.path.join(dirname, basename)):
-            return [basename]
-    return []
-
-# Following functions are not public but can be used by third-party code.
-
-def glob0(dirname, pattern):
-    return _glob0(dirname, pattern, False)
-
-def glob1(dirname, pattern):
-    return _glob1(dirname, pattern, False)
-
-# This helper function recursively yields relative pathnames inside a literal
-# directory.
-
-def _glob2(dirname, pattern, dironly):
-    assert _isrecursive(pattern)
-    yield pattern[:0]
-    yield from _rlistdir(dirname, dironly)
-
-# If dironly is false, yields all file names inside a directory.
-# If dironly is true, yields only directory names.
-def _iterdir(dirname, dironly):
-    if not dirname:
-        if isinstance(dirname, bytes):
-            dirname = bytes(os.curdir, 'ASCII')
-        else:
-            dirname = os.curdir
-    try:
-        with os.scandir(dirname) as it:
-            for entry in it:
-                try:
-                    if not dironly or entry.is_dir():
-                        yield entry.name
-                except OSError:
-                    pass
-    except OSError:
-        return
-
+    if not _ishidden(pattern): 
+        names = (x for x in names if not _ishidden(x)) 
+    return fnmatch.filter(names, pattern) 
+ 
+def _glob0(dirname, basename, dironly): 
+    if not basename: 
+        # `os.path.split()` returns an empty basename for paths ending with a 
+        # directory separator.  'q*x/' should match only directories. 
+        if os.path.isdir(dirname): 
+            return [basename] 
+    else: 
+        if os.path.lexists(os.path.join(dirname, basename)): 
+            return [basename] 
+    return [] 
+ 
+# Following functions are not public but can be used by third-party code. 
+ 
+def glob0(dirname, pattern): 
+    return _glob0(dirname, pattern, False) 
+ 
+def glob1(dirname, pattern): 
+    return _glob1(dirname, pattern, False) 
+ 
+# This helper function recursively yields relative pathnames inside a literal 
+# directory. 
+ 
+def _glob2(dirname, pattern, dironly): 
+    assert _isrecursive(pattern) 
+    yield pattern[:0] 
+    yield from _rlistdir(dirname, dironly) 
+ 
+# If dironly is false, yields all file names inside a directory. 
+# If dironly is true, yields only directory names. 
+def _iterdir(dirname, dironly): 
+    if not dirname: 
+        if isinstance(dirname, bytes): 
+            dirname = bytes(os.curdir, 'ASCII') 
+        else: 
+            dirname = os.curdir 
+    try: 
+        with os.scandir(dirname) as it: 
+            for entry in it: 
+                try: 
+                    if not dironly or entry.is_dir(): 
+                        yield entry.name 
+                except OSError: 
+                    pass 
+    except OSError: 
+        return 
+ 
 def _listdir(dirname, dironly):
     with contextlib.closing(_iterdir(dirname, dironly)) as it:
         return list(it)
 
-# Recursively yields relative pathnames inside a literal directory.
-def _rlistdir(dirname, dironly):
+# Recursively yields relative pathnames inside a literal directory. 
+def _rlistdir(dirname, dironly): 
     names = _listdir(dirname, dironly)
-    for x in names:
-        if not _ishidden(x):
-            yield x
-            path = os.path.join(dirname, x) if dirname else x
-            for y in _rlistdir(path, dironly):
-                yield os.path.join(x, y)
-
-
-magic_check = re.compile('([*?[])')
-magic_check_bytes = re.compile(b'([*?[])')
-
-def has_magic(s):
-    if isinstance(s, bytes):
-        match = magic_check_bytes.search(s)
-    else:
-        match = magic_check.search(s)
-    return match is not None
-
-def _ishidden(path):
-    return path[0] in ('.', b'.'[0])
-
-def _isrecursive(pattern):
-    if isinstance(pattern, bytes):
-        return pattern == b'**'
-    else:
-        return pattern == '**'
-
-def escape(pathname):
-    """Escape all special characters.
-    """
-    # Escaping is done by wrapping any of "*?[" between square brackets.
-    # Metacharacters do not work in the drive part and shouldn't be escaped.
-    drive, pathname = os.path.splitdrive(pathname)
-    if isinstance(pathname, bytes):
-        pathname = magic_check_bytes.sub(br'[\1]', pathname)
-    else:
-        pathname = magic_check.sub(r'[\1]', pathname)
-    return drive + pathname
+    for x in names: 
+        if not _ishidden(x): 
+            yield x 
+            path = os.path.join(dirname, x) if dirname else x 
+            for y in _rlistdir(path, dironly): 
+                yield os.path.join(x, y) 
+ 
+ 
+magic_check = re.compile('([*?[])') 
+magic_check_bytes = re.compile(b'([*?[])') 
+ 
+def has_magic(s): 
+    if isinstance(s, bytes): 
+        match = magic_check_bytes.search(s) 
+    else: 
+        match = magic_check.search(s) 
+    return match is not None 
+ 
+def _ishidden(path): 
+    return path[0] in ('.', b'.'[0]) 
+ 
+def _isrecursive(pattern): 
+    if isinstance(pattern, bytes): 
+        return pattern == b'**' 
+    else: 
+        return pattern == '**' 
+ 
+def escape(pathname): 
+    """Escape all special characters. 
+    """ 
+    # Escaping is done by wrapping any of "*?[" between square brackets. 
+    # Metacharacters do not work in the drive part and shouldn't be escaped. 
+    drive, pathname = os.path.splitdrive(pathname) 
+    if isinstance(pathname, bytes): 
+        pathname = magic_check_bytes.sub(br'[\1]', pathname) 
+    else: 
+        pathname = magic_check.sub(r'[\1]', pathname) 
+    return drive + pathname