@motiadev/core 0.1.0-beta.27 → 0.1.0-beta.29

package/python_modules/lib/python3.11/site-packages/jsonschema/benchmarks/issue232.py

@@ -0,0 +1,25 @@
+"""
+A performance benchmark using the example from issue #232.
+
+See https://github.com/python-jsonschema/jsonschema/pull/232.
+"""
+from pathlib import Path
+
+from pyperf import Runner
+from referencing import Registry
+
+from jsonschema.tests._suite import Version
+import jsonschema
+
+issue232 = Version(
+    path=Path(__file__).parent / "issue232",
+    remotes=Registry(),
+    name="issue232",
+)
+
+
+if __name__ == "__main__":
+    issue232.benchmark(
+        runner=Runner(),
+        Validator=jsonschema.Draft4Validator,
+    )

package/python_modules/lib/python3.11/site-packages/jsonschema/benchmarks/json_schema_test_suite.py

@@ -0,0 +1,12 @@
+"""
+A performance benchmark using the official test suite.
+
+This benchmarks jsonschema using every valid example in the
+JSON-Schema-Test-Suite. It will take some time to complete.
+"""
+from pyperf import Runner
+
+from jsonschema.tests._suite import Suite
+
+if __name__ == "__main__":
+    Suite().benchmark(runner=Runner())

package/python_modules/lib/python3.11/site-packages/jsonschema/benchmarks/nested_schemas.py

@@ -0,0 +1,56 @@
+"""
+Validating highly nested schemas shouldn't cause exponential time blowups.
+
+See https://github.com/python-jsonschema/jsonschema/issues/1097.
+"""
+from itertools import cycle
+
+from jsonschema.validators import validator_for
+
+metaschemaish = {
+    "$id": "https://example.com/draft/2020-12/schema/strict",
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/core": True,
+        "https://json-schema.org/draft/2020-12/vocab/applicator": True,
+        "https://json-schema.org/draft/2020-12/vocab/unevaluated": True,
+        "https://json-schema.org/draft/2020-12/vocab/validation": True,
+        "https://json-schema.org/draft/2020-12/vocab/meta-data": True,
+        "https://json-schema.org/draft/2020-12/vocab/format-annotation": True,
+        "https://json-schema.org/draft/2020-12/vocab/content": True,
+    },
+    "$dynamicAnchor": "meta",
+
+    "$ref": "https://json-schema.org/draft/2020-12/schema",
+    "unevaluatedProperties": False,
+}
+
+
+def nested_schema(levels):
+    """
+    Produce a schema which validates deeply nested objects and arrays.
+    """
+
+    names = cycle(["foo", "bar", "baz", "quux", "spam", "eggs"])
+    schema = {"type": "object", "properties": {"ham": {"type": "string"}}}
+    for _, name in zip(range(levels - 1), names):
+        schema = {"type": "object", "properties": {name: schema}}
+    return schema
+
+
+validator = validator_for(metaschemaish)(metaschemaish)
+
+if __name__ == "__main__":
+    from pyperf import Runner
+    runner = Runner()
+
+    not_nested = nested_schema(levels=1)
+    runner.bench_func("not nested", lambda: validator.is_valid(not_nested))
+
+    for levels in range(1, 11, 3):
+        schema = nested_schema(levels=levels)
+        runner.bench_func(
+            f"nested * {levels}",
+            lambda schema=schema: validator.is_valid(schema),
+        )

package/python_modules/lib/python3.11/site-packages/jsonschema/benchmarks/subcomponents.py

