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

6 files changed, 244 insertions, 244 deletions

diff --git a/library/python/filelock/__init__.py b/library/python/filelock/__init__.py
index 1d0fe9b535..f81ff67f37 100644
--- a/library/python/filelock/__init__.py
+++ b/library/python/filelock/__init__.py
@@ -41,7 +41,7 @@ class _NixFileLock(AbstractFileLock):
         super(_NixFileLock, self).__init__(path)
         from fcntl import flock, LOCK_EX, LOCK_UN, LOCK_NB
         self._locker = lambda lock, blocking: flock(lock, LOCK_EX if blocking else LOCK_EX | LOCK_NB)
-        self._unlocker = lambda lock: flock(lock, LOCK_UN) 
+        self._unlocker = lambda lock: flock(lock, LOCK_UN)
         self._lock = open(self.path, 'a')
         set_close_on_exec(self._lock)
 
diff --git a/library/python/fs/__init__.py b/library/python/fs/__init__.py
index f5d2a2b2ce..b1b7cde079 100644
--- a/library/python/fs/__init__.py
+++ b/library/python/fs/__init__.py
@@ -1,21 +1,21 @@
 # coding: utf-8
 
 import codecs
-import errno 
-import logging 
-import os 
+import errno
+import logging
+import os
 import random
-import shutil 
+import shutil
 import six
 import stat
 import sys
- 
+
 import library.python.func
 import library.python.strings
 import library.python.windows
- 
+
 logger = logging.getLogger(__name__)
- 
+
 
 try:
     WindowsError
@@ -40,12 +40,12 @@ class CustomFsError(OSError):
 # Throws OSError
 @errorfix_win
 def ensure_dir(path):
-    try: 
-        os.makedirs(path) 
-    except OSError as e: 
+    try:
+        os.makedirs(path)
+    except OSError as e:
         if e.errno != errno.EEXIST or not os.path.isdir(path):
-            raise 
- 
+            raise
+
 
 # Directories creation
 # If dst is already exists and is a directory - does nothing
@@ -54,9 +54,9 @@ def ensure_dir(path):
 @errorfix_win
 def create_dirs(path):
     ensure_dir(path)
-    return path 
- 
- 
+    return path
+
+
 # Atomic file/directory move (rename)
 # Doesn't guarantee dst replacement
 # Atomic if no device boundaries are crossed
@@ -72,8 +72,8 @@ def create_dirs(path):
 @library.python.windows.diehard(library.python.windows.RETRIABLE_FILE_ERRORS, tries=_diehard_win_tries)
 def move(src, dst):
     os.rename(src, dst)
- 
- 
+
+
 # Atomic replacing file move (rename)
 # Replaces dst if exists and not a dir
 # Doesn't guarantee dst dir replacement
@@ -372,94 +372,94 @@ def copytree3(
     ignore_dangling_symlinks=False,
     dirs_exist_ok=False,
 ):
