@motiadev/core 0.2.1-beta.57 → 0.2.1-beta.59

package/python_modules/lib/python3.11/site-packages/jsonschema/tests/test_format.py

@@ -1,91 +0,0 @@
-"""
-Tests for the parts of jsonschema related to the :kw:`format` keyword.
-"""
-
-from unittest import TestCase
-
-from jsonschema import FormatChecker, ValidationError
-from jsonschema.exceptions import FormatError
-from jsonschema.validators import Draft4Validator
-
-BOOM = ValueError("Boom!")
-BANG = ZeroDivisionError("Bang!")
-
-
-def boom(thing):
-    if thing == "bang":
-        raise BANG
-    raise BOOM
-
-
-class TestFormatChecker(TestCase):
-    def test_it_can_validate_no_formats(self):
-        checker = FormatChecker(formats=())
-        self.assertFalse(checker.checkers)
-
-    def test_it_raises_a_key_error_for_unknown_formats(self):
-        with self.assertRaises(KeyError):
-            FormatChecker(formats=["o noes"])
-
-    def test_it_can_register_cls_checkers(self):
-        original = dict(FormatChecker.checkers)
-        self.addCleanup(FormatChecker.checkers.pop, "boom")
-        with self.assertWarns(DeprecationWarning):
-            FormatChecker.cls_checks("boom")(boom)
-        self.assertEqual(
-            FormatChecker.checkers,
-            dict(original, boom=(boom, ())),
-        )
-
-    def test_it_can_register_checkers(self):
-        checker = FormatChecker()
-        checker.checks("boom")(boom)
-        self.assertEqual(
-            checker.checkers,
-            dict(FormatChecker.checkers, boom=(boom, ())),
-        )
-
-    def test_it_catches_registered_errors(self):
-        checker = FormatChecker()
-        checker.checks("boom", raises=type(BOOM))(boom)
-
-        with self.assertRaises(FormatError) as cm:
-            checker.check(instance=12, format="boom")
-
-        self.assertIs(cm.exception.cause, BOOM)
-        self.assertIs(cm.exception.__cause__, BOOM)
-        self.assertEqual(str(cm.exception), "12 is not a 'boom'")
-
-        # Unregistered errors should not be caught
-        with self.assertRaises(type(BANG)):
-            checker.check(instance="bang", format="boom")
-
-    def test_format_error_causes_become_validation_error_causes(self):
-        checker = FormatChecker()
-        checker.checks("boom", raises=ValueError)(boom)
-        validator = Draft4Validator({"format": "boom"}, format_checker=checker)
-
-        with self.assertRaises(ValidationError) as cm:
-            validator.validate("BOOM")
-
-        self.assertIs(cm.exception.cause, BOOM)
-        self.assertIs(cm.exception.__cause__, BOOM)
-
-    def test_format_checkers_come_with_defaults(self):
-        # This is bad :/ but relied upon.
-        # The docs for quite awhile recommended people do things like
-        # validate(..., format_checker=FormatChecker())
-        # We should change that, but we can't without deprecation...
-        checker = FormatChecker()
-        with self.assertRaises(FormatError):
-            checker.check(instance="not-an-ipv4", format="ipv4")
-
-    def test_repr(self):
-        checker = FormatChecker(formats=())
-        checker.checks("foo")(lambda thing: True)  # pragma: no cover
-        checker.checks("bar")(lambda thing: True)  # pragma: no cover
-        checker.checks("baz")(lambda thing: True)  # pragma: no cover
-        self.assertEqual(
-            repr(checker),
-            "<FormatChecker checkers=['bar', 'baz', 'foo']>",
-        )

package/python_modules/lib/python3.11/site-packages/jsonschema/tests/test_jsonschema_test_suite.py

