ULTRA [ growontech.com ]

Linux premium216.web-hosting.com 4.18.0-513.18.1.lve.el8.x86_64 #1 SMP Thu Feb 22 12:55:50 UTC 2024 x86_64

LiteSpeed

66.29.141.148 | Your IP: 3.23.128.28

Cant read [ /etc/named.conf ]

[ drwxr-xr-x ]

/ opt / cloudlinux / venv / lib64 / python3.11 / site-packages / tap /

Home Upload Mass Deface Mass Delete Back Connect Notify

parser.py

from io import StringIO
import itertools
import re
import sys

from tap.directive import Directive
from tap.line import Bail, Diagnostic, Plan, Result, Unknown, Version

try:
    from more_itertools import peekable
    import yaml  # noqa

ENABLE_VERSION_13 = True
except ImportError:  # pragma: no cover
    ENABLE_VERSION_13 = False

class Parser(object):
    """A parser for TAP files and lines."""

# ok and not ok share most of the same characteristics.
    result_base = r"""
        \s*                    # Optional whitespace.
        (?P<number>\d*)        # Optional test number.
        \s*                    # Optional whitespace.
        (?P<description>[^#]*) # Optional description before #.
        \#?                    # Optional directive marker.
        \s*                    # Optional whitespace.
        (?P<directive>.*)      # Optional directive text.
    """
    ok = re.compile(r"^ok" + result_base, re.VERBOSE)
    not_ok = re.compile(r"^not\ ok" + result_base, re.VERBOSE)
    plan = re.compile(
        r"""
        ^1..(?P<expected>\d+) # Match the plan details.
        [^#]*                 # Consume any non-hash character to confirm only
                              # directives appear with the plan details.
        \#?                   # Optional directive marker.
        \s*                   # Optional whitespace.
        (?P<directive>.*)     # Optional directive text.
    """,
        re.VERBOSE,
    )
    diagnostic = re.compile(r"^#")
    bail = re.compile(
        r"""
        ^Bail\ out!
        \s*            # Optional whitespace.
        (?P<reason>.*) # Optional reason.
    """,
        re.VERBOSE,
    )
    version = re.compile(r"^TAP version (?P<version>\d+)$")

yaml_block_start = re.compile(r"^(?P<indent>\s+)-")
    yaml_block_end = re.compile(r"^\s+\.\.\.")

TAP_MINIMUM_DECLARED_VERSION = 13

def parse_file(self, filename):
        """Parse a TAP file to an iterable of tap.line.Line objects.

This is a generator method that will yield an object for each
        parsed line. The file given by `filename` is assumed to exist.
        """
        return self.parse(open(filename, "r"))

def parse_stdin(self):
        """Parse a TAP stream from standard input.

Note: this has the side effect of closing the standard input
        filehandle after parsing.
        """
        return self.parse(sys.stdin)

def parse_text(self, text):
        """Parse a string containing one or more lines of TAP output."""
        return self.parse(StringIO(text))

def parse(self, fh):
        """Generate tap.line.Line objects, given a file-like object `fh`.

`fh` may be any object that implements both the iterator and
        context management protocol (i.e. it can be used in both a
        "with" statement and a "for...in" statement.)

Trailing whitespace and newline characters will be automatically
        stripped from the input lines.
        """
        with fh:
            try:
                first_line = next(fh)
            except StopIteration:
                return
            first_parsed = self.parse_line(first_line.rstrip())
            fh_new = itertools.chain([first_line], fh)
            if first_parsed.category == "version" and first_parsed.version >= 13:
                if ENABLE_VERSION_13:
                    fh_new = peekable(itertools.chain([first_line], fh))
                else:  # pragma no cover
                    print(
                        """
WARNING: Optional imports not found, TAP 13 output will be
    ignored. To parse yaml, see requirements in docs:
    https://tappy.readthedocs.io/en/latest/consumers.html#tap-version-13"""
                    )

for line in fh_new:
                yield self.parse_line(line.rstrip(), fh_new)

def parse_line(self, text, fh=None):
        """Parse a line into whatever TAP category it belongs."""
        match = self.ok.match(text)
        if match:
            return self._parse_result(True, match, fh)