-    """Recursively copy a directory tree. 
- 
-    The copytree3 is a port of shutil.copytree function from python-3.2. 
-    It has additional useful parameters and may be helpful while we are 
-    on python-2.x. It has to be removed as soon as we have moved to 
-    python-3.2 or higher. 
- 
-    The destination directory must not already exist. 
-    If exception(s) occur, an Error is raised with a list of reasons. 
- 
-    If the optional symlinks flag is true, symbolic links in the 
-    source tree result in symbolic links in the destination tree; if 
-    it is false, the contents of the files pointed to by symbolic 
-    links are copied. If the file pointed by the symlink doesn't 
-    exist, an exception will be added in the list of errors raised in 
-    an Error exception at the end of the copy process. 
- 
-    You can set the optional ignore_dangling_symlinks flag to true if you 
-    want to silence this exception. Notice that this has no effect on 
-    platforms that don't support os.symlink. 
- 
-    The optional ignore argument is a callable. If given, it 
-    is called with the `src` parameter, which is the directory 
-    being visited by copytree3(), and `names` which is the list of 
-    `src` contents, as returned by os.listdir(): 
- 
-        callable(src, names) -> ignored_names 
- 
-    Since copytree3() is called recursively, the callable will be 
-    called once for each directory that is copied. It returns a 
-    list of names relative to the `src` directory that should 
-    not be copied. 
- 
-    The optional copy_function argument is a callable that will be used 
-    to copy each file. It will be called with the source path and the 
-    destination path as arguments. By default, copy2() is used, but any 
-    function that supports the same signature (like copy()) can be used. 
- 
-    """ 
-    names = os.listdir(src) 
-    if ignore is not None: 
-        ignored_names = ignore(src, names) 
-    else: 
-        ignored_names = set() 
- 
+    """Recursively copy a directory tree.
+
+    The copytree3 is a port of shutil.copytree function from python-3.2.
+    It has additional useful parameters and may be helpful while we are
+    on python-2.x. It has to be removed as soon as we have moved to
+    python-3.2 or higher.
+
+    The destination directory must not already exist.
+    If exception(s) occur, an Error is raised with a list of reasons.
+
+    If the optional symlinks flag is true, symbolic links in the
+    source tree result in symbolic links in the destination tree; if
+    it is false, the contents of the files pointed to by symbolic
+    links are copied. If the file pointed by the symlink doesn't
+    exist, an exception will be added in the list of errors raised in
+    an Error exception at the end of the copy process.
+
+    You can set the optional ignore_dangling_symlinks flag to true if you
+    want to silence this exception. Notice that this has no effect on
+    platforms that don't support os.symlink.
+
+    The optional ignore argument is a callable. If given, it
+    is called with the `src` parameter, which is the directory
+    being visited by copytree3(), and `names` which is the list of
+    `src` contents, as returned by os.listdir():
+
+        callable(src, names) -> ignored_names
+
+    Since copytree3() is called recursively, the callable will be
+    called once for each directory that is copied. It returns a
+    list of names relative to the `src` directory that should
+    not be copied.
+
+    The optional copy_function argument is a callable that will be used
+    to copy each file. It will be called with the source path and the
+    destination path as arguments. By default, copy2() is used, but any
+    function that supports the same signature (like copy()) can be used.
+
+    """
+    names = os.listdir(src)
+    if ignore is not None:
+        ignored_names = ignore(src, names)
+    else:
+        ignored_names = set()
+
     if not (dirs_exist_ok and os.path.isdir(dst)):
         os.makedirs(dst)
 
-    errors = [] 
-    for name in names: 
-        if name in ignored_names: 
-            continue 
-        srcname = os.path.join(src, name) 
-        dstname = os.path.join(dst, name) 
-        try: 
-            if os.path.islink(srcname): 
-                linkto = os.readlink(srcname) 
-                if symlinks: 
-                    # We can't just leave it to `copy_function` because legacy 
-                    # code with a custom `copy_function` may rely on copytree3 
-                    # doing the right thing. 
-                    os.symlink(linkto, dstname) 
-                else: 
-                    # ignore dangling symlink if the flag is on 
-                    if not os.path.exists(linkto) and ignore_dangling_symlinks: 
-                        continue 
-                    # otherwise let the copy occurs. copy2 will raise an error 
-                    copy_function(srcname, dstname) 
-            elif os.path.isdir(srcname): 
+    errors = []
+    for name in names:
+        if name in ignored_names:
+            continue
+        srcname = os.path.join(src, name)
+        dstname = os.path.join(dst, name)
+        try:
+            if os.path.islink(srcname):
+                linkto = os.readlink(srcname)
+                if symlinks:
+                    # We can't just leave it to `copy_function` because legacy
+                    # code with a custom `copy_function` may rely on copytree3
+                    # doing the right thing.
+                    os.symlink(linkto, dstname)
+                else:
+                    # ignore dangling symlink if the flag is on
+                    if not os.path.exists(linkto) and ignore_dangling_symlinks:
+                        continue
+                    # otherwise let the copy occurs. copy2 will raise an error
+                    copy_function(srcname, dstname)
+            elif os.path.isdir(srcname):
                 copytree3(srcname, dstname, symlinks, ignore, copy_function, dirs_exist_ok=dirs_exist_ok)
