@motiadev/core 0.2.1-beta.58 → 0.2.1-beta.60

package/python_modules/lib/python3.11/site-packages/pip/_vendor/pyparsing/testing.py

@@ -1,331 +0,0 @@
-# testing.py
-
-from contextlib import contextmanager
-import typing
-
-from .core import (
-    ParserElement,
-    ParseException,
-    Keyword,
-    __diag__,
-    __compat__,
-)
-
-
-class pyparsing_test:
-    """
-    namespace class for classes useful in writing unit tests
-    """
-
-    class reset_pyparsing_context:
-        """
-        Context manager to be used when writing unit tests that modify pyparsing config values:
-        - packrat parsing
-        - bounded recursion parsing
-        - default whitespace characters.
-        - default keyword characters
-        - literal string auto-conversion class
-        - __diag__ settings
-
-        Example::
-
-            with reset_pyparsing_context():
-                # test that literals used to construct a grammar are automatically suppressed
-                ParserElement.inlineLiteralsUsing(Suppress)
-
-                term = Word(alphas) | Word(nums)
-                group = Group('(' + term[...] + ')')
-
-                # assert that the '()' characters are not included in the parsed tokens
-                self.assertParseAndCheckList(group, "(abc 123 def)", ['abc', '123', 'def'])
-
-            # after exiting context manager, literals are converted to Literal expressions again
-        """
-
-        def __init__(self):
-            self._save_context = {}
-
-        def save(self):
-            self._save_context["default_whitespace"] = ParserElement.DEFAULT_WHITE_CHARS
-            self._save_context["default_keyword_chars"] = Keyword.DEFAULT_KEYWORD_CHARS
-
-            self._save_context[
-                "literal_string_class"
-            ] = ParserElement._literalStringClass
-
-            self._save_context["verbose_stacktrace"] = ParserElement.verbose_stacktrace
-
-            self._save_context["packrat_enabled"] = ParserElement._packratEnabled
-            if ParserElement._packratEnabled:
-                self._save_context[
-                    "packrat_cache_size"
-                ] = ParserElement.packrat_cache.size
-            else:
-                self._save_context["packrat_cache_size"] = None
-            self._save_context["packrat_parse"] = ParserElement._parse
-            self._save_context[
-                "recursion_enabled"
-            ] = ParserElement._left_recursion_enabled
-
-            self._save_context["__diag__"] = {
-                name: getattr(__diag__, name) for name in __diag__._all_names
-            }
-
-            self._save_context["__compat__"] = {
-                "collect_all_And_tokens": __compat__.collect_all_And_tokens
-            }
-
-            return self
-
-        def restore(self):
-            # reset pyparsing global state
-            if (
-                ParserElement.DEFAULT_WHITE_CHARS
-                != self._save_context["default_whitespace"]
-            ):
-                ParserElement.set_default_whitespace_chars(
-                    self._save_context["default_whitespace"]
-                )
-
-            ParserElement.verbose_stacktrace = self._save_context["verbose_stacktrace"]
-
-            Keyword.DEFAULT_KEYWORD_CHARS = self._save_context["default_keyword_chars"]
-            ParserElement.inlineLiteralsUsing(
-                self._save_context["literal_string_class"]
-            )
-
-            for name, value in self._save_context["__diag__"].items():
-                (__diag__.enable if value else __diag__.disable)(name)
-
-            ParserElement._packratEnabled = False
-            if self._save_context["packrat_enabled"]:
-                ParserElement.enable_packrat(self._save_context["packrat_cache_size"])
-            else:
-                ParserElement._parse = self._save_context["packrat_parse"]
-            ParserElement._left_recursion_enabled = self._save_context[
-                "recursion_enabled"
-            ]
-
-            __compat__.collect_all_And_tokens = self._save_context["__compat__"]
-
-            return self
-
-        def copy(self):
-            ret = type(self)()
-            ret._save_context.update(self._save_context)
-            return ret
-
-        def __enter__(self):
-            return self.save()
-
-        def __exit__(self, *args):
-            self.restore()
-
-    class TestParseResultsAsserts:
-        """
-        A mixin class to add parse results assertion methods to normal unittest.TestCase classes.
-        """
-
-        def assertParseResultsEquals(
-            self, result, expected_list=None, expected_dict=None, msg=None
-        ):
-            """
-            Unit test assertion to compare a :class:`ParseResults` object with an optional ``expected_list``,
-            and compare any defined results names with an optional ``expected_dict``.
-            """
-            if expected_list is not None:
-                self.assertEqual(expected_list, result.as_list(), msg=msg)
-            if expected_dict is not None:
-                self.assertEqual(expected_dict, result.as_dict(), msg=msg)
-
-        def assertParseAndCheckList(
-            self, expr, test_string, expected_list, msg=None, verbose=True
-        ):
-            """
-            Convenience wrapper assert to test a parser element and input string, and assert that
-            the resulting ``ParseResults.asList()`` is equal to the ``expected_list``.
-            """
-            result = expr.parse_string(test_string, parse_all=True)
-            if verbose:
-                print(result.dump())
-            else:
-                print(result.as_list())
-            self.assertParseResultsEquals(result, expected_list=expected_list, msg=msg)
-
-        def assertParseAndCheckDict(
-            self, expr, test_string, expected_dict, msg=None, verbose=True
-        ):
-            """
-            Convenience wrapper assert to test a parser element and input string, and assert that
-            the resulting ``ParseResults.asDict()`` is equal to the ``expected_dict``.
-            """
-            result = expr.parse_string(test_string, parseAll=True)
-            if verbose:
-                print(result.dump())
-            else:
-                print(result.as_list())
-            self.assertParseResultsEquals(result, expected_dict=expected_dict, msg=msg)
-
-        def assertRunTestResults(
-            self, run_tests_report, expected_parse_results=None, msg=None
-        ):
-            """
-            Unit test assertion to evaluate output of ``ParserElement.runTests()``. If a list of
-            list-dict tuples is given as the ``expected_parse_results`` argument, then these are zipped
-            with the report tuples returned by ``runTests`` and evaluated using ``assertParseResultsEquals``.
-            Finally, asserts that the overall ``runTests()`` success value is ``True``.
-
-            :param run_tests_report: tuple(bool, [tuple(str, ParseResults or Exception)]) returned from runTests
-            :param expected_parse_results (optional): [tuple(str, list, dict, Exception)]
-            """
-            run_test_success, run_test_results = run_tests_report
-
-            if expected_parse_results is not None:
-                merged = [
-                    (*rpt, expected)
-                    for rpt, expected in zip(run_test_results, expected_parse_results)
-                ]
-                for test_string, result, expected in merged:
-                    # expected should be a tuple containing a list and/or a dict or an exception,
-                    # and optional failure message string
-                    # an empty tuple will skip any result validation
-                    fail_msg = next(
-                        (exp for exp in expected if isinstance(exp, str)), None
-                    )
-                    expected_exception = next(
-                        (
-                            exp
-                            for exp in expected
-                            if isinstance(exp, type) and issubclass(exp, Exception)
-                        ),
-                        None,
-                    )
-                    if expected_exception is not None:
-                        with self.assertRaises(
-                            expected_exception=expected_exception, msg=fail_msg or msg
-                        ):
-                            if isinstance(result, Exception):
-                                raise result
-                    else:
-                        expected_list = next(
-                            (exp for exp in expected if isinstance(exp, list)), None
-                        )
-                        expected_dict = next(
-                            (exp for exp in expected if isinstance(exp, dict)), None
-                        )
-                        if (expected_list, expected_dict) != (None, None):
-                            self.assertParseResultsEquals(
-                                result,
-                                expected_list=expected_list,
-                                expected_dict=expected_dict,
-                                msg=fail_msg or msg,
-                            )
-                        else:
-                            # warning here maybe?
-                            print(f"no validation for {test_string!r}")
-
-            # do this last, in case some specific test results can be reported instead
-            self.assertTrue(
-                run_test_success, msg=msg if msg is not None else "failed runTests"
-            )
-
-        @contextmanager
-        def assertRaisesParseException(self, exc_type=ParseException, msg=None):
-            with self.assertRaises(exc_type, msg=msg):
-                yield
-
-    @staticmethod
-    def with_line_numbers(
-        s: str,
-        start_line: typing.Optional[int] = None,
-        end_line: typing.Optional[int] = None,
-        expand_tabs: bool = True,
-        eol_mark: str = "|",
-        mark_spaces: typing.Optional[str] = None,
-        mark_control: typing.Optional[str] = None,
-    ) -> str:
-        """
-        Helpful method for debugging a parser - prints a string with line and column numbers.
-        (Line and column numbers are 1-based.)
-
-        :param s: tuple(bool, str - string to be printed with line and column numbers
-        :param start_line: int - (optional) starting line number in s to print (default=1)
-        :param end_line: int - (optional) ending line number in s to print (default=len(s))
-        :param expand_tabs: bool - (optional) expand tabs to spaces, to match the pyparsing default
-        :param eol_mark: str - (optional) string to mark the end of lines, helps visualize trailing spaces (default="|")
-        :param mark_spaces: str - (optional) special character to display in place of spaces
-        :param mark_control: str - (optional) convert non-printing control characters to a placeholding
-                                 character; valid values:
-                                 - "unicode" - replaces control chars with Unicode symbols, such as "␍" and "␊"
-                                 - any single character string - replace control characters with given string
-                                 - None (default) - string is displayed as-is
-
-        :return: str - input string with leading line numbers and column number headers
-        """
-        if expand_tabs:
-            s = s.expandtabs()
-        if mark_control is not None:
-            mark_control = typing.cast(str, mark_control)
-            if mark_control == "unicode":
-                transtable_map = {
-                    c: u for c, u in zip(range(0, 33), range(0x2400, 0x2433))
-                }
-                transtable_map[127] = 0x2421
-                tbl = str.maketrans(transtable_map)
-                eol_mark = ""
-            else:
-                ord_mark_control = ord(mark_control)
-                tbl = str.maketrans(
-                    {c: ord_mark_control for c in list(range(0, 32)) + [127]}
-                )
-            s = s.translate(tbl)
-        if mark_spaces is not None and mark_spaces != " ":
-            if mark_spaces == "unicode":
-                tbl = str.maketrans({9: 0x2409, 32: 0x2423})
-                s = s.translate(tbl)
-            else:
-                s = s.replace(" ", mark_spaces)
-        if start_line is None:
-            start_line = 1
-        if end_line is None:
-            end_line = len(s)
-        end_line = min(end_line, len(s))
-        start_line = min(max(1, start_line), end_line)
-
-        if mark_control != "unicode":
-            s_lines = s.splitlines()[start_line - 1 : end_line]
-        else:
-            s_lines = [line + "␊" for line in s.split("␊")[start_line - 1 : end_line]]
-        if not s_lines:
-            return ""
-
-        lineno_width = len(str(end_line))
-        max_line_len = max(len(line) for line in s_lines)
-        lead = " " * (lineno_width + 1)
-        if max_line_len >= 99:
-            header0 = (
-                lead
-                + "".join(
-                    f"{' ' * 99}{(i + 1) % 100}"
-                    for i in range(max(max_line_len // 100, 1))
-                )
-                + "\n"
-            )
-        else:
-            header0 = ""
-        header1 = (
-            header0
-            + lead
-            + "".join(f"         {(i + 1) % 10}" for i in range(-(-max_line_len // 10)))
-            + "\n"
-        )
-        header2 = lead + "1234567890" * (-(-max_line_len // 10)) + "\n"
-        return (
-            header1
-            + header2
-            + "\n".join(
-                f"{i:{lineno_width}d}:{line}{eol_mark}"
-                for i, line in enumerate(s_lines, start=start_line)
-            )
-            + "\n"
-        )

package/python_modules/lib/python3.11/site-packages/pip/_vendor/pyparsing/unicode.py

@@ -1,361 +0,0 @@
-# unicode.py
-
-import sys
-from itertools import filterfalse
-from typing import List, Tuple, Union
-
-
-class _lazyclassproperty:
-    def __init__(self, fn):
-        self.fn = fn
-        self.__doc__ = fn.__doc__
-        self.__name__ = fn.__name__
-
-    def __get__(self, obj, cls):
-        if cls is None:
-            cls = type(obj)
-        if not hasattr(cls, "_intern") or any(
-            cls._intern is getattr(superclass, "_intern", [])
-            for superclass in cls.__mro__[1:]
-        ):
-            cls._intern = {}
-        attrname = self.fn.__name__
-        if attrname not in cls._intern:
-            cls._intern[attrname] = self.fn(cls)
-        return cls._intern[attrname]
-
-
-UnicodeRangeList = List[Union[Tuple[int, int], Tuple[int]]]
-
-
-class unicode_set:
-    """
-    A set of Unicode characters, for language-specific strings for
-    ``alphas``, ``nums``, ``alphanums``, and ``printables``.
-    A unicode_set is defined by a list of ranges in the Unicode character
-    set, in a class attribute ``_ranges``. Ranges can be specified using
-    2-tuples or a 1-tuple, such as::
-
-        _ranges = [
-            (0x0020, 0x007e),
-            (0x00a0, 0x00ff),
-            (0x0100,),
-            ]
-
-    Ranges are left- and right-inclusive. A 1-tuple of (x,) is treated as (x, x).
-
-    A unicode set can also be defined using multiple inheritance of other unicode sets::
-
-        class CJK(Chinese, Japanese, Korean):
-            pass
-    """
-
-    _ranges: UnicodeRangeList = []
-
-    @_lazyclassproperty
-    def _chars_for_ranges(cls):
-        ret = []
-        for cc in cls.__mro__:
-            if cc is unicode_set:
-                break
-            for rr in getattr(cc, "_ranges", ()):
-                ret.extend(range(rr[0], rr[-1] + 1))
-        return [chr(c) for c in sorted(set(ret))]
-
-    @_lazyclassproperty
-    def printables(cls):
-        """all non-whitespace characters in this range"""
-        return "".join(filterfalse(str.isspace, cls._chars_for_ranges))
-
-    @_lazyclassproperty
-    def alphas(cls):
-        """all alphabetic characters in this range"""
-        return "".join(filter(str.isalpha, cls._chars_for_ranges))
-
-    @_lazyclassproperty
-    def nums(cls):
-        """all numeric digit characters in this range"""
-        return "".join(filter(str.isdigit, cls._chars_for_ranges))
-
-    @_lazyclassproperty
-    def alphanums(cls):
-        """all alphanumeric characters in this range"""
-        return cls.alphas + cls.nums
-
-    @_lazyclassproperty
-    def identchars(cls):
-        """all characters in this range that are valid identifier characters, plus underscore '_'"""
-        return "".join(
-            sorted(
-                set(
-                    "".join(filter(str.isidentifier, cls._chars_for_ranges))
-                    + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzªµº"
-                    + "ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ"
-                    + "_"
-                )
-            )
-        )
-
-    @_lazyclassproperty
-    def identbodychars(cls):
-        """
-        all characters in this range that are valid identifier body characters,
-        plus the digits 0-9, and · (Unicode MIDDLE DOT)
-        """
-        return "".join(
-            sorted(
-                set(
-                    cls.identchars
-                    + "0123456789·"
-                    + "".join(
-                        [c for c in cls._chars_for_ranges if ("_" + c).isidentifier()]
-                    )
-                )
-            )
-        )
-
-    @_lazyclassproperty
-    def identifier(cls):
-        """
-        a pyparsing Word expression for an identifier using this range's definitions for
-        identchars and identbodychars
-        """
-        from pip._vendor.pyparsing import Word
-
-        return Word(cls.identchars, cls.identbodychars)
-
-
-class pyparsing_unicode(unicode_set):
-    """
-    A namespace class for defining common language unicode_sets.
-    """
-
-    # fmt: off
-
-    # define ranges in language character sets
-    _ranges: UnicodeRangeList = [
-        (0x0020, sys.maxunicode),
-    ]
-
-    class BasicMultilingualPlane(unicode_set):
-        """Unicode set for the Basic Multilingual Plane"""
-        _ranges: UnicodeRangeList = [
-            (0x0020, 0xFFFF),
-        ]
-
-    class Latin1(unicode_set):
-        """Unicode set for Latin-1 Unicode Character Range"""
-        _ranges: UnicodeRangeList = [
-            (0x0020, 0x007E),
-            (0x00A0, 0x00FF),
-        ]
-
-    class LatinA(unicode_set):
-        """Unicode set for Latin-A Unicode Character Range"""
-        _ranges: UnicodeRangeList = [
-            (0x0100, 0x017F),
-        ]
-
-    class LatinB(unicode_set):
-        """Unicode set for Latin-B Unicode Character Range"""
-        _ranges: UnicodeRangeList = [
-            (0x0180, 0x024F),
-        ]
-
-    class Greek(unicode_set):
-        """Unicode set for Greek Unicode Character Ranges"""
-        _ranges: UnicodeRangeList = [
-            (0x0342, 0x0345),
-            (0x0370, 0x0377),
-            (0x037A, 0x037F),
-            (0x0384, 0x038A),
-            (0x038C,),
-            (0x038E, 0x03A1),
-            (0x03A3, 0x03E1),
-            (0x03F0, 0x03FF),
-            (0x1D26, 0x1D2A),
-            (0x1D5E,),
-            (0x1D60,),
-            (0x1D66, 0x1D6A),
-            (0x1F00, 0x1F15),
-            (0x1F18, 0x1F1D),
-            (0x1F20, 0x1F45),
-            (0x1F48, 0x1F4D),
-            (0x1F50, 0x1F57),
-            (0x1F59,),
-            (0x1F5B,),
-            (0x1F5D,),
-            (0x1F5F, 0x1F7D),
-            (0x1F80, 0x1FB4),
-            (0x1FB6, 0x1FC4),
-            (0x1FC6, 0x1FD3),
-            (0x1FD6, 0x1FDB),
-            (0x1FDD, 0x1FEF),
-            (0x1FF2, 0x1FF4),
-            (0x1FF6, 0x1FFE),
-            (0x2129,),
-            (0x2719, 0x271A),
-            (0xAB65,),
-            (0x10140, 0x1018D),
-            (0x101A0,),
-            (0x1D200, 0x1D245),
-            (0x1F7A1, 0x1F7A7),
-        ]
-
-    class Cyrillic(unicode_set):
-        """Unicode set for Cyrillic Unicode Character Range"""
-        _ranges: UnicodeRangeList = [
-            (0x0400, 0x052F),
-            (0x1C80, 0x1C88),
-            (0x1D2B,),
-            (0x1D78,),
-            (0x2DE0, 0x2DFF),
-            (0xA640, 0xA672),
-            (0xA674, 0xA69F),
-            (0xFE2E, 0xFE2F),
-        ]
-
-    class Chinese(unicode_set):
-        """Unicode set for Chinese Unicode Character Range"""
-        _ranges: UnicodeRangeList = [
-            (0x2E80, 0x2E99),
-            (0x2E9B, 0x2EF3),
-            (0x31C0, 0x31E3),
-            (0x3400, 0x4DB5),
-            (0x4E00, 0x9FEF),
-            (0xA700, 0xA707),
-            (0xF900, 0xFA6D),
-            (0xFA70, 0xFAD9),
-            (0x16FE2, 0x16FE3),
-            (0x1F210, 0x1F212),
-            (0x1F214, 0x1F23B),
-            (0x1F240, 0x1F248),
-            (0x20000, 0x2A6D6),
-            (0x2A700, 0x2B734),
-            (0x2B740, 0x2B81D),
-            (0x2B820, 0x2CEA1),
-            (0x2CEB0, 0x2EBE0),
-            (0x2F800, 0x2FA1D),
-        ]
-
-    class Japanese(unicode_set):
-        """Unicode set for Japanese Unicode Character Range, combining Kanji, Hiragana, and Katakana ranges"""
-
-        class Kanji(unicode_set):
-            "Unicode set for Kanji Unicode Character Range"
-            _ranges: UnicodeRangeList = [
-                (0x4E00, 0x9FBF),
-                (0x3000, 0x303F),
-            ]
-
-        class Hiragana(unicode_set):
-            """Unicode set for Hiragana Unicode Character Range"""
-            _ranges: UnicodeRangeList = [
-                (0x3041, 0x3096),
-                (0x3099, 0x30A0),
-                (0x30FC,),
-                (0xFF70,),
-                (0x1B001,),
-                (0x1B150, 0x1B152),
-                (0x1F200,),
-            ]
-
-        class Katakana(unicode_set):
-            """Unicode set for Katakana  Unicode Character Range"""
-            _ranges: UnicodeRangeList = [
-                (0x3099, 0x309C),
-                (0x30A0, 0x30FF),
-                (0x31F0, 0x31FF),
-                (0x32D0, 0x32FE),
-                (0xFF65, 0xFF9F),
-                (0x1B000,),
-                (0x1B164, 0x1B167),
-                (0x1F201, 0x1F202),
-                (0x1F213,),
-            ]
-
-        漢字 = Kanji
-        カタカナ = Katakana
-        ひらがな = Hiragana
-
-        _ranges = (
-            Kanji._ranges
-            + Hiragana._ranges
-            + Katakana._ranges
-        )
-
-    class Hangul(unicode_set):
-        """Unicode set for Hangul (Korean) Unicode Character Range"""
-        _ranges: UnicodeRangeList = [
-            (0x1100, 0x11FF),
-            (0x302E, 0x302F),
-            (0x3131, 0x318E),
-            (0x3200, 0x321C),
-            (0x3260, 0x327B),
-            (0x327E,),
-            (0xA960, 0xA97C),
-            (0xAC00, 0xD7A3),
-            (0xD7B0, 0xD7C6),
-            (0xD7CB, 0xD7FB),
-            (0xFFA0, 0xFFBE),
-            (0xFFC2, 0xFFC7),
-            (0xFFCA, 0xFFCF),
-            (0xFFD2, 0xFFD7),
-            (0xFFDA, 0xFFDC),
-        ]
-
-    Korean = Hangul
-
-    class CJK(Chinese, Japanese, Hangul):
-        """Unicode set for combined Chinese, Japanese, and Korean (CJK) Unicode Character Range"""
-
-    class Thai(unicode_set):
-        """Unicode set for Thai Unicode Character Range"""
-        _ranges: UnicodeRangeList = [
-            (0x0E01, 0x0E3A),
-            (0x0E3F, 0x0E5B)
-        ]
-
-    class Arabic(unicode_set):
-        """Unicode set for Arabic Unicode Character Range"""
-        _ranges: UnicodeRangeList = [
-            (0x0600, 0x061B),
-            (0x061E, 0x06FF),
-            (0x0700, 0x077F),
-        ]
-
-    class Hebrew(unicode_set):
-        """Unicode set for Hebrew Unicode Character Range"""
-        _ranges: UnicodeRangeList = [
-            (0x0591, 0x05C7),
-            (0x05D0, 0x05EA),
-            (0x05EF, 0x05F4),
-            (0xFB1D, 0xFB36),
-            (0xFB38, 0xFB3C),
-            (0xFB3E,),
-            (0xFB40, 0xFB41),
-            (0xFB43, 0xFB44),
-            (0xFB46, 0xFB4F),
-        ]
-
-    class Devanagari(unicode_set):
-        """Unicode set for Devanagari Unicode Character Range"""
-        _ranges: UnicodeRangeList = [
-            (0x0900, 0x097F),
-            (0xA8E0, 0xA8FF)
-        ]
-
-    BMP = BasicMultilingualPlane
-
-    # add language identifiers using language Unicode
-    العربية = Arabic
-    中文 = Chinese
-    кириллица = Cyrillic
-    Ελληνικά = Greek
-    עִברִית = Hebrew
-    日本語 = Japanese
-    한국어 = Korean
-    ไทย = Thai
-    देवनागरी = Devanagari
-
-    # fmt: on