Restoring authorship annotation for Dmitry Kopylov <kopylovd@gmail.com>. Commit 1 of 2.

1 files changed, 431 insertions, 431 deletions

diff --git a/library/python/pytest/plugins/ya.py b/library/python/pytest/plugins/ya.py
index 1bde03042d..c6b06478d9 100644
--- a/library/python/pytest/plugins/ya.py
+++ b/library/python/pytest/plugins/ya.py
@@ -3,101 +3,101 @@
 import base64
 import errno
 import re
-import sys
-import os
-import logging
-import fnmatch
-import json
-import time
+import sys 
+import os 
+import logging 
+import fnmatch 
+import json 
+import time 
 import traceback
-import collections
+import collections 
 import signal
 import inspect
 import warnings
 
 import attr
 import faulthandler
-import py
-import pytest
+import py 
+import pytest 
 import six
 
-import _pytest
+import _pytest 
 import _pytest._io
 import _pytest.mark
 import _pytest.outcomes
 import _pytest.skipping
-
+ 
 from _pytest.warning_types import PytestUnhandledCoroutineWarning
 
 from yatest_lib import test_splitter
 
-try:
-    import resource
-except ImportError:
-    resource = None
-
-try:
-    import library.python.pytest.yatest_tools as tools
-except ImportError:
-    # fallback for pytest script mode
-    import yatest_tools as tools
-
+try: 
+    import resource 
+except ImportError: 
+    resource = None 
+ 
+try: 
+    import library.python.pytest.yatest_tools as tools 
+except ImportError: 
+    # fallback for pytest script mode 
+    import yatest_tools as tools 
+ 
 try:
     from library.python import filelock
 except ImportError:
     filelock = None
 
 
-import yatest_lib.tools
-
-import yatest_lib.external as canon
-
+import yatest_lib.tools 
+ 
+import yatest_lib.external as canon 
+ 
 import yatest_lib.ya
 
 from library.python.pytest import context
 
-console_logger = logging.getLogger("console")
-yatest_logger = logging.getLogger("ya.test")
-
-
-_pytest.main.EXIT_NOTESTSCOLLECTED = 0
+console_logger = logging.getLogger("console") 
+yatest_logger = logging.getLogger("ya.test") 
+ 
+ 
+_pytest.main.EXIT_NOTESTSCOLLECTED = 0 
 SHUTDOWN_REQUESTED = False
-
+ 
 pytest_config = None
+ 
 
-
-def configure_pdb_on_demand():
-    import signal
-
-    if hasattr(signal, "SIGUSR1"):
-        def on_signal(*args):
+def configure_pdb_on_demand(): 
+    import signal 
+ 
+    if hasattr(signal, "SIGUSR1"): 
+        def on_signal(*args): 
             import ipdb
             ipdb.set_trace()
-
-        signal.signal(signal.SIGUSR1, on_signal)
-
-
-class CustomImporter(object):
-    def __init__(self, roots):
-        self._roots = roots
-
-    def find_module(self, fullname, package_path=None):
-        for path in self._roots:
-            full_path = self._get_module_path(path, fullname)
-
-            if os.path.exists(full_path) and os.path.isdir(full_path) and not os.path.exists(os.path.join(full_path, "__init__.py")):
-                open(os.path.join(full_path, "__init__.py"), "w").close()
-
-        return None
-
-    def _get_module_path(self, path, fullname):
-        return os.path.join(path, *fullname.split('.'))
-
-
-class YaTestLoggingFileHandler(logging.FileHandler):
-    pass
-
-
+ 
+        signal.signal(signal.SIGUSR1, on_signal) 
+ 
+ 
+class CustomImporter(object): 
+    def __init__(self, roots): 
+        self._roots = roots 
+ 
+    def find_module(self, fullname, package_path=None): 
+        for path in self._roots: 
+            full_path = self._get_module_path(path, fullname) 
+ 
+            if os.path.exists(full_path) and os.path.isdir(full_path) and not os.path.exists(os.path.join(full_path, "__init__.py")): 
+                open(os.path.join(full_path, "__init__.py"), "w").close() 
+ 
+        return None 
+ 
+    def _get_module_path(self, path, fullname): 
+        return os.path.join(path, *fullname.split('.')) 
+ 
+ 
+class YaTestLoggingFileHandler(logging.FileHandler): 
+    pass 
+ 
+ 
 class _TokenFilterFormatter(logging.Formatter):
     def __init__(self, fmt):
         super(_TokenFilterFormatter, self).__init__(fmt)
@@ -123,141 +123,141 @@ class _TokenFilterFormatter(logging.Formatter):
         return self._filter(super(_TokenFilterFormatter, self).format(record))
 
 
-def setup_logging(log_path, level=logging.DEBUG, *other_logs):
-    logs = [log_path] + list(other_logs)
-    root_logger = logging.getLogger()
-    for i in range(len(root_logger.handlers) - 1, -1, -1):
-        if isinstance(root_logger.handlers[i], YaTestLoggingFileHandler):
+def setup_logging(log_path, level=logging.DEBUG, *other_logs): 
+    logs = [log_path] + list(other_logs) 
+    root_logger = logging.getLogger() 
+    for i in range(len(root_logger.handlers) - 1, -1, -1): 
+        if isinstance(root_logger.handlers[i], YaTestLoggingFileHandler): 
             root_logger.handlers.pop(i).close()