-            else: 
-                # Will raise a SpecialFileError for unsupported file types 
-                copy_function(srcname, dstname) 
-        # catch the Error from the recursive copytree3 so that we can 
-        # continue with other files 
+            else:
+                # Will raise a SpecialFileError for unsupported file types
+                copy_function(srcname, dstname)
+        # catch the Error from the recursive copytree3 so that we can
+        # continue with other files
         except shutil.Error as err:
-            errors.extend(err.args[0]) 
+            errors.extend(err.args[0])
         except EnvironmentError as why:
-            errors.append((srcname, dstname, str(why))) 
-    try: 
-        shutil.copystat(src, dst) 
+            errors.append((srcname, dstname, str(why)))
+    try:
+        shutil.copystat(src, dst)
     except OSError as why:
-        if WindowsError is not None and isinstance(why, WindowsError): 
-            # Copying file access times may fail on Windows 
-            pass 
-        else: 
-            errors.extend((src, dst, str(why))) 
-    if errors: 
+        if WindowsError is not None and isinstance(why, WindowsError):
+            # Copying file access times may fail on Windows
+            pass
+        else:
+            errors.extend((src, dst, str(why)))
+    if errors:
         raise shutil.Error(errors)
 
 
diff --git a/library/python/func/__init__.py b/library/python/func/__init__.py
index 5e20802bc7..7424361635 100644
--- a/library/python/func/__init__.py
+++ b/library/python/func/__init__.py
@@ -1,49 +1,49 @@
-import functools 
+import functools
 import threading
 import collections
- 
- 
-def map0(func, value): 
-    return func(value) if value is not None else value 
- 
- 
-def single(x): 
-    if len(x) != 1: 
-        raise Exception('Length of {} is not equal to 1'.format(x)) 
-    return x[0] 
- 
- 
-class _Result(object): 
-    pass 
- 
- 
-def lazy(func): 
-    result = _Result() 
- 
+
+
+def map0(func, value):
+    return func(value) if value is not None else value
+
+
+def single(x):
+    if len(x) != 1:
+        raise Exception('Length of {} is not equal to 1'.format(x))
+    return x[0]
+
+
+class _Result(object):
+    pass
+
+
+def lazy(func):
+    result = _Result()
+
     @functools.wraps(func)
     def wrapper(*args):
-        try: 
-            return result.result 
-        except AttributeError: 
+        try:
+            return result.result
+        except AttributeError:
             result.result = func(*args)
- 
-        return result.result 
- 
-    return wrapper 
- 
- 
-def lazy_property(fn): 
-    attr_name = '_lazy_' + fn.__name__ 
- 
-    @property 
-    def _lazy_property(self): 
-        if not hasattr(self, attr_name): 
-            setattr(self, attr_name, fn(self)) 
-        return getattr(self, attr_name) 
- 
-    return _lazy_property 
- 
- 
+
+        return result.result
+
+    return wrapper
+
+
+def lazy_property(fn):
+    attr_name = '_lazy_' + fn.__name__
+
+    @property
+    def _lazy_property(self):
+        if not hasattr(self, attr_name):
+            setattr(self, attr_name, fn(self))
+        return getattr(self, attr_name)
+
+    return _lazy_property
+
+
 class classproperty(object):
     def __init__(self, func):
         self.func = func
@@ -67,7 +67,7 @@ class lazy_classproperty(object):
 def memoize(limit=0, thread_local=False):
     assert limit >= 0
 
-    def decorator(func): 
+    def decorator(func):
         memory = {}
         lock = threading.Lock()
 
