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

1 files changed, 196 insertions, 196 deletions

diff --git a/contrib/python/pytest/py2/_pytest/debugging.py b/contrib/python/pytest/py2/_pytest/debugging.py
index bc114c8683..1bbca0f7bb 100644
--- a/contrib/python/pytest/py2/_pytest/debugging.py
+++ b/contrib/python/pytest/py2/_pytest/debugging.py
@@ -1,18 +1,18 @@
-# -*- coding: utf-8 -*-
+# -*- coding: utf-8 -*- 
 """ interactive debugging with PDB, the Python Debugger. """
 from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function
 
 import os
-import argparse
+import argparse 
 import pdb
 import sys
 from doctest import UnexpectedException
 
 from _pytest import outcomes
 from _pytest.config import hookimpl
-from _pytest.config.exceptions import UsageError
+from _pytest.config.exceptions import UsageError 
 
 
 def import_readline():
@@ -51,17 +51,17 @@ def tty():
         sys.path = old_sys_path
 
 
-def _validate_usepdb_cls(value):
-    """Validate syntax of --pdbcls option."""
-    try:
-        modname, classname = value.split(":")
-    except ValueError:
-        raise argparse.ArgumentTypeError(
-            "{!r} is not in the format 'modname:classname'".format(value)
-        )
-    return (modname, classname)
-
-
+def _validate_usepdb_cls(value): 
+    """Validate syntax of --pdbcls option.""" 
+    try: 
+        modname, classname = value.split(":") 
+    except ValueError: 
+        raise argparse.ArgumentTypeError( 
+            "{!r} is not in the format 'modname:classname'".format(value) 
+        ) 
+    return (modname, classname) 
+ 
+ 
 def pytest_addoption(parser):
     group = parser.getgroup("general")
     group._addoption(
@@ -74,7 +74,7 @@ def pytest_addoption(parser):
         "--pdbcls",
         dest="usepdb_cls",
         metavar="modulename:classname",
-        type=_validate_usepdb_cls,
+        type=_validate_usepdb_cls, 
         help="start a custom interactive Python debugger on errors. "
         "For example: --pdbcls=IPython.terminal.debugger:TerminalPdb",
     )
@@ -93,7 +93,7 @@ def pytest_configure(config):
         config.pluginmanager.register(PdbInvoke(), "pdbinvoke")
 
     pytestPDB._saved.append(
-        (pdb.set_trace, pytestPDB._pluginmanager, pytestPDB._config)
+        (pdb.set_trace, pytestPDB._pluginmanager, pytestPDB._config) 
     )
     pdb.set_trace = pytestPDB.set_trace
     pytestPDB._pluginmanager = config.pluginmanager
@@ -117,181 +117,181 @@ class pytestPDB(object):
     _pluginmanager = None
     _config = None
     _saved = []
-    _recursive_debug = 0
-    _wrapped_pdb_cls = None
-
-    @classmethod
-    def _is_capturing(cls, capman):
-        if capman:
-            return capman.is_capturing()
-        return False
-
-    @classmethod
-    def _import_pdb_cls(cls, capman):
-        if not cls._config:
-            # Happens when using pytest.set_trace outside of a test.
-            return pdb.Pdb
-
-        usepdb_cls = cls._config.getvalue("usepdb_cls")
-
-        if cls._wrapped_pdb_cls and cls._wrapped_pdb_cls[0] == usepdb_cls:
-            return cls._wrapped_pdb_cls[1]
-
-        if usepdb_cls:
-            modname, classname = usepdb_cls
-
-            try:
-                __import__(modname)
-                mod = sys.modules[modname]
-
-                # Handle --pdbcls=pdb:pdb.Pdb (useful e.g. with pdbpp).
-                parts = classname.split(".")
-                pdb_cls = getattr(mod, parts[0])
-                for part in parts[1:]:
-                    pdb_cls = getattr(pdb_cls, part)
-            except Exception as exc:
-                value = ":".join((modname, classname))
-                raise UsageError(
-                    "--pdbcls: could not import {!r}: {}".format(value, exc)
-                )
-        else:
-            pdb_cls = pdb.Pdb
-
-        wrapped_cls = cls._get_pdb_wrapper_class(pdb_cls, capman)
-        cls._wrapped_pdb_cls = (usepdb_cls, wrapped_cls)
-        return wrapped_cls
+    _recursive_debug = 0 
+    _wrapped_pdb_cls = None 
 
     @classmethod