-    root_logger.setLevel(level)
-    for log_file in logs:
-        file_handler = YaTestLoggingFileHandler(log_file)
-        log_format = '%(asctime)s - %(levelname)s - %(name)s - %(funcName)s: %(message)s'
+    root_logger.setLevel(level) 
+    for log_file in logs: 
+        file_handler = YaTestLoggingFileHandler(log_file) 
+        log_format = '%(asctime)s - %(levelname)s - %(name)s - %(funcName)s: %(message)s' 
         file_handler.setFormatter(_TokenFilterFormatter(log_format))
-        file_handler.setLevel(level)
-        root_logger.addHandler(file_handler)
-
-
-def pytest_addoption(parser):
-    parser.addoption("--build-root", action="store", dest="build_root", default="", help="path to the build root")
-    parser.addoption("--dep-root", action="append", dest="dep_roots", default=[], help="path to the dep build roots")
-    parser.addoption("--source-root", action="store", dest="source_root", default="", help="path to the source root")
-    parser.addoption("--data-root", action="store", dest="data_root", default="", help="path to the arcadia_tests_data root")
-    parser.addoption("--output-dir", action="store", dest="output_dir", default="", help="path to the test output dir")
-    parser.addoption("--python-path", action="store", dest="python_path", default="", help="path the canonical python binary")
-    parser.addoption("--valgrind-path", action="store", dest="valgrind_path", default="", help="path the canonical valgring binary")
-    parser.addoption("--test-filter", action="append", dest="test_filter", default=None, help="test filter")
+        file_handler.setLevel(level) 
+        root_logger.addHandler(file_handler) 
+ 
+ 
+def pytest_addoption(parser): 
+    parser.addoption("--build-root", action="store", dest="build_root", default="", help="path to the build root") 
+    parser.addoption("--dep-root", action="append", dest="dep_roots", default=[], help="path to the dep build roots") 
+    parser.addoption("--source-root", action="store", dest="source_root", default="", help="path to the source root") 
+    parser.addoption("--data-root", action="store", dest="data_root", default="", help="path to the arcadia_tests_data root") 
+    parser.addoption("--output-dir", action="store", dest="output_dir", default="", help="path to the test output dir") 
+    parser.addoption("--python-path", action="store", dest="python_path", default="", help="path the canonical python binary") 
+    parser.addoption("--valgrind-path", action="store", dest="valgrind_path", default="", help="path the canonical valgring binary") 
+    parser.addoption("--test-filter", action="append", dest="test_filter", default=None, help="test filter") 
     parser.addoption("--test-file-filter", action="store", dest="test_file_filter", default=None, help="test file filter")
-    parser.addoption("--test-param", action="append", dest="test_params", default=None, help="test parameters")
-    parser.addoption("--test-log-level", action="store", dest="test_log_level", choices=["critical", "error", "warning", "info", "debug"], default="debug", help="test log level")
+    parser.addoption("--test-param", action="append", dest="test_params", default=None, help="test parameters") 
+    parser.addoption("--test-log-level", action="store", dest="test_log_level", choices=["critical", "error", "warning", "info", "debug"], default="debug", help="test log level") 
     parser.addoption("--mode", action="store", choices=[yatest_lib.ya.RunMode.List, yatest_lib.ya.RunMode.Run], dest="mode", default=yatest_lib.ya.RunMode.Run, help="testing mode")
     parser.addoption("--test-list-file", action="store", dest="test_list_file")
-    parser.addoption("--modulo", default=1, type=int)
-    parser.addoption("--modulo-index", default=0, type=int)
+    parser.addoption("--modulo", default=1, type=int) 
+    parser.addoption("--modulo-index", default=0, type=int) 
     parser.addoption("--partition-mode", default='SEQUENTIAL', help="Split tests according to partitoin mode")
-    parser.addoption("--split-by-tests", action='store_true', help="Split test execution by tests instead of suites", default=False)
-    parser.addoption("--project-path", action="store", default="", help="path to CMakeList where test is declared")
-    parser.addoption("--build-type", action="store", default="", help="build type")
+    parser.addoption("--split-by-tests", action='store_true', help="Split test execution by tests instead of suites", default=False) 
+    parser.addoption("--project-path", action="store", default="", help="path to CMakeList where test is declared") 
+    parser.addoption("--build-type", action="store", default="", help="build type") 
     parser.addoption("--flags", action="append", dest="flags", default=[], help="build flags (-D)")
     parser.addoption("--sanitize", action="store", default="", help="sanitize mode")
-    parser.addoption("--test-stderr", action="store_true", default=False, help="test stderr")
+    parser.addoption("--test-stderr", action="store_true", default=False, help="test stderr") 
     parser.addoption("--test-debug", action="store_true", default=False, help="test debug mode")
-    parser.addoption("--root-dir", action="store", default=None)
-    parser.addoption("--ya-trace", action="store", dest="ya_trace_path", default=None, help="path to ya trace report")
+    parser.addoption("--root-dir", action="store", default=None) 
+    parser.addoption("--ya-trace", action="store", dest="ya_trace_path", default=None, help="path to ya trace report") 
     parser.addoption("--ya-version", action="store", dest="ya_version", default=0, type=int, help="allows to be compatible with ya and the new changes in ya-dev")
-    parser.addoption(
-        "--test-suffix", action="store", dest="test_suffix", default=None, help="add suffix to every test name"
-    )
-    parser.addoption("--gdb-path", action="store", dest="gdb_path", default="", help="path the canonical gdb binary")
-    parser.addoption("--collect-cores", action="store_true", dest="collect_cores", default=False, help="allows core dump file recovering during test")
+    parser.addoption( 
+        "--test-suffix", action="store", dest="test_suffix", default=None, help="add suffix to every test name" 
+    ) 
+    parser.addoption("--gdb-path", action="store", dest="gdb_path", default="", help="path the canonical gdb binary") 
+    parser.addoption("--collect-cores", action="store_true", dest="collect_cores", default=False, help="allows core dump file recovering during test") 
     parser.addoption("--sanitizer-extra-checks", action="store_true", dest="sanitizer_extra_checks", default=False, help="enables extra checks for tests built with sanitizers")