match = self.not_ok.match(text)
        if match:
            return self._parse_result(False, match, fh)

if self.diagnostic.match(text):
            return Diagnostic(text)

match = self.plan.match(text)
        if match:
            return self._parse_plan(match)

match = self.bail.match(text)
        if match:
            return Bail(match.group("reason"))

match = self.version.match(text)
        if match:
            return self._parse_version(match)

return Unknown()

def _parse_plan(self, match):
        """Parse a matching plan line."""
        expected_tests = int(match.group("expected"))
        directive = Directive(match.group("directive"))

# Only SKIP directives are allowed in the plan.
        if directive.text and not directive.skip:
            return Unknown()

return Plan(expected_tests, directive)

def _parse_result(self, ok, match, fh=None):
        """Parse a matching result line into a result instance."""
        peek_match = None
        try:
            if fh is not None and ENABLE_VERSION_13 and isinstance(fh, peekable):
                peek_match = self.yaml_block_start.match(fh.peek())
        except StopIteration:
            pass
        if peek_match is None:
            return Result(
                ok,
                number=match.group("number"),
                description=match.group("description").strip(),
                directive=Directive(match.group("directive")),
            )
        indent = peek_match.group("indent")
        concat_yaml = self._extract_yaml_block(indent, fh)
        return Result(
            ok,
            number=match.group("number"),
            description=match.group("description").strip(),
            directive=Directive(match.group("directive")),
            raw_yaml_block=concat_yaml,
        )

def _extract_yaml_block(self, indent, fh):
        """Extract a raw yaml block from a file handler"""
        raw_yaml = []
        indent_match = re.compile(r"^{}".format(indent))
        try:
            next(fh)
            while indent_match.match(fh.peek()):
                yaml_line = next(fh).replace(indent, "", 1)
                raw_yaml.append(yaml_line.rstrip("\n"))
                # check for the end and stop adding yaml if encountered
                if self.yaml_block_end.match(fh.peek()):
                    next(fh)
                    break
        except StopIteration:
            pass
        return "\n".join(raw_yaml)

def _parse_version(self, match):
        version = int(match.group("version"))
        if version < self.TAP_MINIMUM_DECLARED_VERSION:
            raise ValueError(
                "It is an error to explicitly specify any version lower than 13."
            )
        return Version(version)

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/root	drwxr-xr-x	2025-01-11 06:01:11
..	dir	-	root/root	drwxr-xr-x	2025-02-27 06:01:09
__pycache__	dir	-	root/root	drwxr-xr-x	2025-01-11 06:01:11
tests	dir	-	root/root	drwxr-xr-x	2025-01-11 06:01:11
__init__.py	text/x-script.python	83 B	root/root	-rw-r--r--	2024-12-18 10:23:15
__main__.py	text/x-script.python	48 B	root/root	-rw-r--r--	2024-12-18 10:23:15
adapter.py	text/x-script.python	1.51 KB	root/root	-rw-r--r--	2024-12-18 10:23:15
directive.py	text/x-script.python	1.76 KB	root/root	-rw-r--r--	2024-12-18 10:23:15
formatter.py	text/x-script.python	762 B	root/root	-rw-r--r--	2024-12-18 10:23:15
line.py	text/x-script.python	4.62 KB	root/root	-rw-r--r--	2024-12-18 10:23:15
loader.py	text/x-script.python	2.88 KB	root/root	-rw-r--r--	2024-12-18 10:23:15
main.py	text/x-script.python	2.07 KB	root/root	-rw-r--r--	2024-12-18 10:23:15
parser.py	text/x-script.python	6.7 KB	root/root	-rw-r--r--	2024-12-18 10:23:15
rules.py	text/x-script.python	3.39 KB	root/root	-rw-r--r--	2024-12-18 10:23:15
runner.py	text/x-script.python	5.08 KB	root/root	-rw-r--r--	2024-12-18 10:23:15
tracker.py	text/x-script.python	7.43 KB	root/root	-rw-r--r--	2024-12-18 10:23:15