fix ya.make

1 files changed, 0 insertions, 435 deletions

diff --git a/contrib/python/pytest/py2/_pytest/reports.py b/contrib/python/pytest/py2/_pytest/reports.py
deleted file mode 100644
index 0bba6762c3..0000000000
--- a/contrib/python/pytest/py2/_pytest/reports.py
+++ /dev/null
@@ -1,435 +0,0 @@
-# -*- coding: utf-8 -*-
-from pprint import pprint
-
-import py
-import six
-
-from _pytest._code.code import ExceptionInfo
-from _pytest._code.code import ReprEntry
-from _pytest._code.code import ReprEntryNative
-from _pytest._code.code import ReprExceptionInfo
-from _pytest._code.code import ReprFileLocation
-from _pytest._code.code import ReprFuncArgs
-from _pytest._code.code import ReprLocals
-from _pytest._code.code import ReprTraceback
-from _pytest._code.code import TerminalRepr
-from _pytest.outcomes import skip
-from _pytest.pathlib import Path
-
-
-def getslaveinfoline(node):
-    try:
-        return node._slaveinfocache
-    except AttributeError:
-        d = node.slaveinfo
-        ver = "%s.%s.%s" % d["version_info"][:3]
-        node._slaveinfocache = s = "[%s] %s -- Python %s %s" % (
-            d["id"],
-            d["sysplatform"],
-            ver,
-            d["executable"],
-        )
-        return s
-
-
-class BaseReport(object):
-    when = None
-    location = None
-
-    def __init__(self, **kw):
-        self.__dict__.update(kw)
-
-    def toterminal(self, out):
-        if hasattr(self, "node"):
-            out.line(getslaveinfoline(self.node))
-
-        longrepr = self.longrepr
-        if longrepr is None:
-            return
-
-        if hasattr(longrepr, "toterminal"):
-            longrepr.toterminal(out)
-        else:
-            try:
-                out.line(longrepr)
-            except UnicodeEncodeError:
-                out.line("<unprintable longrepr>")
-
-    def get_sections(self, prefix):
-        for name, content in self.sections:
-            if name.startswith(prefix):
-                yield prefix, content
-
-    @property
-    def longreprtext(self):
-        """
-        Read-only property that returns the full string representation
-        of ``longrepr``.
-
-        .. versionadded:: 3.0
-        """
-        tw = py.io.TerminalWriter(stringio=True)
-        tw.hasmarkup = False
-        self.toterminal(tw)
-        exc = tw.stringio.getvalue()
-        return exc.strip()
-
-    @property
-    def caplog(self):
-        """Return captured log lines, if log capturing is enabled
-
-        .. versionadded:: 3.5
-        """
-        return "\n".join(
-            content for (prefix, content) in self.get_sections("Captured log")
-        )
-
-    @property
-    def capstdout(self):
-        """Return captured text from stdout, if capturing is enabled
-
-        .. versionadded:: 3.0
-        """
-        return "".join(
-            content for (prefix, content) in self.get_sections("Captured stdout")
-        )
-
-    @property
-    def capstderr(self):
-        """Return captured text from stderr, if capturing is enabled
-
-        .. versionadded:: 3.0
-        """
-        return "".join(
-            content for (prefix, content) in self.get_sections("Captured stderr")
-        )
-
-    passed = property(lambda x: x.outcome == "passed")
-    failed = property(lambda x: x.outcome == "failed")
-    skipped = property(lambda x: x.outcome == "skipped")
-
-    @property
-    def fspath(self):
-        return self.nodeid.split("::")[0]
-
-    @property
-    def count_towards_summary(self):
-        """
-        **Experimental**
-
-        Returns True if this report should be counted towards the totals shown at the end of the
-        test session: "1 passed, 1 failure, etc".
-
-        .. note::
-
-            This function is considered **experimental**, so beware that it is subject to changes
-            even in patch releases.
-        """
-        return True
-
-    @property
-    def head_line(self):
-        """
-        **Experimental**
-
-        Returns the head line shown with longrepr output for this report, more commonly during
-        traceback representation during failures::
-
-            ________ Test.foo ________
-
-
-        In the example above, the head_line is "Test.foo".
-
-        .. note::
-
-            This function is considered **experimental**, so beware that it is subject to changes
-            even in patch releases.
-        """
-        if self.location is not None:
-            fspath, lineno, domain = self.location
-            return domain
-
-    def _get_verbose_word(self, config):
-        _category, _short, verbose = config.hook.pytest_report_teststatus(
-            report=self, config=config
-        )
-        return verbose
-
-    def _to_json(self):
-        """
-        This was originally the serialize_report() function from xdist (ca03269).
-
-        Returns the contents of this report as a dict of builtin entries, suitable for
-        serialization.
-
-        Experimental method.
-        """
-
-        def disassembled_report(rep):
-            reprtraceback = rep.longrepr.reprtraceback.__dict__.copy()
-            reprcrash = rep.longrepr.reprcrash.__dict__.copy()
-
-            new_entries = []
-            for entry in reprtraceback["reprentries"]:
-                entry_data = {
-                    "type": type(entry).__name__,
-                    "data": entry.__dict__.copy(),
-                }
-                for key, value in entry_data["data"].items():
-                    if hasattr(value, "__dict__"):
-                        entry_data["data"][key] = value.__dict__.copy()
-                new_entries.append(entry_data)
-
-            reprtraceback["reprentries"] = new_entries
-
-            return {
-                "reprcrash": reprcrash,
-                "reprtraceback": reprtraceback,
-                "sections": rep.longrepr.sections,
-            }
-
-        d = self.__dict__.copy()
-        if hasattr(self.longrepr, "toterminal"):
-            if hasattr(self.longrepr, "reprtraceback") and hasattr(
-                self.longrepr, "reprcrash"
-            ):
-                d["longrepr"] = disassembled_report(self)
-            else:
-                d["longrepr"] = six.text_type(self.longrepr)
-        else:
-            d["longrepr"] = self.longrepr
-        for name in d:
-            if isinstance(d[name], (py.path.local, Path)):
-                d[name] = str(d[name])
-            elif name == "result":
-                d[name] = None  # for now
-        return d
-
-    @classmethod
-    def _from_json(cls, reportdict):
-        """
-        This was originally the serialize_report() function from xdist (ca03269).
-
-        Factory method that returns either a TestReport or CollectReport, depending on the calling
-        class. It's the callers responsibility to know which class to pass here.
-
-        Experimental method.
-        """
-        if reportdict["longrepr"]:
-            if (
-                "reprcrash" in reportdict["longrepr"]
-                and "reprtraceback" in reportdict["longrepr"]
-            ):
-
-                reprtraceback = reportdict["longrepr"]["reprtraceback"]
-                reprcrash = reportdict["longrepr"]["reprcrash"]
-
-                unserialized_entries = []
-                reprentry = None
-                for entry_data in reprtraceback["reprentries"]:
-                    data = entry_data["data"]
-                    entry_type = entry_data["type"]
-                    if entry_type == "ReprEntry":
-                        reprfuncargs = None
-                        reprfileloc = None
-                        reprlocals = None
-                        if data["reprfuncargs"]:
-                            reprfuncargs = ReprFuncArgs(**data["reprfuncargs"])
-                        if data["reprfileloc"]:
-                            reprfileloc = ReprFileLocation(**data["reprfileloc"])
-                        if data["reprlocals"]:
-                            reprlocals = ReprLocals(data["reprlocals"]["lines"])
-
-                        reprentry = ReprEntry(
-                            lines=data["lines"],
-                            reprfuncargs=reprfuncargs,
-                            reprlocals=reprlocals,
-                            filelocrepr=reprfileloc,
-                            style=data["style"],
-                        )
-                    elif entry_type == "ReprEntryNative":
-                        reprentry = ReprEntryNative(data["lines"])
-                    else:
-                        _report_unserialization_failure(entry_type, cls, reportdict)
-                    unserialized_entries.append(reprentry)
-                reprtraceback["reprentries"] = unserialized_entries
-
-                exception_info = ReprExceptionInfo(
-                    reprtraceback=ReprTraceback(**reprtraceback),
-                    reprcrash=ReprFileLocation(**reprcrash),
-                )
-
-                for section in reportdict["longrepr"]["sections"]:
-                    exception_info.addsection(*section)
-                reportdict["longrepr"] = exception_info
-
-        return cls(**reportdict)
-
-
-def _report_unserialization_failure(type_name, report_class, reportdict):
-    url = "https://github.com/pytest-dev/pytest/issues"
-    stream = py.io.TextIO()
-    pprint("-" * 100, stream=stream)
-    pprint("INTERNALERROR: Unknown entry type returned: %s" % type_name, stream=stream)
-    pprint("report_name: %s" % report_class, stream=stream)
-    pprint(reportdict, stream=stream)
-    pprint("Please report this bug at %s" % url, stream=stream)
-    pprint("-" * 100, stream=stream)
-    raise RuntimeError(stream.getvalue())
-
-
-class TestReport(BaseReport):
-    """ Basic test report object (also used for setup and teardown calls if
-    they fail).
-    """
-
-    __test__ = False
-
-    def __init__(
-        self,
-        nodeid,
-        location,
-        keywords,
-        outcome,
-        longrepr,
-        when,
-        sections=(),
-        duration=0,
-        user_properties=None,
-        **extra
-    ):
-        #: normalized collection node id
-        self.nodeid = nodeid
-
-        #: a (filesystempath, lineno, domaininfo) tuple indicating the
-        #: actual location of a test item - it might be different from the
-        #: collected one e.g. if a method is inherited from a different module.
-        self.location = location
-
-        #: a name -> value dictionary containing all keywords and
-        #: markers associated with a test invocation.
-        self.keywords = keywords
-
-        #: test outcome, always one of "passed", "failed", "skipped".
-        self.outcome = outcome
-
-        #: None or a failure representation.
-        self.longrepr = longrepr
-
-        #: one of 'setup', 'call', 'teardown' to indicate runtest phase.
-        self.when = when
-
-        #: user properties is a list of tuples (name, value) that holds user
-        #: defined properties of the test
-        self.user_properties = list(user_properties or [])
-
-        #: list of pairs ``(str, str)`` of extra information which needs to
-        #: marshallable. Used by pytest to add captured text
-        #: from ``stdout`` and ``stderr``, but may be used by other plugins
-        #: to add arbitrary information to reports.
-        self.sections = list(sections)
-
-        #: time it took to run just the test
-        self.duration = duration
-
-        self.__dict__.update(extra)
-
-    def __repr__(self):
-        return "<%s %r when=%r outcome=%r>" % (
-            self.__class__.__name__,
-            self.nodeid,
-            self.when,
-            self.outcome,
-        )
-
-    @classmethod
-    def from_item_and_call(cls, item, call):
-        """
-        Factory method to create and fill a TestReport with standard item and call info.
-        """
-        when = call.when
-        duration = call.stop - call.start
-        keywords = {x: 1 for x in item.keywords}
-        excinfo = call.excinfo
-        sections = []
-        if not call.excinfo:
-            outcome = "passed"
-            longrepr = None
-        else:
-            if not isinstance(excinfo, ExceptionInfo):
-                outcome = "failed"
-                longrepr = excinfo
-            elif excinfo.errisinstance(skip.Exception):
-                outcome = "skipped"
-                r = excinfo._getreprcrash()
-                longrepr = (str(r.path), r.lineno, r.message)
-            else:
-                outcome = "failed"
-                if call.when == "call":
-                    longrepr = item.repr_failure(excinfo)
-                else:  # exception in setup or teardown
-                    longrepr = item._repr_failure_py(
-                        excinfo, style=item.config.getoption("tbstyle", "auto")
-                    )
-        for rwhen, key, content in item._report_sections:
-            sections.append(("Captured %s %s" % (key, rwhen), content))
-        return cls(
-            item.nodeid,
-            item.location,
-            keywords,
-            outcome,
-            longrepr,
-            when,
-            sections,
-            duration,
-            user_properties=item.user_properties,
-        )
-
-
-class CollectReport(BaseReport):
-    when = "collect"
-
-    def __init__(self, nodeid, outcome, longrepr, result, sections=(), **extra):
-        self.nodeid = nodeid
-        self.outcome = outcome
-        self.longrepr = longrepr
-        self.result = result or []
-        self.sections = list(sections)
-        self.__dict__.update(extra)
-
-    @property
-    def location(self):
-        return (self.fspath, None, self.fspath)
-
-    def __repr__(self):
-        return "<CollectReport %r lenresult=%s outcome=%r>" % (
-            self.nodeid,
-            len(self.result),
-            self.outcome,
-        )
-
-
-class CollectErrorRepr(TerminalRepr):
-    def __init__(self, msg):
-        self.longrepr = msg
-
-    def toterminal(self, out):
-        out.line(self.longrepr, red=True)
-
-
-def pytest_report_to_serializable(report):
-    if isinstance(report, (TestReport, CollectReport)):
-        data = report._to_json()
-        data["_report_type"] = report.__class__.__name__
-        return data
-
-
-def pytest_report_from_serializable(data):
-    if "_report_type" in data:
-        if data["_report_type"] == "TestReport":
-            return TestReport._from_json(data)
-        elif data["_report_type"] == "CollectReport":
-            return CollectReport._from_json(data)
-        assert False, "Unknown report_type unserialize data: {}".format(
-            data["_report_type"]
-        )