-    parser.addoption("--report-deselected", action="store_true", dest="report_deselected", default=False, help="report deselected tests to the trace file")
-    parser.addoption("--pdb-on-sigusr1", action="store_true", default=False, help="setup pdb.set_trace on SIGUSR1")
+    parser.addoption("--report-deselected", action="store_true", dest="report_deselected", default=False, help="report deselected tests to the trace file") 
+    parser.addoption("--pdb-on-sigusr1", action="store_true", default=False, help="setup pdb.set_trace on SIGUSR1") 
     parser.addoption("--test-tool-bin", help="Path to test_tool")
     parser.addoption("--test-list-path", dest="test_list_path", action="store", help="path to test list", default="")
-
-
+ 
+ 
 def from_ya_test():
     return "YA_TEST_RUNNER" in os.environ
 
 
-def pytest_configure(config):
+def pytest_configure(config): 
     global pytest_config
     pytest_config = config
 
     config.option.continue_on_collection_errors = True
-
+ 
     config.addinivalue_line("markers", "ya:external")
 
     config.from_ya_test = from_ya_test()
-    config.test_logs = collections.defaultdict(dict)
-    config.test_metrics = {}
+    config.test_logs = collections.defaultdict(dict) 
+    config.test_metrics = {} 
     config.suite_metrics = {}
     config.configure_timestamp = time.time()
-    context = {
-        "project_path": config.option.project_path,
-        "test_stderr": config.option.test_stderr,
+    context = { 
+        "project_path": config.option.project_path, 
+        "test_stderr": config.option.test_stderr, 
         "test_debug": config.option.test_debug,
-        "build_type": config.option.build_type,
-        "test_traceback": config.option.tbstyle,
+        "build_type": config.option.build_type, 
+        "test_traceback": config.option.tbstyle, 
         "flags": config.option.flags,
         "sanitize": config.option.sanitize,
-    }
+    } 
 
     if config.option.collectonly:
         config.option.mode = yatest_lib.ya.RunMode.List
 
     config.ya = yatest_lib.ya.Ya(
-        config.option.mode,
-        config.option.source_root,
-        config.option.build_root,
-        config.option.dep_roots,
-        config.option.output_dir,
-        config.option.test_params,
-        context,
-        config.option.python_path,
-        config.option.valgrind_path,
-        config.option.gdb_path,
-        config.option.data_root,
-    )
-    config.option.test_log_level = {
-        "critical": logging.CRITICAL,
-        "error": logging.ERROR,
-        "warning": logging.WARN,
-        "info": logging.INFO,
-        "debug": logging.DEBUG,
-    }[config.option.test_log_level]
-
-    if not config.option.collectonly:
-        setup_logging(os.path.join(config.ya.output_dir, "run.log"), config.option.test_log_level)
-    config.current_item_nodeid = None
-    config.current_test_name = None
-    config.test_cores_count = 0
-    config.collect_cores = config.option.collect_cores
+        config.option.mode, 
+        config.option.source_root, 
+        config.option.build_root, 
+        config.option.dep_roots, 
+        config.option.output_dir, 
+        config.option.test_params, 
+        context, 
+        config.option.python_path, 
+        config.option.valgrind_path, 
+        config.option.gdb_path, 
+        config.option.data_root, 
+    ) 
+    config.option.test_log_level = { 
+        "critical": logging.CRITICAL, 
+        "error": logging.ERROR, 
+        "warning": logging.WARN, 
+        "info": logging.INFO, 
+        "debug": logging.DEBUG, 
+    }[config.option.test_log_level] 
+ 
+    if not config.option.collectonly: 
+        setup_logging(os.path.join(config.ya.output_dir, "run.log"), config.option.test_log_level) 
+    config.current_item_nodeid = None 
+    config.current_test_name = None 
+    config.test_cores_count = 0 
+    config.collect_cores = config.option.collect_cores 
     config.sanitizer_extra_checks = config.option.sanitizer_extra_checks
     try:
         config.test_tool_bin = config.option.test_tool_bin
     except AttributeError:
         logging.info("test_tool_bin not specified")
-
-    if config.sanitizer_extra_checks:
+ 
+    if config.sanitizer_extra_checks: 
         for envvar in ['LSAN_OPTIONS', 'ASAN_OPTIONS']:
             if envvar in os.environ:
                 os.environ.pop(envvar)
             if envvar + '_ORIGINAL' in os.environ:
                 os.environ[envvar] = os.environ[envvar + '_ORIGINAL']
 
-    if config.option.root_dir:
+    if config.option.root_dir: 
         config.rootdir = py.path.local(config.option.root_dir)
         config.invocation_params = attr.evolve(config.invocation_params, dir=config.rootdir)
-
+ 
     extra_sys_path = []
     # Arcadia paths from the test DEPENDS section of ya.make
     extra_sys_path.append(os.path.join(config.option.source_root, config.option.project_path))
-    # Build root is required for correct import of protobufs, because imports are related to the root
-    # (like import devtools.dummy_arcadia.protos.lib.my_proto_pb2)
+    # Build root is required for correct import of protobufs, because imports are related to the root 
+    # (like import devtools.dummy_arcadia.protos.lib.my_proto_pb2) 
     extra_sys_path.append(config.option.build_root)
-
+ 
     for path in config.option.dep_roots:
         if os.path.isabs(path):
             extra_sys_path.append(path)