-    def _get_pdb_wrapper_class(cls, pdb_cls, capman):
+    def _is_capturing(cls, capman): 
+        if capman: 
+            return capman.is_capturing() 
+        return False 
+ 
+    @classmethod 
+    def _import_pdb_cls(cls, capman): 
+        if not cls._config: 
+            # Happens when using pytest.set_trace outside of a test. 
+            return pdb.Pdb 
+ 
+        usepdb_cls = cls._config.getvalue("usepdb_cls") 
+ 
+        if cls._wrapped_pdb_cls and cls._wrapped_pdb_cls[0] == usepdb_cls: 
+            return cls._wrapped_pdb_cls[1] 
+ 
+        if usepdb_cls: 
+            modname, classname = usepdb_cls 
+ 
+            try: 
+                __import__(modname) 
+                mod = sys.modules[modname] 
+ 
+                # Handle --pdbcls=pdb:pdb.Pdb (useful e.g. with pdbpp). 
+                parts = classname.split(".") 
+                pdb_cls = getattr(mod, parts[0]) 
+                for part in parts[1:]: 
+                    pdb_cls = getattr(pdb_cls, part) 
+            except Exception as exc: 
+                value = ":".join((modname, classname)) 
+                raise UsageError( 
+                    "--pdbcls: could not import {!r}: {}".format(value, exc) 
+                ) 
+        else: 
+            pdb_cls = pdb.Pdb 
+ 
+        wrapped_cls = cls._get_pdb_wrapper_class(pdb_cls, capman) 
+        cls._wrapped_pdb_cls = (usepdb_cls, wrapped_cls) 
+        return wrapped_cls 
+ 
+    @classmethod 
+    def _get_pdb_wrapper_class(cls, pdb_cls, capman): 
         import _pytest.config
 
-        class PytestPdbWrapper(pdb_cls, object):
-            _pytest_capman = capman
-            _continued = False
-
-            def do_debug(self, arg):
-                cls._recursive_debug += 1
-                ret = super(PytestPdbWrapper, self).do_debug(arg)
-                cls._recursive_debug -= 1
-                return ret
-
-            def do_continue(self, arg):
-                ret = super(PytestPdbWrapper, self).do_continue(arg)
-                if cls._recursive_debug == 0:
-                    tw = _pytest.config.create_terminal_writer(cls._config)
-                    tw.line()
-
-                    capman = self._pytest_capman
-                    capturing = pytestPDB._is_capturing(capman)
-                    if capturing:
-                        if capturing == "global":
+        class PytestPdbWrapper(pdb_cls, object): 
+            _pytest_capman = capman 
+            _continued = False 
+
+            def do_debug(self, arg): 
+                cls._recursive_debug += 1 
+                ret = super(PytestPdbWrapper, self).do_debug(arg) 
+                cls._recursive_debug -= 1 
+                return ret 
+
+            def do_continue(self, arg): 
+                ret = super(PytestPdbWrapper, self).do_continue(arg) 
+                if cls._recursive_debug == 0: 
+                    tw = _pytest.config.create_terminal_writer(cls._config) 
+                    tw.line() 
+ 
+                    capman = self._pytest_capman 
+                    capturing = pytestPDB._is_capturing(capman) 
+                    if capturing: 
+                        if capturing == "global": 
                             tw.sep(">", "PDB continue (IO-capturing resumed)")
                         else:
-                            tw.sep(
-                                ">",
-                                "PDB continue (IO-capturing resumed for %s)"
-                                % capturing,
-                            )
-                        capman.resume()
-                    else:
-                        tw.sep(">", "PDB continue")
-                cls._pluginmanager.hook.pytest_leave_pdb(config=cls._config, pdb=self)
-                self._continued = True
-                return ret
-
-            do_c = do_cont = do_continue
-
-            def do_quit(self, arg):
-                """Raise Exit outcome when quit command is used in pdb.
-
-                This is a bit of a hack - it would be better if BdbQuit
-                could be handled, but this would require to wrap the
-                whole pytest run, and adjust the report etc.
-                """
-                ret = super(PytestPdbWrapper, self).do_quit(arg)
-
-                if cls._recursive_debug == 0:
-                    outcomes.exit("Quitting debugger")
-
-                return ret
-
-            do_q = do_quit
-            do_exit = do_quit
-
-            def setup(self, f, tb):
-                """Suspend on setup().
-
-                Needed after do_continue resumed, and entering another
-                breakpoint again.
-                """
-                ret = super(PytestPdbWrapper, self).setup(f, tb)
-                if not ret and self._continued:
-                    # pdb.setup() returns True if the command wants to exit
-                    # from the interaction: do not suspend capturing then.
-                    if self._pytest_capman:
-                        self._pytest_capman.suspend_global_capture(in_=True)
-                return ret
-
-            def get_stack(self, f, t):
-                stack, i = super(PytestPdbWrapper, self).get_stack(f, t)
-                if f is None:
-                    # Find last non-hidden frame.
-                    i = max(0, len(stack) - 1)
-                    while i and stack[i][0].f_locals.get("__tracebackhide__", False):
-                        i -= 1
-                return stack, i
-
-        return PytestPdbWrapper
-
-    @classmethod
-    def _init_pdb(cls, method, *args, **kwargs):
-        """ Initialize PDB debugging, dropping any IO capturing. """
-        import _pytest.config
-
-        if cls._pluginmanager is not None:
-            capman = cls._pluginmanager.getplugin("capturemanager")
+                            tw.sep( 
+                                ">", 
+                                "PDB continue (IO-capturing resumed for %s)" 
+                                % capturing, 
+                            ) 
+                        capman.resume() 
+                    else: 
+                        tw.sep(">", "PDB continue") 
+                cls._pluginmanager.hook.pytest_leave_pdb(config=cls._config, pdb=self) 
+                self._continued = True 
+                return ret 
+
+            do_c = do_cont = do_continue 
+
+            def do_quit(self, arg): 
+                """Raise Exit outcome when quit command is used in pdb. 
+
+                This is a bit of a hack - it would be better if BdbQuit 
+                could be handled, but this would require to wrap the 
+                whole pytest run, and adjust the report etc. 
+                """ 
+                ret = super(PytestPdbWrapper, self).do_quit(arg) 
+
+                if cls._recursive_debug == 0: 
+                    outcomes.exit("Quitting debugger") 
+ 
+                return ret 
+ 
+            do_q = do_quit 
+            do_exit = do_quit 
+ 
+            def setup(self, f, tb): 
+                """Suspend on setup(). 
+ 
+                Needed after do_continue resumed, and entering another 
+                breakpoint again. 
+                """ 
+                ret = super(PytestPdbWrapper, self).setup(f, tb) 
+                if not ret and self._continued: 
+                    # pdb.setup() returns True if the command wants to exit 
+                    # from the interaction: do not suspend capturing then. 
+                    if self._pytest_capman: 
+                        self._pytest_capman.suspend_global_capture(in_=True) 
+                return ret 
+ 
+            def get_stack(self, f, t): 
+                stack, i = super(PytestPdbWrapper, self).get_stack(f, t) 
+                if f is None: 
+                    # Find last non-hidden frame. 
+                    i = max(0, len(stack) - 1) 
+                    while i and stack[i][0].f_locals.get("__tracebackhide__", False): 
+                        i -= 1 
+                return stack, i 
+ 
+        return PytestPdbWrapper 
+ 
+    @classmethod 
+    def _init_pdb(cls, method, *args, **kwargs): 
+        """ Initialize PDB debugging, dropping any IO capturing. """ 
+        import _pytest.config 
+ 
+        if cls._pluginmanager is not None: 
+            capman = cls._pluginmanager.getplugin("capturemanager") 
         else:
-            capman = None
-        if capman:
-            capman.suspend(in_=True)
-
-        if cls._config:
-            tw = _pytest.config.create_terminal_writer(cls._config)
-            tw.line()
-
-            if cls._recursive_debug == 0:
-                # Handle header similar to pdb.set_trace in py37+.
-                header = kwargs.pop("header", None)
-                if header is not None:
-                    tw.sep(">", header)
-                else:
-                    capturing = cls._is_capturing(capman)
-                    if capturing == "global":
-                        tw.sep(">", "PDB %s (IO-capturing turned off)" % (method,))
-                    elif capturing:
-                        tw.sep(
-                            ">",
-                            "PDB %s (IO-capturing turned off for %s)"
-                            % (method, capturing),
-                        )
-                    else:
-                        tw.sep(">", "PDB %s" % (method,))
-
-        _pdb = cls._import_pdb_cls(capman)(**kwargs)
-
-        if cls._pluginmanager:
-            cls._pluginmanager.hook.pytest_enter_pdb(config=cls._config, pdb=_pdb)
-        return _pdb
-
-    @classmethod
-    def set_trace(cls, *args, **kwargs):
-        """Invoke debugging via ``Pdb.set_trace``, dropping any IO capturing."""
-        tty()
-        frame = sys._getframe().f_back
-        _pdb = cls._init_pdb("set_trace", *args, **kwargs)
-        _pdb.set_trace(frame)
-
-
+            capman = None 
+        if capman: 
+            capman.suspend(in_=True) 
+
+        if cls._config: 
+            tw = _pytest.config.create_terminal_writer(cls._config) 
+            tw.line() 
+
+            if cls._recursive_debug == 0: 
+                # Handle header similar to pdb.set_trace in py37+. 
+                header = kwargs.pop("header", None) 
+                if header is not None: 
+                    tw.sep(">", header) 
+                else: 
+                    capturing = cls._is_capturing(capman) 
+                    if capturing == "global": 
+                        tw.sep(">", "PDB %s (IO-capturing turned off)" % (method,)) 
+                    elif capturing: 
+                        tw.sep( 
+                            ">", 
+                            "PDB %s (IO-capturing turned off for %s)" 
+                            % (method, capturing), 
+                        ) 
+                    else: 
+                        tw.sep(">", "PDB %s" % (method,)) 
+
+        _pdb = cls._import_pdb_cls(capman)(**kwargs) 
+ 
+        if cls._pluginmanager: 
+            cls._pluginmanager.hook.pytest_enter_pdb(config=cls._config, pdb=_pdb) 
+        return _pdb 
+ 
+    @classmethod 
+    def set_trace(cls, *args, **kwargs): 
+        """Invoke debugging via ``Pdb.set_trace``, dropping any IO capturing.""" 
+        tty() 
+        frame = sys._getframe().f_back 
+        _pdb = cls._init_pdb("set_trace", *args, **kwargs) 
+        _pdb.set_trace(frame) 
+ 
+ 
 class PdbInvoke(object):
     def pytest_exception_interact(self, node, call, report):
         capman = node.config.pluginmanager.getplugin("capturemanager")
@@ -316,15 +316,15 @@ class PdbTrace(object):
 
 
 def _test_pytest_function(pyfuncitem):
-    _pdb = pytestPDB._init_pdb("runcall")
+    _pdb = pytestPDB._init_pdb("runcall") 
     testfunction = pyfuncitem.obj
-    pyfuncitem.obj = _pdb.runcall
-    if "func" in pyfuncitem._fixtureinfo.argnames:  # pragma: no branch
-        raise ValueError("--trace can't be used with a fixture named func!")
-    pyfuncitem.funcargs["func"] = testfunction
-    new_list = list(pyfuncitem._fixtureinfo.argnames)
-    new_list.append("func")
-    pyfuncitem._fixtureinfo.argnames = tuple(new_list)
+    pyfuncitem.obj = _pdb.runcall 
+    if "func" in pyfuncitem._fixtureinfo.argnames:  # pragma: no branch 
+        raise ValueError("--trace can't be used with a fixture named func!") 
+    pyfuncitem.funcargs["func"] = testfunction 
+    new_list = list(pyfuncitem._fixtureinfo.argnames) 
+    new_list.append("func") 
+    pyfuncitem._fixtureinfo.argnames = tuple(new_list) 
 
 
 def _enter_pdb(node, excinfo, rep):
@@ -352,7 +352,7 @@ def _enter_pdb(node, excinfo, rep):
     tw.sep(">", "entering PDB")
     tb = _postmortem_traceback(excinfo)
     rep._pdbshown = True
-    post_mortem(tb)
+    post_mortem(tb) 
     return rep
 
 
@@ -366,8 +366,8 @@ def _postmortem_traceback(excinfo):
 
 
 def post_mortem(t):
-    p = pytestPDB._init_pdb("post_mortem")
+    p = pytestPDB._init_pdb("post_mortem") 
     p.reset()
     p.interaction(None, t)
-    if p.quitting:
-        outcomes.exit("Quitting debugger")
+    if p.quitting: 
+        outcomes.exit("Quitting debugger")