@@ -1,262 +0,0 @@
-"""
-Test runner for the JSON Schema official test suite
-
-Tests comprehensive correctness of each draft's validator.
-
-See https://github.com/json-schema-org/JSON-Schema-Test-Suite for details.
-"""
-
-
-from jsonschema.tests._suite import Suite
-import jsonschema
-
-SUITE = Suite()
-DRAFT3 = SUITE.version(name="draft3")
-DRAFT4 = SUITE.version(name="draft4")
-DRAFT6 = SUITE.version(name="draft6")
-DRAFT7 = SUITE.version(name="draft7")
-DRAFT201909 = SUITE.version(name="draft2019-09")
-DRAFT202012 = SUITE.version(name="draft2020-12")
-
-
-def skip(message, **kwargs):
-    def skipper(test):
-        if all(value == getattr(test, attr) for attr, value in kwargs.items()):
-            return message
-    return skipper
-
-
-def ecmascript_regex(test):
-    if test.subject == "ecmascript-regex":
-        return "ECMA regex support will be added in #1142."
-
-
-def missing_format(Validator):
-    def missing_format(test):  # pragma: no cover
-        schema = test.schema
-        if (
-            schema is True
-            or schema is False
-            or "format" not in schema
-            or schema["format"] in Validator.FORMAT_CHECKER.checkers
-            or test.valid
-        ):
-            return
-
-        return f"Format checker {schema['format']!r} not found."
-    return missing_format
-
-
-def complex_email_validation(test):
-    if test.subject != "email":
-        return
-
-    message = "Complex email validation is (intentionally) unsupported."
-    return skip(
-        message=message,
-        description="an invalid domain",
-    )(test) or skip(
-        message=message,
-        description="an invalid IPv4-address-literal",
-    )(test) or skip(
-        message=message,
-        description="dot after local part is not valid",
-    )(test) or skip(
-        message=message,
-        description="dot before local part is not valid",
-    )(test) or skip(
-        message=message,
-        description="two subsequent dots inside local part are not valid",
-    )(test)
-
-
-def leap_second(test):
-    message = "Leap seconds are unsupported."
-    return skip(
-        message=message,
-        subject="time",
-        description="a valid time string with leap second",
-    )(test) or skip(
-        message=message,
-        subject="time",
-        description="a valid time string with leap second, Zulu",
-    )(test) or skip(
-        message=message,
-        subject="time",
-        description="a valid time string with leap second with offset",
-    )(test) or skip(
-        message=message,
-        subject="time",
-        description="valid leap second, positive time-offset",
-    )(test) or skip(
-        message=message,
-        subject="time",
-        description="valid leap second, negative time-offset",
-    )(test) or skip(
-        message=message,
-        subject="time",
-        description="valid leap second, large positive time-offset",
-    )(test) or skip(
-        message=message,
-        subject="time",
-        description="valid leap second, large negative time-offset",
-    )(test) or skip(
-        message=message,
-        subject="time",
-        description="valid leap second, zero time-offset",
-    )(test) or skip(
-        message=message,
-        subject="date-time",
-        description="a valid date-time with a leap second, UTC",
-    )(test) or skip(
-        message=message,
-        subject="date-time",
-        description="a valid date-time with a leap second, with minus offset",
-    )(test)
-
-
-TestDraft3 = DRAFT3.to_unittest_testcase(
-    DRAFT3.cases(),
-    DRAFT3.format_cases(),
-    DRAFT3.optional_cases_of(name="bignum"),
-    DRAFT3.optional_cases_of(name="non-bmp-regex"),
-    DRAFT3.optional_cases_of(name="zeroTerminatedFloats"),
-    Validator=jsonschema.Draft3Validator,
-    format_checker=jsonschema.Draft3Validator.FORMAT_CHECKER,
-    skip=lambda test: (
-        ecmascript_regex(test)
-        or missing_format(jsonschema.Draft3Validator)(test)
-        or complex_email_validation(test)
-    ),
-)
-
-
-TestDraft4 = DRAFT4.to_unittest_testcase(
-    DRAFT4.cases(),
-    DRAFT4.format_cases(),
-    DRAFT4.optional_cases_of(name="bignum"),
-    DRAFT4.optional_cases_of(name="float-overflow"),
-    DRAFT4.optional_cases_of(name="id"),
-    DRAFT4.optional_cases_of(name="non-bmp-regex"),
-    DRAFT4.optional_cases_of(name="zeroTerminatedFloats"),
-    Validator=jsonschema.Draft4Validator,
-    format_checker=jsonschema.Draft4Validator.FORMAT_CHECKER,
-    skip=lambda test: (
-        ecmascript_regex(test)
-        or leap_second(test)
-        or missing_format(jsonschema.Draft4Validator)(test)
-        or complex_email_validation(test)
-    ),
-)
-
-
-TestDraft6 = DRAFT6.to_unittest_testcase(
-    DRAFT6.cases(),
-    DRAFT6.format_cases(),
-    DRAFT6.optional_cases_of(name="bignum"),
-    DRAFT6.optional_cases_of(name="float-overflow"),
-    DRAFT6.optional_cases_of(name="id"),
-    DRAFT6.optional_cases_of(name="non-bmp-regex"),
-    Validator=jsonschema.Draft6Validator,
-    format_checker=jsonschema.Draft6Validator.FORMAT_CHECKER,
-    skip=lambda test: (
-        ecmascript_regex(test)
-        or leap_second(test)
-        or missing_format(jsonschema.Draft6Validator)(test)
-        or complex_email_validation(test)
-    ),
-)
-
-
-TestDraft7 = DRAFT7.to_unittest_testcase(
-    DRAFT7.cases(),
-    DRAFT7.format_cases(),
-    DRAFT7.optional_cases_of(name="bignum"),
-    DRAFT7.optional_cases_of(name="cross-draft"),
-    DRAFT7.optional_cases_of(name="float-overflow"),
-    DRAFT6.optional_cases_of(name="id"),
-    DRAFT7.optional_cases_of(name="non-bmp-regex"),
-    DRAFT7.optional_cases_of(name="unknownKeyword"),
-    Validator=jsonschema.Draft7Validator,
-    format_checker=jsonschema.Draft7Validator.FORMAT_CHECKER,
-    skip=lambda test: (
-        ecmascript_regex(test)
-        or leap_second(test)
-        or missing_format(jsonschema.Draft7Validator)(test)
-        or complex_email_validation(test)
-    ),
-)
-
-
-TestDraft201909 = DRAFT201909.to_unittest_testcase(
-    DRAFT201909.cases(),
-    DRAFT201909.optional_cases_of(name="anchor"),
-    DRAFT201909.optional_cases_of(name="bignum"),
-    DRAFT201909.optional_cases_of(name="cross-draft"),
-    DRAFT201909.optional_cases_of(name="float-overflow"),
-    DRAFT201909.optional_cases_of(name="id"),
-    DRAFT201909.optional_cases_of(name="no-schema"),
-    DRAFT201909.optional_cases_of(name="non-bmp-regex"),
-    DRAFT201909.optional_cases_of(name="refOfUnknownKeyword"),
-    DRAFT201909.optional_cases_of(name="unknownKeyword"),
-    Validator=jsonschema.Draft201909Validator,
-    skip=skip(
-        message="Vocabulary support is still in-progress.",
-        subject="vocabulary",
-        description=(
-            "no validation: invalid number, but it still validates"
-        ),
-    ),
-)
-
-
-TestDraft201909Format = DRAFT201909.to_unittest_testcase(
-    DRAFT201909.format_cases(),
-    name="TestDraft201909Format",
-    Validator=jsonschema.Draft201909Validator,
-    format_checker=jsonschema.Draft201909Validator.FORMAT_CHECKER,
-    skip=lambda test: (
-        complex_email_validation(test)
-        or ecmascript_regex(test)
-        or leap_second(test)
-        or missing_format(jsonschema.Draft201909Validator)(test)
-        or complex_email_validation(test)
-    ),
-)
-
-
-TestDraft202012 = DRAFT202012.to_unittest_testcase(
-    DRAFT202012.cases(),
-    DRAFT201909.optional_cases_of(name="anchor"),
-    DRAFT202012.optional_cases_of(name="bignum"),
-    DRAFT202012.optional_cases_of(name="cross-draft"),
-    DRAFT202012.optional_cases_of(name="float-overflow"),
-    DRAFT202012.optional_cases_of(name="id"),
-    DRAFT202012.optional_cases_of(name="no-schema"),
-    DRAFT202012.optional_cases_of(name="non-bmp-regex"),
-    DRAFT202012.optional_cases_of(name="refOfUnknownKeyword"),
-    DRAFT202012.optional_cases_of(name="unknownKeyword"),
-    Validator=jsonschema.Draft202012Validator,
-    skip=skip(
-        message="Vocabulary support is still in-progress.",
-        subject="vocabulary",
-        description=(
-            "no validation: invalid number, but it still validates"
-        ),
-    ),
-)
-
-
-TestDraft202012Format = DRAFT202012.to_unittest_testcase(
-    DRAFT202012.format_cases(),
-    name="TestDraft202012Format",
-    Validator=jsonschema.Draft202012Validator,
-    format_checker=jsonschema.Draft202012Validator.FORMAT_CHECKER,
-    skip=lambda test: (
-        complex_email_validation(test)
-        or ecmascript_regex(test)
-        or leap_second(test)
-        or missing_format(jsonschema.Draft202012Validator)(test)
-        or complex_email_validation(test)
-    ),
-)