@@ -272,17 +272,17 @@ def pytest_configure(config):
 
     os.environ["PYTHONPATH"] = os.pathsep.join(sys.path)
 
-    if not config.option.collectonly:
-        if config.option.ya_trace_path:
-            config.ya_trace_reporter = TraceReportGenerator(config.option.ya_trace_path)
-        else:
-            config.ya_trace_reporter = DryTraceReportGenerator(config.option.ya_trace_path)
+    if not config.option.collectonly: 
+        if config.option.ya_trace_path: 
+            config.ya_trace_reporter = TraceReportGenerator(config.option.ya_trace_path) 
+        else: 
+            config.ya_trace_reporter = DryTraceReportGenerator(config.option.ya_trace_path) 
     config.ya_version = config.option.ya_version
-
-    sys.meta_path.append(CustomImporter([config.option.build_root] + [os.path.join(config.option.build_root, dep) for dep in config.option.dep_roots]))
-    if config.option.pdb_on_sigusr1:
-        configure_pdb_on_demand()
-
+ 
+    sys.meta_path.append(CustomImporter([config.option.build_root] + [os.path.join(config.option.build_root, dep) for dep in config.option.dep_roots])) 
+    if config.option.pdb_on_sigusr1: 
+        configure_pdb_on_demand() 
+ 
     # Dump python backtrace in case of any errors
     faulthandler.enable()
     if hasattr(signal, "SIGQUIT"):
@@ -291,7 +291,7 @@ def pytest_configure(config):
 
     if hasattr(signal, "SIGUSR2"):
         signal.signal(signal.SIGUSR2, _graceful_shutdown)
-
+ 
 
 session_should_exit = False
 
@@ -327,122 +327,122 @@ def _graceful_shutdown(*args):
     _graceful_shutdown_on_log(not capman.is_globally_capturing())
 
 
-def _get_rusage():
-    return resource and resource.getrusage(resource.RUSAGE_SELF)
-
-
-def _collect_test_rusage(item):
-    if resource and hasattr(item, "rusage"):
-        finish_rusage = _get_rusage()
+def _get_rusage(): 
+    return resource and resource.getrusage(resource.RUSAGE_SELF) 
+ 
+ 
+def _collect_test_rusage(item): 
+    if resource and hasattr(item, "rusage"): 
+        finish_rusage = _get_rusage() 
         ya_inst = pytest_config.ya
-
-        def add_metric(attr_name, metric_name=None, modifier=None):
-            if not metric_name:
-                metric_name = attr_name
-            if not modifier:
-                modifier = lambda x: x
-            if hasattr(item.rusage, attr_name):
+ 
+        def add_metric(attr_name, metric_name=None, modifier=None): 
+            if not metric_name: 
+                metric_name = attr_name 
+            if not modifier: 
+                modifier = lambda x: x 
+            if hasattr(item.rusage, attr_name): 
                 ya_inst.set_metric_value(metric_name, modifier(getattr(finish_rusage, attr_name) - getattr(item.rusage, attr_name)))
-
-        for args in [
-            ("ru_maxrss", "ru_rss", lambda x: x*1024),  # to be the same as in util/system/rusage.cpp
-            ("ru_utime",),
-            ("ru_stime",),
-            ("ru_ixrss", None, lambda x: x*1024),
-            ("ru_idrss", None, lambda x: x*1024),
-            ("ru_isrss", None, lambda x: x*1024),
-            ("ru_majflt", "ru_major_pagefaults"),
-            ("ru_minflt", "ru_minor_pagefaults"),
-            ("ru_nswap",),
-            ("ru_inblock",),
-            ("ru_oublock",),
-            ("ru_msgsnd",),
-            ("ru_msgrcv",),
-            ("ru_nsignals",),
-            ("ru_nvcsw",),
-            ("ru_nivcsw",),
-        ]:
-            add_metric(*args)
-
-
-def _get_item_tags(item):
-    tags = []
-    for key, value in item.keywords.items():
+ 
+        for args in [ 
+            ("ru_maxrss", "ru_rss", lambda x: x*1024),  # to be the same as in util/system/rusage.cpp 
+            ("ru_utime",), 
+            ("ru_stime",), 
+            ("ru_ixrss", None, lambda x: x*1024), 
+            ("ru_idrss", None, lambda x: x*1024), 
+            ("ru_isrss", None, lambda x: x*1024), 
+            ("ru_majflt", "ru_major_pagefaults"), 
+            ("ru_minflt", "ru_minor_pagefaults"), 
+            ("ru_nswap",), 
+            ("ru_inblock",), 
+            ("ru_oublock",), 
+            ("ru_msgsnd",), 
+            ("ru_msgrcv",), 
+            ("ru_nsignals",), 
+            ("ru_nvcsw",), 
+            ("ru_nivcsw",), 
+        ]: 
+            add_metric(*args) 
+ 
+ 
+def _get_item_tags(item): 
+    tags = [] 
+    for key, value in item.keywords.items(): 
         if key == 'pytestmark' and isinstance(value, list):
             for mark in value:
                 tags.append(mark.name)
         elif isinstance(value, _pytest.mark.MarkDecorator):
-            tags.append(key)
-    return tags
-
-
-def pytest_runtest_setup(item):
-    item.rusage = _get_rusage()
+            tags.append(key) 
+    return tags 
+ 
+ 
+def pytest_runtest_setup(item): 
+    item.rusage = _get_rusage() 
     pytest_config.test_cores_count = 0
     pytest_config.current_item_nodeid = item.nodeid