@@ -0,0 +1,42 @@
+"""
+A benchmark which tries to compare the possible slow subparts of validation.
+"""
+from referencing import Registry
+from referencing.jsonschema import DRAFT202012
+from rpds import HashTrieMap, HashTrieSet
+
+from jsonschema import Draft202012Validator
+
+schema = {
+    "type": "array",
+    "minLength": 1,
+    "maxLength": 1,
+    "items": {"type": "integer"},
+}
+
+hmap = HashTrieMap()
+hset = HashTrieSet()
+
+registry = Registry()
+
+v = Draft202012Validator(schema)
+
+
+def registry_data_structures():
+    return hmap.insert("foo", "bar"), hset.insert("foo")
+
+
+def registry_add():
+    resource = DRAFT202012.create_resource(schema)
+    return registry.with_resource(uri="urn:example", resource=resource)
+
+
+if __name__ == "__main__":
+    from pyperf import Runner
+    runner = Runner()
+
+    runner.bench_func("HashMap/HashSet insertion", registry_data_structures)
+    runner.bench_func("Registry insertion", registry_add)
+    runner.bench_func("Success", lambda: v.is_valid([1]))
+    runner.bench_func("Failure", lambda: v.is_valid(["foo"]))
+    runner.bench_func("Metaschema validation", lambda: v.check_schema(schema))

package/python_modules/lib/python3.11/site-packages/jsonschema/benchmarks/unused_registry.py

@@ -0,0 +1,35 @@
+"""
+An unused schema registry should not cause slower validation.
+
+"Unused" here means one where no reference resolution is occurring anyhow.
+
+See https://github.com/python-jsonschema/jsonschema/issues/1088.
+"""
+from pyperf import Runner
+from referencing import Registry
+from referencing.jsonschema import DRAFT201909
+
+from jsonschema import Draft201909Validator
+
+registry = Registry().with_resource(
+    "urn:example:foo",
+    DRAFT201909.create_resource({}),
+)
+
+schema = {"$ref": "https://json-schema.org/draft/2019-09/schema"}
+instance = {"maxLength": 4}
+
+no_registry = Draft201909Validator(schema)
+with_useless_registry = Draft201909Validator(schema, registry=registry)
+
+if __name__ == "__main__":
+    runner = Runner()
+
+    runner.bench_func(
+        "no registry",
+        lambda: no_registry.is_valid(instance),
+    )
+    runner.bench_func(
+        "useless registry",
+        lambda: with_useless_registry.is_valid(instance),
+    )

package/python_modules/lib/python3.11/site-packages/jsonschema/benchmarks/useless_applicator_schemas.py