package/python_modules/lib/python3.11/site-packages/jsonschema/tests/test_types.py

@@ -1,221 +0,0 @@
-"""
-Tests for the `TypeChecker`-based type interface.
-
-The actual correctness of the type checking is handled in
-`test_jsonschema_test_suite`; these tests check that TypeChecker
-functions correctly at a more granular level.
-"""
-from collections import namedtuple
-from unittest import TestCase
-
-from jsonschema import ValidationError, _keywords
-from jsonschema._types import TypeChecker
-from jsonschema.exceptions import UndefinedTypeCheck, UnknownType
-from jsonschema.validators import Draft202012Validator, extend
-
-
-def equals_2(checker, instance):
-    return instance == 2
-
-
-def is_namedtuple(instance):
-    return isinstance(instance, tuple) and getattr(instance, "_fields", None)
-
-
-def is_object_or_named_tuple(checker, instance):
-    if Draft202012Validator.TYPE_CHECKER.is_type(instance, "object"):
-        return True
-    return is_namedtuple(instance)
-
-
-class TestTypeChecker(TestCase):
-    def test_is_type(self):
-        checker = TypeChecker({"two": equals_2})
-        self.assertEqual(
-            (
-                checker.is_type(instance=2, type="two"),
-                checker.is_type(instance="bar", type="two"),
-            ),
-            (True, False),
-        )
-
-    def test_is_unknown_type(self):
-        with self.assertRaises(UndefinedTypeCheck) as e:
-            TypeChecker().is_type(4, "foobar")
-        self.assertIn(
-            "'foobar' is unknown to this type checker",
-            str(e.exception),
-        )
-        self.assertTrue(
-            e.exception.__suppress_context__,
-            msg="Expected the internal KeyError to be hidden.",
-        )
-
-    def test_checks_can_be_added_at_init(self):
-        checker = TypeChecker({"two": equals_2})
-        self.assertEqual(checker, TypeChecker().redefine("two", equals_2))
-
-    def test_redefine_existing_type(self):
-        self.assertEqual(
-            TypeChecker().redefine("two", object()).redefine("two", equals_2),
-            TypeChecker().redefine("two", equals_2),
-        )
-
-    def test_remove(self):
-        self.assertEqual(
-            TypeChecker({"two": equals_2}).remove("two"),
-            TypeChecker(),
-        )
-
-    def test_remove_unknown_type(self):
-        with self.assertRaises(UndefinedTypeCheck) as context:
-            TypeChecker().remove("foobar")
-        self.assertIn("foobar", str(context.exception))
-
-    def test_redefine_many(self):
-        self.assertEqual(
-            TypeChecker().redefine_many({"foo": int, "bar": str}),
-            TypeChecker().redefine("foo", int).redefine("bar", str),
-        )
-
-    def test_remove_multiple(self):
-        self.assertEqual(
-            TypeChecker({"foo": int, "bar": str}).remove("foo", "bar"),
-            TypeChecker(),
-        )
-
-    def test_type_check_can_raise_key_error(self):
-        """
-        Make sure no one writes:
-
-            try:
-                self._type_checkers[type](...)
-            except KeyError:
-
-        ignoring the fact that the function itself can raise that.
-        """
-
-        error = KeyError("Stuff")
-
-        def raises_keyerror(checker, instance):
-            raise error
-
-        with self.assertRaises(KeyError) as context:
-            TypeChecker({"foo": raises_keyerror}).is_type(4, "foo")
-
-        self.assertIs(context.exception, error)
-
-    def test_repr(self):
-        checker = TypeChecker({"foo": is_namedtuple, "bar": is_namedtuple})
-        self.assertEqual(repr(checker), "<TypeChecker types={'bar', 'foo'}>")
-
-
-class TestCustomTypes(TestCase):
-    def test_simple_type_can_be_extended(self):
-        def int_or_str_int(checker, instance):
-            if not isinstance(instance, (int, str)):
-                return False
-            try:
-                int(instance)
-            except ValueError:
-                return False
-            return True
-
-        CustomValidator = extend(
-            Draft202012Validator,
-            type_checker=Draft202012Validator.TYPE_CHECKER.redefine(
-                "integer", int_or_str_int,
-            ),
-        )
-        validator = CustomValidator({"type": "integer"})
-
-        validator.validate(4)
-        validator.validate("4")
-
-        with self.assertRaises(ValidationError):
-            validator.validate(4.4)
-
-        with self.assertRaises(ValidationError):
-            validator.validate("foo")
-
-    def test_object_can_be_extended(self):
-        schema = {"type": "object"}
-
-        Point = namedtuple("Point", ["x", "y"])
-
-        type_checker = Draft202012Validator.TYPE_CHECKER.redefine(
-            "object", is_object_or_named_tuple,
-        )
-
-        CustomValidator = extend(
-            Draft202012Validator,
-            type_checker=type_checker,
-        )
-        validator = CustomValidator(schema)
-
-        validator.validate(Point(x=4, y=5))
-
-    def test_object_extensions_require_custom_validators(self):
-        schema = {"type": "object", "required": ["x"]}
-
-        type_checker = Draft202012Validator.TYPE_CHECKER.redefine(
-            "object", is_object_or_named_tuple,
-        )
-
-        CustomValidator = extend(
-            Draft202012Validator,
-            type_checker=type_checker,
-        )
-        validator = CustomValidator(schema)
-
-        Point = namedtuple("Point", ["x", "y"])
-        # Cannot handle required
-        with self.assertRaises(ValidationError):
-            validator.validate(Point(x=4, y=5))
-
-    def test_object_extensions_can_handle_custom_validators(self):
-        schema = {
-            "type": "object",
-            "required": ["x"],
-            "properties": {"x": {"type": "integer"}},
-        }
-
-        type_checker = Draft202012Validator.TYPE_CHECKER.redefine(
-            "object", is_object_or_named_tuple,
-        )
-
-        def coerce_named_tuple(fn):
-            def coerced(validator, value, instance, schema):
-                if is_namedtuple(instance):
-                    instance = instance._asdict()
-                return fn(validator, value, instance, schema)
-            return coerced
-
-        required = coerce_named_tuple(_keywords.required)
-        properties = coerce_named_tuple(_keywords.properties)
-
-        CustomValidator = extend(
-            Draft202012Validator,
-            type_checker=type_checker,
-            validators={"required": required, "properties": properties},
-        )
-
-        validator = CustomValidator(schema)
-
-        Point = namedtuple("Point", ["x", "y"])
-        # Can now process required and properties
-        validator.validate(Point(x=4, y=5))
-
-        with self.assertRaises(ValidationError):
-            validator.validate(Point(x="not an integer", y=5))
-
-        # As well as still handle objects.
-        validator.validate({"x": 4, "y": 5})
-
-        with self.assertRaises(ValidationError):
-            validator.validate({"x": "not an integer", "y": 5})
-
-    def test_unknown_type(self):
-        with self.assertRaises(UnknownType) as e:
-            Draft202012Validator({}).is_type(12, "some unknown type")
-        self.assertIn("'some unknown type'", str(e.exception))