-    class_name, test_name = tools.split_node_id(item.nodeid)
+    class_name, test_name = tools.split_node_id(item.nodeid) 
     test_log_path = tools.get_test_log_file_path(pytest_config.ya.output_dir, class_name, test_name)
-    setup_logging(
+    setup_logging( 
         os.path.join(pytest_config.ya.output_dir, "run.log"),
         pytest_config.option.test_log_level,
-        test_log_path
-    )
+        test_log_path 
+    ) 
     pytest_config.test_logs[item.nodeid]['log'] = test_log_path
     pytest_config.test_logs[item.nodeid]['logsdir'] = pytest_config.ya.output_dir
     pytest_config.current_test_log_path = test_log_path
     pytest_config.current_test_name = "{}::{}".format(class_name, test_name)
-    separator = "#" * 100
-    yatest_logger.info(separator)
-    yatest_logger.info(test_name)
-    yatest_logger.info(separator)
-    yatest_logger.info("Test setup")
-
+    separator = "#" * 100 
+    yatest_logger.info(separator) 
+    yatest_logger.info(test_name) 
+    yatest_logger.info(separator) 
+    yatest_logger.info("Test setup") 
+ 
     test_item = CrashedTestItem(item.nodeid, pytest_config.option.test_suffix)
     pytest_config.ya_trace_reporter.on_start_test_class(test_item)
     pytest_config.ya_trace_reporter.on_start_test_case(test_item)
-
-
-def pytest_runtest_teardown(item, nextitem):
-    yatest_logger.info("Test teardown")
-
-
-def pytest_runtest_call(item):
+ 
+ 
+def pytest_runtest_teardown(item, nextitem): 
+    yatest_logger.info("Test teardown") 
+ 
+ 
+def pytest_runtest_call(item): 
     class_name, test_name = tools.split_node_id(item.nodeid)
     yatest_logger.info("Test call (class_name: %s, test_name: %s)", class_name, test_name)
-
-
-def pytest_deselected(items):
+ 
+ 
+def pytest_deselected(items): 
     config = pytest_config
-    if config.option.report_deselected:
-        for item in items:
-            deselected_item = DeselectedTestItem(item.nodeid, config.option.test_suffix)
-            config.ya_trace_reporter.on_start_test_class(deselected_item)
-            config.ya_trace_reporter.on_finish_test_case(deselected_item)
-            config.ya_trace_reporter.on_finish_test_class(deselected_item)
-
-
-@pytest.mark.trylast
-def pytest_collection_modifyitems(items, config):
-
-    def filter_items(filters):
-        filtered_items = []
-        deselected_items = []
-        for item in items:
+    if config.option.report_deselected: 
+        for item in items: 
+            deselected_item = DeselectedTestItem(item.nodeid, config.option.test_suffix) 
+            config.ya_trace_reporter.on_start_test_class(deselected_item) 
+            config.ya_trace_reporter.on_finish_test_case(deselected_item) 
+            config.ya_trace_reporter.on_finish_test_class(deselected_item) 
+ 
+ 
+@pytest.mark.trylast 
+def pytest_collection_modifyitems(items, config): 
+ 
+    def filter_items(filters): 
+        filtered_items = [] 
+        deselected_items = [] 
+        for item in items: 
             canonical_node_id = str(CustomTestItem(item.nodeid, pytest_config.option.test_suffix))
-            matched = False
-            for flt in filters:
+            matched = False 
+            for flt in filters: 
                 if "::" not in flt and "*" not in flt:
-                    flt += "*"  # add support for filtering by module name
-                if canonical_node_id.endswith(flt) or fnmatch.fnmatch(tools.escape_for_fnmatch(canonical_node_id), tools.escape_for_fnmatch(flt)):
-                    matched = True
-            if matched:
-                filtered_items.append(item)
-            else:
-                deselected_items.append(item)
-
-        config.hook.pytest_deselected(items=deselected_items)
-        items[:] = filtered_items
-
+                    flt += "*"  # add support for filtering by module name 
+                if canonical_node_id.endswith(flt) or fnmatch.fnmatch(tools.escape_for_fnmatch(canonical_node_id), tools.escape_for_fnmatch(flt)): 
+                    matched = True 
+            if matched: 
+                filtered_items.append(item) 
+            else: 
+                deselected_items.append(item) 
+ 
+        config.hook.pytest_deselected(items=deselected_items) 
+        items[:] = filtered_items 
+ 
     def filter_by_full_name(filters):
         filter_set = {flt for flt in filters}
         filtered_items = []
@@ -456,10 +456,10 @@ def pytest_collection_modifyitems(items, config):
         config.hook.pytest_deselected(items=deselected_items)
         items[:] = filtered_items
 
-    # XXX - check to be removed when tests for peerdirs don't run
-    for item in items:
-        if not item.nodeid:
-            item._nodeid = os.path.basename(item.location[0])
+    # XXX - check to be removed when tests for peerdirs don't run 
+    for item in items: 
+        if not item.nodeid: 
+            item._nodeid = os.path.basename(item.location[0]) 
     if os.path.exists(config.option.test_list_path):
         with open(config.option.test_list_path, 'r') as afile:
             chunks = json.load(afile)
@@ -490,39 +490,39 @@ def pytest_collection_modifyitems(items, config):
             for item in chunk_items:
                 items.extend(item)
             yatest_logger.info("Modulo %s tests are: %s", modulo_index, chunk_items)
-
+ 
     if config.option.mode == yatest_lib.ya.RunMode.Run:
-        for item in items:
-            test_item = NotLaunchedTestItem(item.nodeid, config.option.test_suffix)
-            config.ya_trace_reporter.on_start_test_class(test_item)
-            config.ya_trace_reporter.on_finish_test_case(test_item)
-            config.ya_trace_reporter.on_finish_test_class(test_item)
+        for item in items: 
+            test_item = NotLaunchedTestItem(item.nodeid, config.option.test_suffix) 
+            config.ya_trace_reporter.on_start_test_class(test_item) 
+            config.ya_trace_reporter.on_finish_test_case(test_item) 
+            config.ya_trace_reporter.on_finish_test_class(test_item) 
     elif config.option.mode == yatest_lib.ya.RunMode.List:
-        tests = []
-        for item in items:
+        tests = [] 
+        for item in items: 
             item = CustomTestItem(item.nodeid, pytest_config.option.test_suffix, item.keywords)
-            record = {
-                "class": item.class_name,
-                "test": item.test_name,
-                "tags": _get_item_tags(item),
-            }
-            tests.append(record)
+            record = { 
+                "class": item.class_name, 
+                "test": item.test_name, 
+                "tags": _get_item_tags(item), 
+            } 
+            tests.append(record) 
         if config.option.test_list_file:
             with open(config.option.test_list_file, 'w') as afile:
                 json.dump(tests, afile)
         # TODO prettyboy remove after test_tool release - currently it's required for backward compatibility
-        sys.stderr.write(json.dumps(tests))
-
-
-def pytest_collectreport(report):
-    if not report.passed:
+        sys.stderr.write(json.dumps(tests)) 
+ 
+ 
+def pytest_collectreport(report): 
+    if not report.passed: 
         if hasattr(pytest_config, 'ya_trace_reporter'):
             test_item = TestItem(report, None, pytest_config.option.test_suffix)
             pytest_config.ya_trace_reporter.on_error(test_item)
-        else:
-            sys.stderr.write(yatest_lib.tools.to_utf8(report.longrepr))
-
-
+        else: 
+            sys.stderr.write(yatest_lib.tools.to_utf8(report.longrepr)) 
+ 
+ 
 @pytest.mark.tryfirst
 def pytest_pyfunc_call(pyfuncitem):
     testfunction = pyfuncitem.obj
@@ -542,7 +542,7 @@ def pytest_pyfunc_call(pyfuncitem):
 
 
 @pytest.hookimpl(hookwrapper=True)
-def pytest_runtest_makereport(item, call):
+def pytest_runtest_makereport(item, call): 
     def logreport(report, result, call):
         test_item = TestItem(report, result, pytest_config.option.test_suffix)
         if not pytest_config.suite_metrics and context.Ctx.get("YA_PYTEST_START_TIMESTAMP"):
@@ -554,24 +554,24 @@ def pytest_runtest_makereport(item, call):
         if report.outcome == "failed":
             yatest_logger.error(report.longrepr)
 
-        if report.when == "call":
-            _collect_test_rusage(item)
+        if report.when == "call": 
+            _collect_test_rusage(item) 
             pytest_config.ya_trace_reporter.on_finish_test_case(test_item)
-        elif report.when == "setup":
+        elif report.when == "setup": 
             pytest_config.ya_trace_reporter.on_start_test_class(test_item)
-            if report.outcome != "passed":
+            if report.outcome != "passed": 
                 pytest_config.ya_trace_reporter.on_start_test_case(test_item)
                 pytest_config.ya_trace_reporter.on_finish_test_case(test_item)
-            else:
+            else: 
                 pytest_config.ya_trace_reporter.on_start_test_case(test_item)
-        elif report.when == "teardown":
-            if report.outcome == "failed":
+        elif report.when == "teardown": 
+            if report.outcome == "failed": 
                 pytest_config.ya_trace_reporter.on_start_test_case(test_item)
                 pytest_config.ya_trace_reporter.on_finish_test_case(test_item)
             else:
                 pytest_config.ya_trace_reporter.on_finish_test_case(test_item, duration_only=True)
             pytest_config.ya_trace_reporter.on_finish_test_class(test_item)
-
+ 
     outcome = yield
     rep = outcome.get_result()
     result = None
@@ -580,10 +580,10 @@ def pytest_runtest_makereport(item, call):
         if not pytest_config.from_ya_test:
             ti = TestItem(rep, result, pytest_config.option.test_suffix)
             tr = pytest_config.pluginmanager.getplugin('terminalreporter')
-            tr.write_line("{} - Validating canonical data is not supported when running standalone binary".format(ti), yellow=True, bold=True)
+            tr.write_line("{} - Validating canonical data is not supported when running standalone binary".format(ti), yellow=True, bold=True) 
     logreport(rep, result, call)
-
-
+ 
+ 
 def pytest_make_parametrize_id(config, val, argname):
     # Avoid <, > symbols in canondata file names
     if inspect.isfunction(val) and val.__name__ == "<lambda>":
@@ -598,7 +598,7 @@ def get_formatted_error(report):
             text += colorize(entry)
     else:
         text = colorize(report.longrepr)
-    text = yatest_lib.tools.to_utf8(text)
+    text = yatest_lib.tools.to_utf8(text) 
     return text
 
 
@@ -616,9 +616,9 @@ def colorize(longrepr):
         if hasattr(longrepr, 'reprtraceback') and hasattr(longrepr.reprtraceback, 'toterminal'):
             longrepr.reprtraceback.toterminal(writer)
             return io.getvalue().strip()
-        return yatest_lib.tools.to_utf8(longrepr)
+        return yatest_lib.tools.to_utf8(longrepr) 
 
-    text = yatest_lib.tools.to_utf8(longrepr)
+    text = yatest_lib.tools.to_utf8(longrepr) 
     pos = text.find("E   ")
     if pos == -1:
         return text