@@ -0,0 +1,106 @@
+
+"""
+A benchmark for validation of applicators containing lots of useless schemas.
+
+Signals a small possible optimization to remove all such schemas ahead of time.
+"""
+
+from pyperf import Runner
+
+from jsonschema import Draft202012Validator as Validator
+
+NUM_USELESS = 100000
+
+subschema = {"const": 37}
+
+valid = 37
+invalid = 12
+
+baseline = Validator(subschema)
+
+
+# These should be indistinguishable from just `subschema`
+by_name = {
+    "single subschema": {
+        "anyOf": Validator({"anyOf": [subschema]}),
+        "allOf": Validator({"allOf": [subschema]}),
+        "oneOf": Validator({"oneOf": [subschema]}),
+    },
+    "redundant subschemas": {
+        "anyOf": Validator({"anyOf": [subschema] * NUM_USELESS}),
+        "allOf": Validator({"allOf": [subschema] * NUM_USELESS}),
+    },
+    "useless successful subschemas (beginning)": {
+        "anyOf": Validator({"anyOf": [subschema, *[True] * NUM_USELESS]}),
+        "allOf": Validator({"allOf": [subschema, *[True] * NUM_USELESS]}),
+    },
+    "useless successful subschemas (middle)": {
+        "anyOf": Validator(
+            {
+                "anyOf": [
+                    *[True] * (NUM_USELESS // 2),
+                    subschema,
+                    *[True] * (NUM_USELESS // 2),
+                ],
+            },
+        ),
+        "allOf": Validator(
+            {
+                "allOf": [
+                    *[True] * (NUM_USELESS // 2),
+                    subschema,
+                    *[True] * (NUM_USELESS // 2),
+                ],
+            },
+        ),
+    },
+    "useless successful subschemas (end)": {
+        "anyOf": Validator({"anyOf": [*[True] * NUM_USELESS, subschema]}),
+        "allOf": Validator({"allOf": [*[True] * NUM_USELESS, subschema]}),
+    },
+    "useless failing subschemas (beginning)": {
+        "anyOf": Validator({"anyOf": [subschema, *[False] * NUM_USELESS]}),
+        "oneOf": Validator({"oneOf": [subschema, *[False] * NUM_USELESS]}),
+    },
+    "useless failing subschemas (middle)": {
+        "anyOf": Validator(
+            {
+                "anyOf": [
+                    *[False] * (NUM_USELESS // 2),
+                    subschema,
+                    *[False] * (NUM_USELESS // 2),
+                ],
+            },
+        ),
+        "oneOf": Validator(
+            {
+                "oneOf": [
+                    *[False] * (NUM_USELESS // 2),
+                    subschema,
+                    *[False] * (NUM_USELESS // 2),
+                ],
+            },
+        ),
+    },
+    "useless failing subschemas (end)": {
+        "anyOf": Validator({"anyOf": [*[False] * NUM_USELESS, subschema]}),
+        "oneOf": Validator({"oneOf": [*[False] * NUM_USELESS, subschema]}),
+    },
+}
+
+if __name__ == "__main__":
+    runner = Runner()
+
+    runner.bench_func("baseline valid", lambda: baseline.is_valid(valid))
+    runner.bench_func("baseline invalid", lambda: baseline.is_valid(invalid))
+
+    for group, applicators in by_name.items():
+        for applicator, validator in applicators.items():
+            runner.bench_func(
+                f"{group}: {applicator} valid",
+                lambda validator=validator: validator.is_valid(valid),
+            )
+            runner.bench_func(
+                f"{group}: {applicator} invalid",
+                lambda validator=validator: validator.is_valid(invalid),
+            )

package/python_modules/lib/python3.11/site-packages/jsonschema/benchmarks/useless_keywords.py

@@ -0,0 +1,32 @@
+"""
+A benchmark for validation of schemas containing lots of useless keywords.
+
+Checks we filter them out once, ahead of time.
+"""
+
+from pyperf import Runner
+
+from jsonschema import Draft202012Validator
+
+NUM_USELESS = 100000
+schema = dict(
+    [
+        ("not", {"const": 42}),
+        *((str(i), i) for i in range(NUM_USELESS)),
+        ("type", "integer"),
+        *((str(i), i) for i in range(NUM_USELESS, NUM_USELESS)),
+        ("minimum", 37),
+    ],
+)
+validator = Draft202012Validator(schema)
+
+valid = 3737
+invalid = 12
+
+
+if __name__ == "__main__":
+    runner = Runner()
+    runner.bench_func("beginning of schema", lambda: validator.is_valid(42))
+    runner.bench_func("middle of schema", lambda: validator.is_valid("foo"))
+    runner.bench_func("end of schema", lambda: validator.is_valid(12))
+    runner.bench_func("valid", lambda: validator.is_valid(3737))

package/python_modules/lib/python3.11/site-packages/jsonschema/benchmarks/validator_creation.py

@@ -0,0 +1,14 @@
+from pyperf import Runner
+
+from jsonschema import Draft202012Validator
+
+schema = {
+    "type": "array",
+    "minLength": 1,
+    "maxLength": 1,
+    "items": {"type": "integer"},
+}
+
+
+if __name__ == "__main__":
+    Runner().bench_func("validator creation", Draft202012Validator, schema)

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

@@ -0,0 +1,296 @@
+"""
+The ``jsonschema`` command line.
+"""
+
+from importlib import metadata
+from json import JSONDecodeError
+from textwrap import dedent
+import argparse
+import json
+import sys
+import traceback
+import warnings
+
+try:
+    from pkgutil import resolve_name
+except ImportError:
+    from pkgutil_resolve_name import resolve_name  # type: ignore[no-redef]
+
+from attrs import define, field
+
+from jsonschema.exceptions import SchemaError
+from jsonschema.validators import _RefResolver, validator_for
+
+warnings.warn(
+    (
+        "The jsonschema CLI is deprecated and will be removed in a future "
+        "version. Please use check-jsonschema instead, which can be installed "
+        "from https://pypi.org/project/check-jsonschema/"
+    ),
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+
+class _CannotLoadFile(Exception):
+    pass
+
+
+@define
+class _Outputter:
+
+    _formatter = field()
+    _stdout = field()
+    _stderr = field()
+
+    @classmethod
+    def from_arguments(cls, arguments, stdout, stderr):
+        if arguments["output"] == "plain":
+            formatter = _PlainFormatter(arguments["error_format"])
+        elif arguments["output"] == "pretty":
+            formatter = _PrettyFormatter()
+        return cls(formatter=formatter, stdout=stdout, stderr=stderr)
+
+    def load(self, path):
+        try:
+            file = open(path)  # noqa: SIM115, PTH123
+        except FileNotFoundError as error:
+            self.filenotfound_error(path=path, exc_info=sys.exc_info())
+            raise _CannotLoadFile() from error
+
+        with file:
+            try:
+                return json.load(file)
+            except JSONDecodeError as error:
+                self.parsing_error(path=path, exc_info=sys.exc_info())
+                raise _CannotLoadFile() from error
+
+    def filenotfound_error(self, **kwargs):
+        self._stderr.write(self._formatter.filenotfound_error(**kwargs))
+
+    def parsing_error(self, **kwargs):
+        self._stderr.write(self._formatter.parsing_error(**kwargs))
+
+    def validation_error(self, **kwargs):
+        self._stderr.write(self._formatter.validation_error(**kwargs))
+
+    def validation_success(self, **kwargs):
+        self._stdout.write(self._formatter.validation_success(**kwargs))
+
+
+@define
+class _PrettyFormatter:
+
+    _ERROR_MSG = dedent(
+        """\
+        ===[{type}]===({path})===
+
+        {body}
+        -----------------------------
+        """,
+    )
+    _SUCCESS_MSG = "===[SUCCESS]===({path})===\n"
+
+    def filenotfound_error(self, path, exc_info):
+        return self._ERROR_MSG.format(
+            path=path,
+            type="FileNotFoundError",
+            body=f"{path!r} does not exist.",
+        )
+
+    def parsing_error(self, path, exc_info):
+        exc_type, exc_value, exc_traceback = exc_info
+        exc_lines = "".join(
+            traceback.format_exception(exc_type, exc_value, exc_traceback),
+        )
+        return self._ERROR_MSG.format(
+            path=path,
+            type=exc_type.__name__,
+            body=exc_lines,
+        )
+
+    def validation_error(self, instance_path, error):
+        return self._ERROR_MSG.format(
+            path=instance_path,
+            type=error.__class__.__name__,
+            body=error,
+        )
+
+    def validation_success(self, instance_path):
+        return self._SUCCESS_MSG.format(path=instance_path)
+
+
+@define
+class _PlainFormatter:
+
+    _error_format = field()
+
+    def filenotfound_error(self, path, exc_info):
+        return f"{path!r} does not exist.\n"
+
+    def parsing_error(self, path, exc_info):
+        return "Failed to parse {}: {}\n".format(
+            "<stdin>" if path == "<stdin>" else repr(path),
+            exc_info[1],
+        )
+
+    def validation_error(self, instance_path, error):
+        return self._error_format.format(file_name=instance_path, error=error)
+
+    def validation_success(self, instance_path):
+        return ""
+
+
+def _resolve_name_with_default(name):
+    if "." not in name:
+        name = "jsonschema." + name
+    return resolve_name(name)
+
+
+parser = argparse.ArgumentParser(
+    description="JSON Schema Validation CLI",
+)
+parser.add_argument(
+    "-i", "--instance",
+    action="append",
+    dest="instances",
+    help="""
+        a path to a JSON instance (i.e. filename.json) to validate (may
+        be specified multiple times). If no instances are provided via this
+        option, one will be expected on standard input.
+    """,
+)
+parser.add_argument(
+    "-F", "--error-format",
+    help="""
+        the format to use for each validation error message, specified
+        in a form suitable for str.format. This string will be passed
+        one formatted object named 'error' for each ValidationError.
+        Only provide this option when using --output=plain, which is the
+        default. If this argument is unprovided and --output=plain is
+        used, a simple default representation will be used.
+    """,
+)
+parser.add_argument(
+    "-o", "--output",
+    choices=["plain", "pretty"],
+    default="plain",
+    help="""
+        an output format to use. 'plain' (default) will produce minimal
+        text with one line for each error, while 'pretty' will produce
+        more detailed human-readable output on multiple lines.
+    """,
+)
+parser.add_argument(
+    "-V", "--validator",
+    type=_resolve_name_with_default,
+    help="""
+        the fully qualified object name of a validator to use, or, for
+        validators that are registered with jsonschema, simply the name
+        of the class.
+    """,
+)
+parser.add_argument(
+    "--base-uri",
+    help="""
+        a base URI to assign to the provided schema, even if it does not
+        declare one (via e.g. $id). This option can be used if you wish to
+        resolve relative references to a particular URI (or local path)
+    """,
+)
+parser.add_argument(
+    "--version",
+    action="version",
+    version=metadata.version("jsonschema"),
+)
+parser.add_argument(
+    "schema",
+    help="the path to a JSON Schema to validate with (i.e. schema.json)",
+)
+
+
+def parse_args(args):  # noqa: D103
+    arguments = vars(parser.parse_args(args=args or ["--help"]))
+    if arguments["output"] != "plain" and arguments["error_format"]:
+        raise parser.error(
+            "--error-format can only be used with --output plain",
+        )
+    if arguments["output"] == "plain" and arguments["error_format"] is None:
+        arguments["error_format"] = "{error.instance}: {error.message}\n"
+    return arguments
+
+
+def _validate_instance(instance_path, instance, validator, outputter):
+    invalid = False
+    for error in validator.iter_errors(instance):
+        invalid = True
+        outputter.validation_error(instance_path=instance_path, error=error)
+
+    if not invalid:
+        outputter.validation_success(instance_path=instance_path)
+    return invalid
+
+
+def main(args=sys.argv[1:]):  # noqa: D103
+    sys.exit(run(arguments=parse_args(args=args)))
+
+
+def run(arguments, stdout=sys.stdout, stderr=sys.stderr, stdin=sys.stdin):  # noqa: D103
+    outputter = _Outputter.from_arguments(
+        arguments=arguments,
+        stdout=stdout,
+        stderr=stderr,
+    )
+
+    try:
+        schema = outputter.load(arguments["schema"])
+    except _CannotLoadFile:
+        return 1
+
+    Validator = arguments["validator"]
+    if Validator is None:
+        Validator = validator_for(schema)
+
+    try:
+        Validator.check_schema(schema)
+    except SchemaError as error:
+        outputter.validation_error(
+            instance_path=arguments["schema"],
+            error=error,
+        )
+        return 1
+
+    if arguments["instances"]:
+        load, instances = outputter.load, arguments["instances"]
+    else:
+        def load(_):
+            try:
+                return json.load(stdin)
+            except JSONDecodeError as error:
+                outputter.parsing_error(
+                    path="<stdin>", exc_info=sys.exc_info(),
+                )
+                raise _CannotLoadFile() from error
+        instances = ["<stdin>"]
+
+    resolver = _RefResolver(
+        base_uri=arguments["base_uri"],
+        referrer=schema,
+    ) if arguments["base_uri"] is not None else None
+
+    validator = Validator(schema, resolver=resolver)
+    exit_code = 0
+    for each in instances:
+        try:
+            instance = load(each)
+        except _CannotLoadFile:
+            exit_code = 1
+        else:
+            exit_code |= _validate_instance(
+                instance_path=each,
+                instance=instance,
+                validator=validator,
+                outputter=outputter,
+            )
+
+    return exit_code