@@ -86,7 +86,7 @@ def memoize(limit=0, thread_local=False):
                             if len(keys) > limit:
                                 del memory[keys.popleft()]
                         return memory[args]
- 
+
         else:
 
             def get(args):
@@ -112,15 +112,15 @@ def memoize(limit=0, thread_local=False):
 
         return wrapper
 
-    return decorator 
- 
- 
-# XXX: add test 
-def compose(*functions): 
-    def compose2(f, g): 
-        return lambda x: f(g(x)) 
+    return decorator
+
+
+# XXX: add test
+def compose(*functions):
+    def compose2(f, g):
+        return lambda x: f(g(x))
 
-    return functools.reduce(compose2, functions, lambda x: x) 
+    return functools.reduce(compose2, functions, lambda x: x)
 
 
 class Singleton(type):
diff --git a/library/python/func/ut/test_func.py b/library/python/func/ut/test_func.py
index f3605bafcf..3c4fad1a07 100644
--- a/library/python/func/ut/test_func.py
+++ b/library/python/func/ut/test_func.py
@@ -1,87 +1,87 @@
-import pytest 
+import pytest
 import threading
- 
+
 import library.python.func as func
- 
- 
-def test_map0(): 
+
+
+def test_map0():
     assert None is func.map0(lambda x: x + 1, None)
-    assert 3 == func.map0(lambda x: x + 1, 2) 
+    assert 3 == func.map0(lambda x: x + 1, 2)
     assert None is func.map0(len, None)
-    assert 2 == func.map0(len, [1, 2]) 
- 
- 
-def test_single(): 
-    assert 1 == func.single([1]) 
-    with pytest.raises(Exception): 
-        assert 1 == func.single([]) 
-    with pytest.raises(Exception): 
-        assert 1 == func.single([1, 2]) 
- 
- 
-def test_memoize(): 
-    class Counter(object): 
-        @staticmethod 
-        def inc(): 
-            Counter._qty = getattr(Counter, '_qty', 0) + 1 
-            return Counter._qty 
- 
+    assert 2 == func.map0(len, [1, 2])
+
+
+def test_single():
+    assert 1 == func.single([1])
+    with pytest.raises(Exception):
+        assert 1 == func.single([])
+    with pytest.raises(Exception):
+        assert 1 == func.single([1, 2])
+
+
+def test_memoize():
+    class Counter(object):
+        @staticmethod
+        def inc():
+            Counter._qty = getattr(Counter, '_qty', 0) + 1
+            return Counter._qty
+
     @func.memoize()
-    def t1(a): 
-        return a, Counter.inc() 
- 
+    def t1(a):
+        return a, Counter.inc()
+
     @func.memoize()
-    def t2(a): 
-        return a, Counter.inc() 
- 
+    def t2(a):
+        return a, Counter.inc()
+
     @func.memoize()
-    def t3(a): 
-        return a, Counter.inc() 
- 
+    def t3(a):
+        return a, Counter.inc()
+
     @func.memoize()
-    def t4(a): 
-        return a, Counter.inc() 
- 
+    def t4(a):
+        return a, Counter.inc()
+
     @func.memoize()
-    def t5(a, b, c): 
-        return a + b + c, Counter.inc() 
- 
+    def t5(a, b, c):
+        return a + b + c, Counter.inc()
+
     @func.memoize()
-    def t6(): 
-        return Counter.inc() 
- 
+    def t6():
+        return Counter.inc()
+
     @func.memoize(limit=2)
     def t7(a, _b):
         return a, Counter.inc()
 