@@ -633,25 +633,25 @@ def colorize(longrepr):
     return "{}[[bad]]{}".format(bt, error)
 
 
-class TestItem(object):
-
-    def __init__(self, report, result, test_suffix):
-        self._result = result
-        self.nodeid = report.nodeid
-        self._class_name, self._test_name = tools.split_node_id(self.nodeid, test_suffix)
-        self._error = None
-        self._status = None
-        self._process_report(report)
-        self._duration = hasattr(report, 'duration') and report.duration or 0
-        self._keywords = getattr(report, "keywords", {})
-
-    def _process_report(self, report):
-        if report.longrepr:
-            self.set_error(report)
-            if hasattr(report, 'when') and report.when != "call":
-                self.set_error(report.when + " failed:\n" + self._error)
-        else:
-            self.set_error("")
+class TestItem(object): 
+ 
+    def __init__(self, report, result, test_suffix): 
+        self._result = result 
+        self.nodeid = report.nodeid 
+        self._class_name, self._test_name = tools.split_node_id(self.nodeid, test_suffix) 
+        self._error = None 
+        self._status = None 
+        self._process_report(report) 
+        self._duration = hasattr(report, 'duration') and report.duration or 0 
+        self._keywords = getattr(report, "keywords", {}) 
+ 
+    def _process_report(self, report): 
+        if report.longrepr: 
+            self.set_error(report) 
+            if hasattr(report, 'when') and report.when != "call": 
+                self.set_error(report.when + " failed:\n" + self._error) 
+        else: 
+            self.set_error("") 
 
         report_teststatus = _pytest.skipping.pytest_report_teststatus(report)
         if report_teststatus is not None:
@@ -667,89 +667,89 @@ class TestItem(object):
             self._status = 'skipped'
             self.set_error(yatest_lib.tools.to_utf8(report.longrepr[-1]))
         elif report.passed:
-            self._status = 'good'
-            self.set_error("")
+            self._status = 'good' 
+            self.set_error("") 
         else:
             self._status = 'fail'
-
-    @property
-    def status(self):
-        return self._status
-
-    def set_status(self, status):
-        self._status = status
-
-    @property
-    def test_name(self):
-        return tools.normalize_name(self._test_name)
-
-    @property
-    def class_name(self):
-        return tools.normalize_name(self._class_name)
-
-    @property
-    def error(self):
-        return self._error
-
+ 
+    @property 
+    def status(self): 
+        return self._status 
+ 
+    def set_status(self, status): 
+        self._status = status 
+ 
+    @property 
+    def test_name(self): 
+        return tools.normalize_name(self._test_name) 
+ 
+    @property 
+    def class_name(self): 
+        return tools.normalize_name(self._class_name) 
+ 
+    @property 
+    def error(self): 
+        return self._error 
+ 
     def set_error(self, entry, marker='bad'):
         if isinstance(entry, _pytest.reports.BaseReport):
-            self._error = get_formatted_error(entry)
-        else:
+            self._error = get_formatted_error(entry) 
+        else: 
             self._error = "[[{}]]{}".format(yatest_lib.tools.to_str(marker), yatest_lib.tools.to_str(entry))
-
-    @property
-    def duration(self):
-        return self._duration
-
-    @property
-    def result(self):
-        if 'not_canonize' in self._keywords:
-            return None
-        return self._result
-
-    @property
-    def keywords(self):
-        return self._keywords
-
-    def __str__(self):
-        return "{}::{}".format(self.class_name, self.test_name)
-
-
-class CustomTestItem(TestItem):
-
-    def __init__(self, nodeid, test_suffix, keywords=None):
-        self._result = None
-        self.nodeid = nodeid
-        self._class_name, self._test_name = tools.split_node_id(nodeid, test_suffix)
-        self._duration = 0
-        self._error = ""
-        self._keywords = keywords if keywords is not None else {}
-
-
-class NotLaunchedTestItem(CustomTestItem):
-
-    def __init__(self, nodeid, test_suffix):
-        super(NotLaunchedTestItem, self).__init__(nodeid, test_suffix)
-        self._status = "not_launched"
-
-
-class CrashedTestItem(CustomTestItem):
-
-    def __init__(self, nodeid, test_suffix):
-        super(CrashedTestItem, self).__init__(nodeid, test_suffix)
-        self._status = "crashed"
-
-
-class DeselectedTestItem(CustomTestItem):
-
-    def __init__(self, nodeid, test_suffix):
-        super(DeselectedTestItem, self).__init__(nodeid, test_suffix)
-        self._status = "deselected"
-
-
-class TraceReportGenerator(object):
-
-    def __init__(self, out_file_path):
+ 
+    @property 
+    def duration(self): 
+        return self._duration 
+ 
+    @property 
+    def result(self): 
+        if 'not_canonize' in self._keywords: 
+            return None 
+        return self._result 
+ 
+    @property 
+    def keywords(self): 
+        return self._keywords 
+ 
+    def __str__(self): 
+        return "{}::{}".format(self.class_name, self.test_name) 
+ 
+ 
+class CustomTestItem(TestItem): 
+ 
+    def __init__(self, nodeid, test_suffix, keywords=None): 
+        self._result = None 
+        self.nodeid = nodeid 
+        self._class_name, self._test_name = tools.split_node_id(nodeid, test_suffix) 
+        self._duration = 0 
+        self._error = "" 
+        self._keywords = keywords if keywords is not None else {} 
+ 
+ 
+class NotLaunchedTestItem(CustomTestItem): 
+ 
+    def __init__(self, nodeid, test_suffix): 
+        super(NotLaunchedTestItem, self).__init__(nodeid, test_suffix) 
+        self._status = "not_launched" 
+ 
+ 
+class CrashedTestItem(CustomTestItem): 
+ 
+    def __init__(self, nodeid, test_suffix): 
+        super(CrashedTestItem, self).__init__(nodeid, test_suffix) 
+        self._status = "crashed" 
+ 
+ 
+class DeselectedTestItem(CustomTestItem): 
+ 
+    def __init__(self, nodeid, test_suffix): 
+        super(DeselectedTestItem, self).__init__(nodeid, test_suffix) 
+        self._status = "deselected" 
+ 
+ 
+class TraceReportGenerator(object): 
+ 
+    def __init__(self, out_file_path): 
         self._filename = out_file_path
         self._file = open(out_file_path, 'w')
         self._wreckage_filename = out_file_path + '.wreckage'
@@ -759,7 +759,7 @@ class TraceReportGenerator(object):
         self._current_test = (None, None)
         self._pid = os.getpid()
         self._check_intricate_respawn()
-
+ 
     def _check_intricate_respawn(self):
         pid_file = self._filename + '.pid'
         try:
@@ -803,40 +803,40 @@ class TraceReportGenerator(object):
             # Test binary is launched without `ya make -t`'s testing machinery - don't rely on clean environment
             pass
 
-    def on_start_test_class(self, test_item):
+    def on_start_test_class(self, test_item): 
         pytest_config.ya.set_test_item_node_id(test_item.nodeid)
         class_name = test_item.class_name.decode('utf-8') if sys.version_info[0] < 3 else test_item.class_name
         self._current_test = (class_name, None)
         self.trace('test-started', {'class': class_name})
-
-    def on_finish_test_class(self, test_item):
+ 
+    def on_finish_test_class(self, test_item): 
         pytest_config.ya.set_test_item_node_id(test_item.nodeid)
         self.trace('test-finished', {'class': test_item.class_name.decode('utf-8') if sys.version_info[0] < 3 else test_item.class_name})
-
-    def on_start_test_case(self, test_item):
+ 
+    def on_start_test_case(self, test_item): 
         class_name = yatest_lib.tools.to_utf8(test_item.class_name)
         subtest_name = yatest_lib.tools.to_utf8(test_item.test_name)
-        message = {
+        message = { 
             'class': class_name,
             'subtest': subtest_name,
-        }
+        } 
         if test_item.nodeid in pytest_config.test_logs:
             message['logs'] = pytest_config.test_logs[test_item.nodeid]
         pytest_config.ya.set_test_item_node_id(test_item.nodeid)
         self._current_test = (class_name, subtest_name)
-        self.trace('subtest-started', message)
-
+        self.trace('subtest-started', message) 
+ 
     def on_finish_test_case(self, test_item, duration_only=False):
         if test_item.result is not None:
-            try:
+            try: 
                 result = canon.serialize(test_item.result)
-            except Exception as e:
-                yatest_logger.exception("Error while serializing test results")
-                test_item.set_error("Invalid test result: {}".format(e))
-                test_item.set_status("fail")
-                result = None
-        else:
-            result = None
+            except Exception as e: 
+                yatest_logger.exception("Error while serializing test results") 
+                test_item.set_error("Invalid test result: {}".format(e)) 
+                test_item.set_status("fail") 
+                result = None 
+        else: 
+            result = None 
 
         if duration_only and test_item.nodeid in self._test_messages:  # add teardown time
             message = self._test_messages[test_item.nodeid]
@@ -860,7 +860,7 @@ class TraceReportGenerator(object):
 
         self.trace('subtest-finished', message)
         self._test_messages[test_item.nodeid] = message
-
+ 
     def dump_suite_metrics(self):
         message = {"metrics": pytest_config.suite_metrics}
         self.trace("suite-event", message)
@@ -874,28 +874,28 @@ class TraceReportGenerator(object):
         else:
             self._test_duration[test_item.nodeid] = test_item._duration
 
-    @staticmethod
-    def _get_comment(test_item):
-        msg = yatest_lib.tools.to_utf8(test_item.error)
-        if not msg:
-            return ""
+    @staticmethod 
+    def _get_comment(test_item): 
+        msg = yatest_lib.tools.to_utf8(test_item.error) 
+        if not msg: 
+            return "" 
         return msg + "[[rst]]"
-
+ 
     def _dump_trace(self, name, value):
-        event = {
-            'timestamp': time.time(),
-            'value': value,
-            'name': name
-        }
+        event = { 
+            'timestamp': time.time(), 
+            'value': value, 
+            'name': name 
+        } 
 
         data = yatest_lib.tools.to_str(json.dumps(event, ensure_ascii=False))
         self._file.write(data + '\n')
         self._file.flush()
-
+ 
     def _check_sloppy_fork(self, name, value):
         if self._pid == os.getpid():
             return
-
+ 
         yatest_logger.error("Skip tracing to avoid data corruption, name = %s, value = %s", name, value)
 
         try:
@@ -950,14 +950,14 @@ class TraceReportGenerator(object):
         self._dump_trace(name, value)
 
 
-class DryTraceReportGenerator(TraceReportGenerator):
-    """
-    Generator does not write any information.
-    """
-
-    def __init__(self, *args, **kwargs):
+class DryTraceReportGenerator(TraceReportGenerator): 
+    """ 
+    Generator does not write any information. 
+    """ 
+ 
+    def __init__(self, *args, **kwargs): 
         self._test_messages = {}
         self._test_duration = {}
-
-    def trace(self, name, value):
-        pass
+ 
+    def trace(self, name, value): 
+        pass