-    assert (1, 1) == t1(1) 
-    assert (1, 1) == t1(1) 
-    assert (2, 2) == t1(2) 
-    assert (2, 2) == t1(2) 
- 
-    assert (1, 3) == t2(1) 
-    assert (1, 3) == t2(1) 
-    assert (2, 4) == t2(2) 
-    assert (2, 4) == t2(2) 
- 
-    assert (1, 5) == t3(1) 
-    assert (1, 5) == t3(1) 
-    assert (2, 6) == t3(2) 
-    assert (2, 6) == t3(2) 
- 
-    assert (1, 7) == t4(1) 
-    assert (1, 7) == t4(1) 
-    assert (2, 8) == t4(2) 
-    assert (2, 8) == t4(2) 
- 
-    assert (6, 9) == t5(1, 2, 3) 
-    assert (6, 9) == t5(1, 2, 3) 
-    assert (7, 10) == t5(1, 2, 4) 
-    assert (7, 10) == t5(1, 2, 4) 
- 
-    assert 11 == t6() 
-    assert 11 == t6() 
- 
+    assert (1, 1) == t1(1)
+    assert (1, 1) == t1(1)
+    assert (2, 2) == t1(2)
+    assert (2, 2) == t1(2)
+
+    assert (1, 3) == t2(1)
+    assert (1, 3) == t2(1)
+    assert (2, 4) == t2(2)
+    assert (2, 4) == t2(2)
+
+    assert (1, 5) == t3(1)
+    assert (1, 5) == t3(1)
+    assert (2, 6) == t3(2)
+    assert (2, 6) == t3(2)
+
+    assert (1, 7) == t4(1)
+    assert (1, 7) == t4(1)
+    assert (2, 8) == t4(2)
+    assert (2, 8) == t4(2)
+
+    assert (6, 9) == t5(1, 2, 3)
+    assert (6, 9) == t5(1, 2, 3)
+    assert (7, 10) == t5(1, 2, 4)
+    assert (7, 10) == t5(1, 2, 4)
+
+    assert 11 == t6()
+    assert 11 == t6()
+
     assert (1, 12) == t7(1, None)
     assert (2, 13) == t7(2, None)
     assert (1, 12) == t7(1, None)
@@ -158,5 +158,5 @@ def test_memoize_thread_local():
     th.join()
 
 
-if __name__ == '__main__': 
-    pytest.main([__file__]) 
+if __name__ == '__main__':
+    pytest.main([__file__])
diff --git a/library/python/pytest/yatest_tools.py b/library/python/pytest/yatest_tools.py
index 72175cdffa..6b8b896394 100644
--- a/library/python/pytest/yatest_tools.py
+++ b/library/python/pytest/yatest_tools.py
@@ -127,27 +127,27 @@ class Test(object):
         return [x.status for x in self.subtests].count(status)
 
 
-class NoMd5FileException(Exception): 
-    pass 
- 
- 
-TEST_SUBTEST_SEPARATOR = '::' 
- 
- 
-# TODO: extract color theme logic from ya 
-COLOR_THEME = { 
-    'test_name': 'light-blue', 
-    'test_project_path': 'dark-blue', 
-    'test_dir_desc': 'dark-magenta', 
-    'test_binary_path': 'light-gray', 
-} 
- 
- 
-# XXX: remove me 
-class YaCtx(object): 
-    pass 
- 
-ya_ctx = YaCtx() 
+class NoMd5FileException(Exception):
+    pass
+
+
+TEST_SUBTEST_SEPARATOR = '::'
+
+
+# TODO: extract color theme logic from ya
+COLOR_THEME = {
+    'test_name': 'light-blue',
+    'test_project_path': 'dark-blue',
+    'test_dir_desc': 'dark-magenta',
+    'test_binary_path': 'light-gray',
+}
+
+
+# XXX: remove me
+class YaCtx(object):
+    pass
+
+ya_ctx = YaCtx()
 
 TRACE_FILE_NAME = "ytest.report.trace"
 
diff --git a/library/python/ya.make b/library/python/ya.make
index f534798383..2e1eb6e0e1 100644
--- a/library/python/ya.make
+++ b/library/python/ya.make
@@ -138,7 +138,7 @@ RECURSE(
     path
     path/tests
     protobuf
-    pymain 
+    pymain
     pyscopg2
     pytest
     pytest-mongodb