Script 'mail_helper' called by obssrc
Hello community,
here is the log from the commit of package python-jsonschema for
openSUSE:Factory checked in at 2022-11-24 12:22:08
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/python-jsonschema (Old)
and /work/SRC/openSUSE:Factory/.python-jsonschema.new.1597 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-jsonschema"
Thu Nov 24 12:22:08 2022 rev:34 rq:1037460 version:4.17.1
Changes:
--------
--- /work/SRC/openSUSE:Factory/python-jsonschema/python-jsonschema.changes
2022-11-17 17:23:48.708845576 +0100
+++
/work/SRC/openSUSE:Factory/.python-jsonschema.new.1597/python-jsonschema.changes
2022-11-24 12:22:11.744903495 +0100
@@ -1,0 +2,7 @@
+Wed Nov 23 07:15:21 UTC 2022 - Johannes Kastl <[email protected]>
+
+- update to 4.17.1:
+ * No nice changelog provided upstream
+ Full Changelog:
https://github.com/python-jsonschema/jsonschema/compare/v4.17.0...v4.17.1
+
+-------------------------------------------------------------------
Old:
----
jsonschema-4.17.0.tar.gz
New:
----
_service
jsonschema-4.17.1.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ python-jsonschema.spec ++++++
--- /var/tmp/diff_new_pack.ySrBwl/_old 2022-11-24 12:22:12.284906926 +0100
+++ /var/tmp/diff_new_pack.ySrBwl/_new 2022-11-24 12:22:12.288906951 +0100
@@ -23,7 +23,7 @@
%endif
Name: python-jsonschema
-Version: 4.17.0
+Version: 4.17.1
Release: 0
Summary: An implementation of JSON-Schema validation for Python
License: MIT
++++++ _service ++++++
<services>
<service name="download_files" mode="disabled">
</service>
</services>
++++++ jsonschema-4.17.0.tar.gz -> jsonschema-4.17.1.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/jsonschema-4.17.0/.github/workflows/ci.yml
new/jsonschema-4.17.1/.github/workflows/ci.yml
--- old/jsonschema-4.17.0/.github/workflows/ci.yml 2020-02-02
01:00:00.000000000 +0100
+++ new/jsonschema-4.17.1/.github/workflows/ci.yml 2020-02-02
01:00:00.000000000 +0100
@@ -86,50 +86,62 @@
toxenv: py310-formatnongpl-build
- name: "3.10"
toxenv: py310-formatnongpl-tests
- - name: "3.11.0-beta - 3.11.0"
+ - name: "3.11"
toxenv: py311-noextra-build
- - name: "3.11.0-beta - 3.11.0"
+ - name: "3.11"
toxenv: py311-noextra-tests
- - name: "3.11.0-beta - 3.11.0"
+ - name: "3.11"
toxenv: py311-format-build
- - name: "3.11.0-beta - 3.11.0"
+ - name: "3.11"
toxenv: py311-format-tests
- - name: "3.11.0-beta - 3.11.0"
+ - name: "3.11"
toxenv: py311-formatnongpl-build
- - name: "3.11.0-beta - 3.11.0"
+ - name: "3.11"
toxenv: py311-formatnongpl-tests
- - name: "3.10"
+ - name: "3.11"
toxenv: docs-dirhtml
- - name: "3.10"
+ - name: "3.11"
toxenv: docs-doctest
- - name: "3.10"
+ - name: "3.11"
toxenv: docs-linkcheck
- - name: "3.10"
+ - name: "3.11"
toxenv: docs-spelling
- - name: "3.10"
+ - name: "3.11"
toxenv: docs-style
- - name: "3.10"
+ - name: "3.11"
toxenv: readme
- - name: "3.10"
+ - name: "3.11"
toxenv: safety
- - name: "3.10"
+ - name: "3.11"
toxenv: secrets
- - name: "3.10"
+ - name: "3.11"
toxenv: style
- - name: "3.10"
+ - name: "3.11"
toxenv: typing
exclude:
- os: windows-latest
python-version:
- name: "3.10"
+ name: "3.11"
toxenv: readme
- os: windows-latest
python-version:
- name: "3.10"
+ name: "3.11"
+ toxenv: docs-dirhtml
+ - os: windows-latest
+ python-version:
+ name: "3.11"
+ toxenv: docs-doctest
+ - os: windows-latest
+ python-version:
+ name: "3.11"
toxenv: docs-linkcheck
- os: windows-latest
python-version:
- name: "3.10"
+ name: "3.11"
+ toxenv: docs-spelling
+ - os: windows-latest
+ python-version:
+ name: "3.11"
toxenv: docs-style
steps:
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/jsonschema-4.17.0/CHANGELOG.rst
new/jsonschema-4.17.1/CHANGELOG.rst
--- old/jsonschema-4.17.0/CHANGELOG.rst 2020-02-02 01:00:00.000000000 +0100
+++ new/jsonschema-4.17.1/CHANGELOG.rst 2020-02-02 01:00:00.000000000 +0100
@@ -1,3 +1,9 @@
+v4.17.1
+=======
+
+* The error message when using ``unevaluatedProperties`` with a non-trivial
+ schema value (i.e. something other than ``false``) has been improved (#996).
+
v4.17.0
=======
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/jsonschema-4.17.0/PKG-INFO
new/jsonschema-4.17.1/PKG-INFO
--- old/jsonschema-4.17.0/PKG-INFO 2020-02-02 01:00:00.000000000 +0100
+++ new/jsonschema-4.17.1/PKG-INFO 2020-02-02 01:00:00.000000000 +0100
@@ -1,6 +1,6 @@
Metadata-Version: 2.1
Name: jsonschema
-Version: 4.17.0
+Version: 4.17.1
Summary: An implementation of JSON Schema validation for Python
Project-URL: Homepage, https://github.com/python-jsonschema/jsonschema
Project-URL: Documentation, https://python-jsonschema.readthedocs.io/
@@ -188,15 +188,8 @@
Release Information
-------------------
-v4.17.0
+v4.17.1
=======
-* The ``check_schema`` method on ``jsonschema.protocols.Validator`` instances
- now *enables* format validation by default when run. This can catch some
- additional invalid schemas (e.g. containing invalid regular expressions)
- where the issue is indeed uncovered by validating against the metaschema
- with format validation enabled as an assertion.
-* The ``jsonschema`` CLI (along with ``jsonschema.cli`` the module) are now
- deprecated. Use ``check-jsonschema`` instead, which can be installed via
- ``pip install check-jsonschema`` and found
- `here <https://github.com/python-jsonschema/check-jsonschema>`_.
+* The error message when using ``unevaluatedProperties`` with a non-trivial
+ schema value (i.e. something other than ``false``) has been improved (#996).
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/jsonschema-4.17.0/docs/conf.py
new/jsonschema-4.17.1/docs/conf.py
--- old/jsonschema-4.17.0/docs/conf.py 2020-02-02 01:00:00.000000000 +0100
+++ new/jsonschema-4.17.1/docs/conf.py 2020-02-02 01:00:00.000000000 +0100
@@ -165,6 +165,7 @@
suppress_warnings = [
"autoapi.python_import_resolution",
"autoapi.toc_reference",
+ "epub.duplicated_toc_entry",
]
autoapi_root = "api"
autoapi_ignore = [
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/jsonschema-4.17.0/docs/requirements.txt
new/jsonschema-4.17.1/docs/requirements.txt
--- old/jsonschema-4.17.0/docs/requirements.txt 2020-02-02 01:00:00.000000000
+0100
+++ new/jsonschema-4.17.1/docs/requirements.txt 2020-02-02 01:00:00.000000000
+0100
@@ -1,28 +1,28 @@
#
-# This file is autogenerated by pip-compile with python 3.10
+# This file is autogenerated by pip-compile with python 3.11
# To update, run:
#
# pip-compile docs/requirements.in
#
alabaster==0.7.12
# via sphinx
-astroid==2.12.5
+astroid==2.12.13
# via sphinx-autoapi
attrs==22.1.0
# via jsonschema
-babel==2.10.3
+babel==2.11.0
# via sphinx
beautifulsoup4==4.11.1
# via furo
-certifi==2022.6.15
+certifi==2022.9.24
# via requests
charset-normalizer==2.1.1
# via requests
docutils==0.19
# via sphinx
-furo==2022.6.21
+furo==2022.9.29
# via -r docs/requirements.in
-idna==3.3
+idna==3.4
# via requests
imagesize==1.4.1
# via sphinx
@@ -32,7 +32,7 @@
# sphinx-autoapi
file:.#egg=jsonschema
# via -r docs/requirements.in
-lazy-object-proxy==1.7.1
+lazy-object-proxy==1.8.0
# via astroid
lxml==4.9.1
# via
@@ -50,9 +50,9 @@
# sphinx
pyparsing==3.0.9
# via packaging
-pyrsistent==0.18.1
+pyrsistent==0.19.2
# via jsonschema
-pytz==2022.2.1
+pytz==2022.6
# via babel
pyyaml==6.0
# via sphinx-autoapi
@@ -62,7 +62,7 @@
# via sphinx
soupsieve==2.3.2.post1
# via beautifulsoup4
-sphinx==5.1.1
+sphinx==5.3.0
# via
# -r docs/requirements.in
# furo
@@ -73,15 +73,15 @@
# sphinx-json-schema-spec
# sphinxcontrib-spelling
# sphinxext-opengraph
-sphinx-autoapi==1.9.0
+sphinx-autoapi==2.0.0
# via -r docs/requirements.in
-sphinx-autodoc-typehints==1.19.2
+sphinx-autodoc-typehints==1.19.5
# via -r docs/requirements.in
-sphinx-basic-ng==0.0.1a12
+sphinx-basic-ng==1.0.0b1
# via furo
-sphinx-copybutton==0.5.0
+sphinx-copybutton==0.5.1
# via -r docs/requirements.in
-sphinx-json-schema-spec==2.2.3
+sphinx-json-schema-spec==2.3.1
# via -r docs/requirements.in
sphinxcontrib-applehelp==1.0.2
# via sphinx
@@ -95,11 +95,11 @@
# via sphinx
sphinxcontrib-serializinghtml==1.1.5
# via sphinx
-sphinxcontrib-spelling==7.6.0
+sphinxcontrib-spelling==7.7.0
# via -r docs/requirements.in
-sphinxext-opengraph==0.6.3
+sphinxext-opengraph==0.7.3
# via -r docs/requirements.in
-unidecode==1.3.4
+unidecode==1.3.6
# via sphinx-autoapi
urllib3==1.26.12
# via requests
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/jsonschema-4.17.0/json/CONTRIBUTING.md
new/jsonschema-4.17.1/json/CONTRIBUTING.md
--- old/jsonschema-4.17.0/json/CONTRIBUTING.md 1970-01-01 01:00:00.000000000
+0100
+++ new/jsonschema-4.17.1/json/CONTRIBUTING.md 2020-02-02 01:00:00.000000000
+0100
@@ -0,0 +1,87 @@
+# Contributing to the Suite
+
+All contributors to the test suite should familiarize themselves with this
document.
+
+Both pull requests *and* reviews are welcome from any and all, regardless of
their "formal" relationship (or lack thereof) with the JSON Schema organization.
+
+## Commit Access
+
+Any existing members with commit access to the repository may nominate new
members to get access, or a contributor may request access for themselves.
+Access generally should be granted liberally to anyone who has shown positive
contributions to the repository or organization.
+All who are active in other parts of the JSON Schema organization should get
access to this repository as well.
+Access for a former contributor may be removed after long periods of
inactivity.
+
+## Reviewing a Pull Request
+
+Pull requests may (and often should) be reviewed for approval by a single
reviewer whose job it is to confirm the change is specified, correct, minimal
and follows general style in the repository.
+A reviewer who does not feel comfortable signing off on the correctness of a
change is free to comment without explicit approval.
+Other contributors are also encouraged to comment on pull requests whenever
they have feedback, even if another contributor has submitted review comments.
+A submitter may also choose to request additional feedback if they feel the
change is particularly technical or complex, or requires expertise in a
particular area of the specification.
+If additional reviewers have participated in a pull request, the submitter
should not rely on a single reviewer's approval without some form of
confirmation that all participating reviewers are satisfied.
+On the other hand, whenever possible, reviewers who have minor comments should
explicitly mention that they are OK with the PR being merged after or
potentially *without* addressing them.
+
+When submitting a change, explicitly soliciting a specific reviewer explicitly
is currently not needed, as the entire review team is generally pinged for pull
requests.
+Nevertheless, submitters may choose to do so if they want specific review from
an individual, or if a pull request is sitting without review for a period of
time.
+For the latter scenario, leaving a comment on the pull request or in Slack is
also reasonable.
+
+Confirming that a pull request runs successfully on an implementation is *not*
generally sufficient to merge, though it is helpful evidence, and highly
encouraged.
+Proposed changes should be confirmed by reading the specification and ensuring
the behavior is specified and correct.
+Submitters are encouraged to link to the specification whenever doing so will
be helpful to a reviewer.
+
+A reviewer may indicate that the proposed changes are too large for them to
review.
+In such cases the submitter may wait for another reviewer who is comfortable
reviewing the changes, but is generally strongly encouraged to split up the
changes into multiple smaller ones.
+
+Reviewing pull requests is an extremely valuable contribution!
+New reviewers are highly encouraged to attempt to review pull requests even if
they do not have experience doing so, and to themselves expect feedback from
the submitter or from other reviewers on improving the quality of their reviews.
+In such cases the submitter should use their judgement to decide whether the
new contributor's review is sufficient for merging, or whether they should wait
for further feedback.
+
+## Merging Changes
+
+Approval of a change may be given using the GitHub UI or via a comment reply.
+Once it has been given, the pull request may be merged at any point.
+
+To merge a pull request, *either* the submitter or reviewer must have commit
access to the repo (though this is also partially simply because that party's
access is needed to merge).
+
+*Either* the submitter or reviewer may be the one to do the actual merge
(whether via hitting the merge button or externally to the GitHub UI).
+If the submitter wishes to make final changes after a review they should
attempt to say so (and thereby take responsibility for merging themselves).
+Contributors *should not* leave pull requests stagnant whenever possible, and
particularly after they have been reviewed and approved.
+
+Changes should not be merged while continuous integration is failing.
+Failures typically are not spurious and indicate issues with the changes.
+In the event the change is indeed correct and CI is flaky or itself incorrect,
effort should be made by the submitter, reviewer, or a solicited other
contributor to fix the CI before the change is made.
+Improvements to CI itself are very valuable as well, and reviewers who find
repeated issues with proposed changes are highly encouraged to improve CI for
any changes which may be automatically detected.
+
+Changes should be merged *as-is* and not squashed into single commits.
+Submitters are free to structure their commits as they wish throughout the
review process, or in some cases to restructure the commits after a review is
finished and they are merging the branch, but are not required to do so, and
reviewers should not do so on behalf of the submitter without being requested
to do so.
+
+Contributors with commit access may choose to merge pull requests (or commit
directly) to the repository for trivial changes.
+The definition of "trivial" is intentionally slightly ambiguous, and intended
to be followed by good-faith contributors.
+An example of a trivial change is fixing a typo in the README, or bumping a
version of a dependency used by the continuous integration suite.
+If another contributor takes issue with a change merged in this fashion,
simply commenting politely that they have concerns about the change (either in
an issue or directly) is the right remedy.
+
+## Writing Good Tests
+
+Be familiar with the test structure and assumptions documented in the
[README](README.md).
+
+Test cases should include both valid and invalid instances which exercise the
test case schema whenever possible.
+Exceptions include schemas where only one result is ever possible (such as the
`false` schema, or ones using keywords which only produce annotations).
+
+Schemas should be *minimal*, by which we mean that they should contain only
those keywords which are being tested by the specific test case, and should not
contain complex values when simpler ones would do.
+The same applies to instances -- prefer simpler instances to more complex
ones, and when testing string instances, consider using ones which are
self-descriptive whenever it aids readability.
+
+Comments can and should be used to explain tests which are unclear or complex.
+The `comment` field is present both for test cases and individual tests for
this purpose.
+Links to the relevant specification sections are also encouraged, though they
can be tedious to maintain from one version to the next.
+
+When adding test cases, they should be added to all past (and future) versions
of the specification which they apply to, potentially with minor modifications
(e.g. changing `$id` to `id` or accounting for `$ref` not allowing siblings on
older drafts).
+
+Changing the schema used in a particular test case should be done with extra
caution, though it is not formally discouraged if the change simplifies the
schema.
+Contributors should not generally append *additional* behavior to existing
test case schemas, unless doing so has specific justification.
+Instead, new cases should be added, as it can often be subtle to predict which
precise parts of a test case are unique.
+Adding additional *tests* however (instances) is of course safe and encouraged
if gaps are found.
+
+Tests which are *incorrect* (against the specification) should be prioritized
for fixing or removal whenever possible, as their continued presence in the
suite can create confusion for downstream users of the suite.
+
+## Proposing Changes to the Policy
+
+This policy itself is of course changeable, and changes to it may be proposed
in a discussion.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/jsonschema-4.17.0/json/README.md
new/jsonschema-4.17.1/json/README.md
--- old/jsonschema-4.17.0/json/README.md 2020-02-02 01:00:00.000000000
+0100
+++ new/jsonschema-4.17.1/json/README.md 2020-02-02 01:00:00.000000000
+0100
@@ -224,6 +224,7 @@
### C++
* [Modern C++ JSON schema
validator](https://github.com/pboettch/json-schema-validator)
+* [Valijson](https://github.com/tristanpenman/valijson)
### Dart
@@ -339,3 +340,5 @@
them with `bin/jsonschema_suite check` or `tox`. They will be run automatically
by [GitHub
Actions](https://github.com/json-schema-org/JSON-Schema-Test-Suite/actions?query=workflow%3A%22Test+Suite+Sanity+Checking%22)
as well.
+
+This repository is maintained by the JSON Schema organization, and will be
governed by the JSON Schema steering committee (once it exists).
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/jsonschema-4.17.0/json/remotes/draft-next/format-assertion-false.json
new/jsonschema-4.17.1/json/remotes/draft-next/format-assertion-false.json
--- old/jsonschema-4.17.0/json/remotes/draft-next/format-assertion-false.json
2020-02-02 01:00:00.000000000 +0100
+++ new/jsonschema-4.17.1/json/remotes/draft-next/format-assertion-false.json
2020-02-02 01:00:00.000000000 +0100
@@ -6,7 +6,7 @@
"https://json-schema.org/draft/next/vocab/format-assertion": false
},
"allOf": [
- { "$ref": "https://json-schema.org/draft/next/schema/meta/core"; },
- { "$ref":
"https://json-schema.org/draft/next/schema/meta/format-assertion"; }
+ { "$ref": "https://json-schema.org/draft/next/meta/core"; },
+ { "$ref": "https://json-schema.org/draft/next/meta/format-assertion"; }
]
}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/jsonschema-4.17.0/json/remotes/draft-next/format-assertion-true.json
new/jsonschema-4.17.1/json/remotes/draft-next/format-assertion-true.json
--- old/jsonschema-4.17.0/json/remotes/draft-next/format-assertion-true.json
2020-02-02 01:00:00.000000000 +0100
+++ new/jsonschema-4.17.1/json/remotes/draft-next/format-assertion-true.json
2020-02-02 01:00:00.000000000 +0100
@@ -6,7 +6,7 @@
"https://json-schema.org/draft/next/vocab/format-assertion": true
},
"allOf": [
- { "$ref": "https://json-schema.org/draft/next/schema/meta/core"; },
- { "$ref":
"https://json-schema.org/draft/next/schema/meta/format-assertion"; }
+ { "$ref": "https://json-schema.org/draft/next/meta/core"; },
+ { "$ref": "https://json-schema.org/draft/next/meta/format-assertion"; }
]
}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/jsonschema-4.17.0/json/remotes/draft2020-12/format-assertion-false.json
new/jsonschema-4.17.1/json/remotes/draft2020-12/format-assertion-false.json
--- old/jsonschema-4.17.0/json/remotes/draft2020-12/format-assertion-false.json
2020-02-02 01:00:00.000000000 +0100
+++ new/jsonschema-4.17.1/json/remotes/draft2020-12/format-assertion-false.json
2020-02-02 01:00:00.000000000 +0100
@@ -6,7 +6,7 @@
"https://json-schema.org/draft/2020-12/vocab/format-assertion": false
},
"allOf": [
- { "$ref": "https://json-schema.org/draft/2020-12/schema/meta/core"; },
- { "$ref":
"https://json-schema.org/draft/2020-12/schema/meta/format-assertion"; }
+ { "$ref": "https://json-schema.org/draft/2020-12/meta/core"; },
+ { "$ref":
"https://json-schema.org/draft/2020-12/meta/format-assertion"; }
]
}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/jsonschema-4.17.0/json/remotes/draft2020-12/format-assertion-true.json
new/jsonschema-4.17.1/json/remotes/draft2020-12/format-assertion-true.json
--- old/jsonschema-4.17.0/json/remotes/draft2020-12/format-assertion-true.json
2020-02-02 01:00:00.000000000 +0100
+++ new/jsonschema-4.17.1/json/remotes/draft2020-12/format-assertion-true.json
2020-02-02 01:00:00.000000000 +0100
@@ -6,7 +6,7 @@
"https://json-schema.org/draft/2020-12/vocab/format-assertion": true
},
"allOf": [
- { "$ref": "https://json-schema.org/draft/2020-12/schema/meta/core"; },
- { "$ref":
"https://json-schema.org/draft/2020-12/schema/meta/format-assertion"; }
+ { "$ref": "https://json-schema.org/draft/2020-12/meta/core"; },
+ { "$ref":
"https://json-schema.org/draft/2020-12/meta/format-assertion"; }
]
}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/jsonschema-4.17.0/json/tests/draft-next/ref.json
new/jsonschema-4.17.1/json/tests/draft-next/ref.json
--- old/jsonschema-4.17.0/json/tests/draft-next/ref.json 2020-02-02
01:00:00.000000000 +0100
+++ new/jsonschema-4.17.1/json/tests/draft-next/ref.json 2020-02-02
01:00:00.000000000 +0100
@@ -638,7 +638,7 @@
"$ref": "#bigint",
"$defs": {
"bigint": {
- "$comment": "canonical uri:
/ref-and-id2/base.json/$defs/bigint; another valid uri for this location:
/ref-and-id2/base.json#bigint",
+ "$comment": "canonical uri:
/ref-and-id2/base.json#/$defs/bigint; another valid uri for this location:
/ref-and-id2/base.json#bigint",
"$anchor": "bigint",
"maximum": 10
},
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/jsonschema-4.17.0/json/tests/draft-next/unevaluatedProperties.json
new/jsonschema-4.17.1/json/tests/draft-next/unevaluatedProperties.json
--- old/jsonschema-4.17.0/json/tests/draft-next/unevaluatedProperties.json
2020-02-02 01:00:00.000000000 +0100
+++ new/jsonschema-4.17.1/json/tests/draft-next/unevaluatedProperties.json
2020-02-02 01:00:00.000000000 +0100
@@ -741,6 +741,31 @@
]
},
{
+ "description": "unevaluatedProperties can't see inside cousins
(reverse order)",
+ "schema": {
+ "$schema": "https://json-schema.org/draft/next/schema";,
+ "allOf": [
+ {
+ "unevaluatedProperties": false
+ },
+ {
+ "properties": {
+ "foo": true
+ }
+ }
+ ]
+ },
+ "tests": [
+ {
+ "description": "always fails",
+ "data": {
+ "foo": 1
+ },
+ "valid": false
+ }
+ ]
+ },
+ {
"description": "nested unevaluatedProperties, outer false, inner true,
properties outside",
"schema": {
"$schema": "https://json-schema.org/draft/next/schema";,
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/jsonschema-4.17.0/json/tests/draft2019-09/ref.json
new/jsonschema-4.17.1/json/tests/draft2019-09/ref.json
--- old/jsonschema-4.17.0/json/tests/draft2019-09/ref.json 2020-02-02
01:00:00.000000000 +0100
+++ new/jsonschema-4.17.1/json/tests/draft2019-09/ref.json 2020-02-02
01:00:00.000000000 +0100
@@ -638,7 +638,7 @@
"$ref": "#bigint",
"$defs": {
"bigint": {
- "$comment": "canonical uri:
/draft2019-09/ref-and-id2/base.json/$defs/bigint; another valid uri for this
location: /ref-and-id2/base.json#bigint",
+ "$comment": "canonical uri:
/draft2019-09/ref-and-id2/base.json#/$defs/bigint; another valid uri for this
location: /ref-and-id2/base.json#bigint",
"$anchor": "bigint",
"maximum": 10
},
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/jsonschema-4.17.0/json/tests/draft2019-09/unevaluatedProperties.json
new/jsonschema-4.17.1/json/tests/draft2019-09/unevaluatedProperties.json
--- old/jsonschema-4.17.0/json/tests/draft2019-09/unevaluatedProperties.json
2020-02-02 01:00:00.000000000 +0100
+++ new/jsonschema-4.17.1/json/tests/draft2019-09/unevaluatedProperties.json
2020-02-02 01:00:00.000000000 +0100
@@ -741,6 +741,31 @@
]
},
{
+ "description": "unevaluatedProperties can't see inside cousins
(reverse order)",
+ "schema": {
+ "$schema": "https://json-schema.org/draft/2019-09/schema";,
+ "allOf": [
+ {
+ "unevaluatedProperties": false
+ },
+ {
+ "properties": {
+ "foo": true
+ }
+ }
+ ]
+ },
+ "tests": [
+ {
+ "description": "always fails",
+ "data": {
+ "foo": 1
+ },
+ "valid": false
+ }
+ ]
+ },
+ {
"description": "nested unevaluatedProperties, outer false, inner true,
properties outside",
"schema": {
"$schema": "https://json-schema.org/draft/2019-09/schema";,
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/jsonschema-4.17.0/json/tests/draft2020-12/ref.json
new/jsonschema-4.17.1/json/tests/draft2020-12/ref.json
--- old/jsonschema-4.17.0/json/tests/draft2020-12/ref.json 2020-02-02
01:00:00.000000000 +0100
+++ new/jsonschema-4.17.1/json/tests/draft2020-12/ref.json 2020-02-02
01:00:00.000000000 +0100
@@ -638,7 +638,7 @@
"$ref": "#bigint",
"$defs": {
"bigint": {
- "$comment": "canonical uri:
/ref-and-id2/base.json/$defs/bigint; another valid uri for this location:
/ref-and-id2/base.json#bigint",
+ "$comment": "canonical uri:
/ref-and-id2/base.json#/$defs/bigint; another valid uri for this location:
/ref-and-id2/base.json#bigint",
"$anchor": "bigint",
"maximum": 10
},
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/jsonschema-4.17.0/json/tests/draft2020-12/unevaluatedProperties.json
new/jsonschema-4.17.1/json/tests/draft2020-12/unevaluatedProperties.json
--- old/jsonschema-4.17.0/json/tests/draft2020-12/unevaluatedProperties.json
2020-02-02 01:00:00.000000000 +0100
+++ new/jsonschema-4.17.1/json/tests/draft2020-12/unevaluatedProperties.json
2020-02-02 01:00:00.000000000 +0100
@@ -741,6 +741,31 @@
]
},
{
+ "description": "unevaluatedProperties can't see inside cousins
(reverse order)",
+ "schema": {
+ "$schema": "https://json-schema.org/draft/2020-12/schema";,
+ "allOf": [
+ {
+ "unevaluatedProperties": false
+ },
+ {
+ "properties": {
+ "foo": true
+ }
+ }
+ ]
+ },
+ "tests": [
+ {
+ "description": "always fails",
+ "data": {
+ "foo": 1
+ },
+ "valid": false
+ }
+ ]
+ },
+ {
"description": "nested unevaluatedProperties, outer false, inner true,
properties outside",
"schema": {
"$schema": "https://json-schema.org/draft/2020-12/schema";,
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/jsonschema-4.17.0/jsonschema/_format.py
new/jsonschema-4.17.1/jsonschema/_format.py
--- old/jsonschema-4.17.0/jsonschema/_format.py 2020-02-02 01:00:00.000000000
+0100
+++ new/jsonschema-4.17.1/jsonschema/_format.py 2020-02-02 01:00:00.000000000
+0100
@@ -44,7 +44,7 @@
tuple[_FormatCheckCallable, _RaisesType],
] = {}
- def __init__(self, formats: typing.Iterable[str] = None):
+ def __init__(self, formats: typing.Iterable[str] | None = None):
if formats is None:
formats = self.checkers.keys()
self.checkers = {k: self.checkers[k] for k in formats}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/jsonschema-4.17.0/jsonschema/_validators.py
new/jsonschema-4.17.1/jsonschema/_validators.py
--- old/jsonschema-4.17.0/jsonschema/_validators.py 2020-02-02
01:00:00.000000000 +0100
+++ new/jsonschema-4.17.1/jsonschema/_validators.py 2020-02-02
01:00:00.000000000 +0100
@@ -435,23 +435,32 @@
def unevaluatedProperties(validator, unevaluatedProperties, instance, schema):
if not validator.is_type(instance, "object"):
return
- evaluated_property_keys = find_evaluated_property_keys_by_schema(
+ evaluated_keys = find_evaluated_property_keys_by_schema(
validator, instance, schema,
)
- unevaluated_property_keys = []
+ unevaluated_keys = []
for property in instance:
- if property not in evaluated_property_keys:
+ if property not in evaluated_keys:
for _ in validator.descend(
instance[property],
unevaluatedProperties,
path=property,
schema_path=property,
):
- unevaluated_property_keys.append(property)
+ # FIXME: Include context for each unevaluated property
+ # indicating why it's invalid under the subschema.
+ unevaluated_keys.append(property)
- if unevaluated_property_keys:
- error = "Unevaluated properties are not allowed (%s %s unexpected)"
- yield ValidationError(error % extras_msg(unevaluated_property_keys))
+ if unevaluated_keys:
+ if unevaluatedProperties is False:
+ error = "Unevaluated properties are not allowed (%s %s unexpected)"
+ yield ValidationError(error % extras_msg(unevaluated_keys))
+ else:
+ error = (
+ "Unevaluated properties are not valid under "
+ "the given schema (%s %s unevaluated and invalid)"
+ )
+ yield ValidationError(error % extras_msg(unevaluated_keys))
def prefixItems(validator, prefixItems, instance, schema):
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2019-09/applicator
new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2019-09/applicator
---
old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2019-09/applicator
1970-01-01 01:00:00.000000000 +0100
+++
new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2019-09/applicator
2020-02-02 01:00:00.000000000 +0100
@@ -0,0 +1,56 @@
+{
+ "$schema": "https://json-schema.org/draft/2019-09/schema";,
+ "$id": "https://json-schema.org/draft/2019-09/meta/applicator";,
+ "$vocabulary": {
+ "https://json-schema.org/draft/2019-09/vocab/applicator": true
+ },
+ "$recursiveAnchor": true,
+
+ "title": "Applicator vocabulary meta-schema",
+ "type": ["object", "boolean"],
+ "properties": {
+ "additionalItems": { "$recursiveRef": "#" },
+ "unevaluatedItems": { "$recursiveRef": "#" },
+ "items": {
+ "anyOf": [
+ { "$recursiveRef": "#" },
+ { "$ref": "#/$defs/schemaArray" }
+ ]
+ },
+ "contains": { "$recursiveRef": "#" },
+ "additionalProperties": { "$recursiveRef": "#" },
+ "unevaluatedProperties": { "$recursiveRef": "#" },
+ "properties": {
+ "type": "object",
+ "additionalProperties": { "$recursiveRef": "#" },
+ "default": {}
+ },
+ "patternProperties": {
+ "type": "object",
+ "additionalProperties": { "$recursiveRef": "#" },
+ "propertyNames": { "format": "regex" },
+ "default": {}
+ },
+ "dependentSchemas": {
+ "type": "object",
+ "additionalProperties": {
+ "$recursiveRef": "#"
+ }
+ },
+ "propertyNames": { "$recursiveRef": "#" },
+ "if": { "$recursiveRef": "#" },
+ "then": { "$recursiveRef": "#" },
+ "else": { "$recursiveRef": "#" },
+ "allOf": { "$ref": "#/$defs/schemaArray" },
+ "anyOf": { "$ref": "#/$defs/schemaArray" },
+ "oneOf": { "$ref": "#/$defs/schemaArray" },
+ "not": { "$recursiveRef": "#" }
+ },
+ "$defs": {
+ "schemaArray": {
+ "type": "array",
+ "minItems": 1,
+ "items": { "$recursiveRef": "#" }
+ }
+ }
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2019-09/content
new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2019-09/content
--- old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2019-09/content
1970-01-01 01:00:00.000000000 +0100
+++ new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2019-09/content
2020-02-02 01:00:00.000000000 +0100
@@ -0,0 +1,17 @@
+{
+ "$schema": "https://json-schema.org/draft/2019-09/schema";,
+ "$id": "https://json-schema.org/draft/2019-09/meta/content";,
+ "$vocabulary": {
+ "https://json-schema.org/draft/2019-09/vocab/content": true
+ },
+ "$recursiveAnchor": true,
+
+ "title": "Content vocabulary meta-schema",
+
+ "type": ["object", "boolean"],
+ "properties": {
+ "contentMediaType": { "type": "string" },
+ "contentEncoding": { "type": "string" },
+ "contentSchema": { "$recursiveRef": "#" }
+ }
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2019-09/core
new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2019-09/core
--- old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2019-09/core
1970-01-01 01:00:00.000000000 +0100
+++ new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2019-09/core
2020-02-02 01:00:00.000000000 +0100
@@ -0,0 +1,57 @@
+{
+ "$schema": "https://json-schema.org/draft/2019-09/schema";,
+ "$id": "https://json-schema.org/draft/2019-09/meta/core";,
+ "$vocabulary": {
+ "https://json-schema.org/draft/2019-09/vocab/core": true
+ },
+ "$recursiveAnchor": true,
+
+ "title": "Core vocabulary meta-schema",
+ "type": ["object", "boolean"],
+ "properties": {
+ "$id": {
+ "type": "string",
+ "format": "uri-reference",
+ "$comment": "Non-empty fragments not allowed.",
+ "pattern": "^[^#]*#?$"
+ },
+ "$schema": {
+ "type": "string",
+ "format": "uri"
+ },
+ "$anchor": {
+ "type": "string",
+ "pattern": "^[A-Za-z][-A-Za-z0-9.:_]*$"
+ },
+ "$ref": {
+ "type": "string",
+ "format": "uri-reference"
+ },
+ "$recursiveRef": {
+ "type": "string",
+ "format": "uri-reference"
+ },
+ "$recursiveAnchor": {
+ "type": "boolean",
+ "default": false
+ },
+ "$vocabulary": {
+ "type": "object",
+ "propertyNames": {
+ "type": "string",
+ "format": "uri"
+ },
+ "additionalProperties": {
+ "type": "boolean"
+ }
+ },
+ "$comment": {
+ "type": "string"
+ },
+ "$defs": {
+ "type": "object",
+ "additionalProperties": { "$recursiveRef": "#" },
+ "default": {}
+ }
+ }
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2019-09/meta-data
new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2019-09/meta-data
---
old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2019-09/meta-data
1970-01-01 01:00:00.000000000 +0100
+++
new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2019-09/meta-data
2020-02-02 01:00:00.000000000 +0100
@@ -0,0 +1,37 @@
+{
+ "$schema": "https://json-schema.org/draft/2019-09/schema";,
+ "$id": "https://json-schema.org/draft/2019-09/meta/meta-data";,
+ "$vocabulary": {
+ "https://json-schema.org/draft/2019-09/vocab/meta-data": true
+ },
+ "$recursiveAnchor": true,
+
+ "title": "Meta-data vocabulary meta-schema",
+
+ "type": ["object", "boolean"],
+ "properties": {
+ "title": {
+ "type": "string"
+ },
+ "description": {
+ "type": "string"
+ },
+ "default": true,
+ "deprecated": {
+ "type": "boolean",
+ "default": false
+ },
+ "readOnly": {
+ "type": "boolean",
+ "default": false
+ },
+ "writeOnly": {
+ "type": "boolean",
+ "default": false
+ },
+ "examples": {
+ "type": "array",
+ "items": true
+ }
+ }
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2019-09/validation
new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2019-09/validation
---
old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2019-09/validation
1970-01-01 01:00:00.000000000 +0100
+++
new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2019-09/validation
2020-02-02 01:00:00.000000000 +0100
@@ -0,0 +1,98 @@
+{
+ "$schema": "https://json-schema.org/draft/2019-09/schema";,
+ "$id": "https://json-schema.org/draft/2019-09/meta/validation";,
+ "$vocabulary": {
+ "https://json-schema.org/draft/2019-09/vocab/validation": true
+ },
+ "$recursiveAnchor": true,
+
+ "title": "Validation vocabulary meta-schema",
+ "type": ["object", "boolean"],
+ "properties": {
+ "multipleOf": {
+ "type": "number",
+ "exclusiveMinimum": 0
+ },
+ "maximum": {
+ "type": "number"
+ },
+ "exclusiveMaximum": {
+ "type": "number"
+ },
+ "minimum": {
+ "type": "number"
+ },
+ "exclusiveMinimum": {
+ "type": "number"
+ },
+ "maxLength": { "$ref": "#/$defs/nonNegativeInteger" },
+ "minLength": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+ "pattern": {
+ "type": "string",
+ "format": "regex"
+ },
+ "maxItems": { "$ref": "#/$defs/nonNegativeInteger" },
+ "minItems": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+ "uniqueItems": {
+ "type": "boolean",
+ "default": false
+ },
+ "maxContains": { "$ref": "#/$defs/nonNegativeInteger" },
+ "minContains": {
+ "$ref": "#/$defs/nonNegativeInteger",
+ "default": 1
+ },
+ "maxProperties": { "$ref": "#/$defs/nonNegativeInteger" },
+ "minProperties": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+ "required": { "$ref": "#/$defs/stringArray" },
+ "dependentRequired": {
+ "type": "object",
+ "additionalProperties": {
+ "$ref": "#/$defs/stringArray"
+ }
+ },
+ "const": true,
+ "enum": {
+ "type": "array",
+ "items": true
+ },
+ "type": {
+ "anyOf": [
+ { "$ref": "#/$defs/simpleTypes" },
+ {
+ "type": "array",
+ "items": { "$ref": "#/$defs/simpleTypes" },
+ "minItems": 1,
+ "uniqueItems": true
+ }
+ ]
+ }
+ },
+ "$defs": {
+ "nonNegativeInteger": {
+ "type": "integer",
+ "minimum": 0
+ },
+ "nonNegativeIntegerDefault0": {
+ "$ref": "#/$defs/nonNegativeInteger",
+ "default": 0
+ },
+ "simpleTypes": {
+ "enum": [
+ "array",
+ "boolean",
+ "integer",
+ "null",
+ "number",
+ "object",
+ "string"
+ ]
+ },
+ "stringArray": {
+ "type": "array",
+ "items": { "type": "string" },
+ "uniqueItems": true,
+ "default": []
+ }
+ }
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2020-12/applicator
new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2020-12/applicator
---
old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2020-12/applicator
1970-01-01 01:00:00.000000000 +0100
+++
new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2020-12/applicator
2020-02-02 01:00:00.000000000 +0100
@@ -0,0 +1,48 @@
+{
+ "$schema": "https://json-schema.org/draft/2020-12/schema";,
+ "$id": "https://json-schema.org/draft/2020-12/meta/applicator";,
+ "$vocabulary": {
+ "https://json-schema.org/draft/2020-12/vocab/applicator": true
+ },
+ "$dynamicAnchor": "meta",
+
+ "title": "Applicator vocabulary meta-schema",
+ "type": ["object", "boolean"],
+ "properties": {
+ "prefixItems": { "$ref": "#/$defs/schemaArray" },
+ "items": { "$dynamicRef": "#meta" },
+ "contains": { "$dynamicRef": "#meta" },
+ "additionalProperties": { "$dynamicRef": "#meta" },
+ "properties": {
+ "type": "object",
+ "additionalProperties": { "$dynamicRef": "#meta" },
+ "default": {}
+ },
+ "patternProperties": {
+ "type": "object",
+ "additionalProperties": { "$dynamicRef": "#meta" },
+ "propertyNames": { "format": "regex" },
+ "default": {}
+ },
+ "dependentSchemas": {
+ "type": "object",
+ "additionalProperties": { "$dynamicRef": "#meta" },
+ "default": {}
+ },
+ "propertyNames": { "$dynamicRef": "#meta" },
+ "if": { "$dynamicRef": "#meta" },
+ "then": { "$dynamicRef": "#meta" },
+ "else": { "$dynamicRef": "#meta" },
+ "allOf": { "$ref": "#/$defs/schemaArray" },
+ "anyOf": { "$ref": "#/$defs/schemaArray" },
+ "oneOf": { "$ref": "#/$defs/schemaArray" },
+ "not": { "$dynamicRef": "#meta" }
+ },
+ "$defs": {
+ "schemaArray": {
+ "type": "array",
+ "minItems": 1,
+ "items": { "$dynamicRef": "#meta" }
+ }
+ }
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2020-12/content
new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2020-12/content
--- old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2020-12/content
1970-01-01 01:00:00.000000000 +0100
+++ new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2020-12/content
2020-02-02 01:00:00.000000000 +0100
@@ -0,0 +1,17 @@
+{
+ "$schema": "https://json-schema.org/draft/2020-12/schema";,
+ "$id": "https://json-schema.org/draft/2020-12/meta/content";,
+ "$vocabulary": {
+ "https://json-schema.org/draft/2020-12/vocab/content": true
+ },
+ "$dynamicAnchor": "meta",
+
+ "title": "Content vocabulary meta-schema",
+
+ "type": ["object", "boolean"],
+ "properties": {
+ "contentEncoding": { "type": "string" },
+ "contentMediaType": { "type": "string" },
+ "contentSchema": { "$dynamicRef": "#meta" }
+ }
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2020-12/core
new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2020-12/core
--- old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2020-12/core
1970-01-01 01:00:00.000000000 +0100
+++ new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2020-12/core
2020-02-02 01:00:00.000000000 +0100
@@ -0,0 +1,51 @@
+{
+ "$schema": "https://json-schema.org/draft/2020-12/schema";,
+ "$id": "https://json-schema.org/draft/2020-12/meta/core";,
+ "$vocabulary": {
+ "https://json-schema.org/draft/2020-12/vocab/core": true
+ },
+ "$dynamicAnchor": "meta",
+
+ "title": "Core vocabulary meta-schema",
+ "type": ["object", "boolean"],
+ "properties": {
+ "$id": {
+ "$ref": "#/$defs/uriReferenceString",
+ "$comment": "Non-empty fragments not allowed.",
+ "pattern": "^[^#]*#?$"
+ },
+ "$schema": { "$ref": "#/$defs/uriString" },
+ "$ref": { "$ref": "#/$defs/uriReferenceString" },
+ "$anchor": { "$ref": "#/$defs/anchorString" },
+ "$dynamicRef": { "$ref": "#/$defs/uriReferenceString" },
+ "$dynamicAnchor": { "$ref": "#/$defs/anchorString" },
+ "$vocabulary": {
+ "type": "object",
+ "propertyNames": { "$ref": "#/$defs/uriString" },
+ "additionalProperties": {
+ "type": "boolean"
+ }
+ },
+ "$comment": {
+ "type": "string"
+ },
+ "$defs": {
+ "type": "object",
+ "additionalProperties": { "$dynamicRef": "#meta" }
+ }
+ },
+ "$defs": {
+ "anchorString": {
+ "type": "string",
+ "pattern": "^[A-Za-z_][-A-Za-z0-9._]*$"
+ },
+ "uriString": {
+ "type": "string",
+ "format": "uri"
+ },
+ "uriReferenceString": {
+ "type": "string",
+ "format": "uri-reference"
+ }
+ }
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2020-12/format
new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2020-12/format
--- old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2020-12/format
1970-01-01 01:00:00.000000000 +0100
+++ new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2020-12/format
2020-02-02 01:00:00.000000000 +0100
@@ -0,0 +1,14 @@
+{
+ "$schema": "https://json-schema.org/draft/2019-09/schema";,
+ "$id": "https://json-schema.org/draft/2019-09/meta/format";,
+ "$vocabulary": {
+ "https://json-schema.org/draft/2019-09/vocab/format": true
+ },
+ "$recursiveAnchor": true,
+
+ "title": "Format vocabulary meta-schema",
+ "type": ["object", "boolean"],
+ "properties": {
+ "format": { "type": "string" }
+ }
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2020-12/format-annotation
new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2020-12/format-annotation
---
old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2020-12/format-annotation
1970-01-01 01:00:00.000000000 +0100
+++
new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2020-12/format-annotation
2020-02-02 01:00:00.000000000 +0100
@@ -0,0 +1,14 @@
+{
+ "$schema": "https://json-schema.org/draft/2020-12/schema";,
+ "$id": "https://json-schema.org/draft/2020-12/meta/format-annotation";,
+ "$vocabulary": {
+ "https://json-schema.org/draft/2020-12/vocab/format-annotation": true
+ },
+ "$dynamicAnchor": "meta",
+
+ "title": "Format vocabulary meta-schema for annotation results",
+ "type": ["object", "boolean"],
+ "properties": {
+ "format": { "type": "string" }
+ }
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2020-12/format-assertion
new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2020-12/format-assertion
---
old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2020-12/format-assertion
1970-01-01 01:00:00.000000000 +0100
+++
new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2020-12/format-assertion
2020-02-02 01:00:00.000000000 +0100
@@ -0,0 +1,14 @@
+{
+ "$schema": "https://json-schema.org/draft/2020-12/schema";,
+ "$id": "https://json-schema.org/draft/2020-12/meta/format-assertion";,
+ "$vocabulary": {
+ "https://json-schema.org/draft/2020-12/vocab/format-assertion": true
+ },
+ "$dynamicAnchor": "meta",
+
+ "title": "Format vocabulary meta-schema for assertion results",
+ "type": ["object", "boolean"],
+ "properties": {
+ "format": { "type": "string" }
+ }
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2020-12/meta-data
new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2020-12/meta-data
---
old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2020-12/meta-data
1970-01-01 01:00:00.000000000 +0100
+++
new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2020-12/meta-data
2020-02-02 01:00:00.000000000 +0100
@@ -0,0 +1,37 @@
+{
+ "$schema": "https://json-schema.org/draft/2020-12/schema";,
+ "$id": "https://json-schema.org/draft/2020-12/meta/meta-data";,
+ "$vocabulary": {
+ "https://json-schema.org/draft/2020-12/vocab/meta-data": true
+ },
+ "$dynamicAnchor": "meta",
+
+ "title": "Meta-data vocabulary meta-schema",
+
+ "type": ["object", "boolean"],
+ "properties": {
+ "title": {
+ "type": "string"
+ },
+ "description": {
+ "type": "string"
+ },
+ "default": true,
+ "deprecated": {
+ "type": "boolean",
+ "default": false
+ },
+ "readOnly": {
+ "type": "boolean",
+ "default": false
+ },
+ "writeOnly": {
+ "type": "boolean",
+ "default": false
+ },
+ "examples": {
+ "type": "array",
+ "items": true
+ }
+ }
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2020-12/unevaluated
new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2020-12/unevaluated
---
old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2020-12/unevaluated
1970-01-01 01:00:00.000000000 +0100
+++
new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2020-12/unevaluated
2020-02-02 01:00:00.000000000 +0100
@@ -0,0 +1,15 @@
+{
+ "$schema": "https://json-schema.org/draft/2020-12/schema";,
+ "$id": "https://json-schema.org/draft/2020-12/meta/unevaluated";,
+ "$vocabulary": {
+ "https://json-schema.org/draft/2020-12/vocab/unevaluated": true
+ },
+ "$dynamicAnchor": "meta",
+
+ "title": "Unevaluated applicator vocabulary meta-schema",
+ "type": ["object", "boolean"],
+ "properties": {
+ "unevaluatedItems": { "$dynamicRef": "#meta" },
+ "unevaluatedProperties": { "$dynamicRef": "#meta" }
+ }
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2020-12/validation
new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2020-12/validation
---
old/jsonschema-4.17.0/jsonschema/schemas/vocabularies/draft2020-12/validation
1970-01-01 01:00:00.000000000 +0100
+++
new/jsonschema-4.17.1/jsonschema/schemas/vocabularies/draft2020-12/validation
2020-02-02 01:00:00.000000000 +0100
@@ -0,0 +1,98 @@
+{
+ "$schema": "https://json-schema.org/draft/2020-12/schema";,
+ "$id": "https://json-schema.org/draft/2020-12/meta/validation";,
+ "$vocabulary": {
+ "https://json-schema.org/draft/2020-12/vocab/validation": true
+ },
+ "$dynamicAnchor": "meta",
+
+ "title": "Validation vocabulary meta-schema",
+ "type": ["object", "boolean"],
+ "properties": {
+ "type": {
+ "anyOf": [
+ { "$ref": "#/$defs/simpleTypes" },
+ {
+ "type": "array",
+ "items": { "$ref": "#/$defs/simpleTypes" },
+ "minItems": 1,
+ "uniqueItems": true
+ }
+ ]
+ },
+ "const": true,
+ "enum": {
+ "type": "array",
+ "items": true
+ },
+ "multipleOf": {
+ "type": "number",
+ "exclusiveMinimum": 0
+ },
+ "maximum": {
+ "type": "number"
+ },
+ "exclusiveMaximum": {
+ "type": "number"
+ },
+ "minimum": {
+ "type": "number"
+ },
+ "exclusiveMinimum": {
+ "type": "number"
+ },
+ "maxLength": { "$ref": "#/$defs/nonNegativeInteger" },
+ "minLength": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+ "pattern": {
+ "type": "string",
+ "format": "regex"
+ },
+ "maxItems": { "$ref": "#/$defs/nonNegativeInteger" },
+ "minItems": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+ "uniqueItems": {
+ "type": "boolean",
+ "default": false
+ },
+ "maxContains": { "$ref": "#/$defs/nonNegativeInteger" },
+ "minContains": {
+ "$ref": "#/$defs/nonNegativeInteger",
+ "default": 1
+ },
+ "maxProperties": { "$ref": "#/$defs/nonNegativeInteger" },
+ "minProperties": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+ "required": { "$ref": "#/$defs/stringArray" },
+ "dependentRequired": {
+ "type": "object",
+ "additionalProperties": {
+ "$ref": "#/$defs/stringArray"
+ }
+ }
+ },
+ "$defs": {
+ "nonNegativeInteger": {
+ "type": "integer",
+ "minimum": 0
+ },
+ "nonNegativeIntegerDefault0": {
+ "$ref": "#/$defs/nonNegativeInteger",
+ "default": 0
+ },
+ "simpleTypes": {
+ "enum": [
+ "array",
+ "boolean",
+ "integer",
+ "null",
+ "number",
+ "object",
+ "string"
+ ]
+ },
+ "stringArray": {
+ "type": "array",
+ "items": { "type": "string" },
+ "uniqueItems": true,
+ "default": []
+ }
+ }
+}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/jsonschema-4.17.0/jsonschema/schemas/vocabularies.json
new/jsonschema-4.17.1/jsonschema/schemas/vocabularies.json
--- old/jsonschema-4.17.0/jsonschema/schemas/vocabularies.json 2020-02-02
01:00:00.000000000 +0100
+++ new/jsonschema-4.17.1/jsonschema/schemas/vocabularies.json 1970-01-01
01:00:00.000000000 +0100
@@ -1 +0,0 @@
-{"https://json-schema.org/draft/2020-12/meta/content": {"$schema":
"https://json-schema.org/draft/2020-12/schema";, "$id":
"https://json-schema.org/draft/2020-12/meta/content";, "$vocabulary":
{"https://json-schema.org/draft/2020-12/vocab/content": true},
"$dynamicAnchor": "meta", "title": "Content vocabulary meta-schema", "type":
["object", "boolean"], "properties": {"contentEncoding": {"type": "string"},
"contentMediaType": {"type": "string"}, "contentSchema": {"$dynamicRef":
"#meta"}}}, "https://json-schema.org/draft/2020-12/meta/unevaluated":
{"$schema": "https://json-schema.org/draft/2020-12/schema";, "$id":
"https://json-schema.org/draft/2020-12/meta/unevaluated";, "$vocabulary":
{"https://json-schema.org/draft/2020-12/vocab/unevaluated": true},
"$dynamicAnchor": "meta", "title": "Unevaluated applicator vocabulary
meta-schema", "type": ["object", "boolean"], "properties": {"unevaluatedItems":
{"$dynamicRef": "#meta"}, "unevaluatedProperties": {"$dynamicRef": "#meta"}}},
"https://j
son-schema.org/draft/2020-12/meta/format-annotation": {"$schema":
"https://json-schema.org/draft/2020-12/schema";, "$id":
"https://json-schema.org/draft/2020-12/meta/format-annotation";, "$vocabulary":
{"https://json-schema.org/draft/2020-12/vocab/format-annotation": true},
"$dynamicAnchor": "meta", "title": "Format vocabulary meta-schema for
annotation results", "type": ["object", "boolean"], "properties": {"format":
{"type": "string"}}}, "https://json-schema.org/draft/2020-12/meta/applicator":
{"$schema": "https://json-schema.org/draft/2020-12/schema";, "$id":
"https://json-schema.org/draft/2020-12/meta/applicator";, "$vocabulary":
{"https://json-schema.org/draft/2020-12/vocab/applicator": true},
"$dynamicAnchor": "meta", "title": "Applicator vocabulary meta-schema", "type":
["object", "boolean"], "properties": {"prefixItems": {"$ref":
"#/$defs/schemaArray"}, "items": {"$dynamicRef": "#meta"}, "contains":
{"$dynamicRef": "#meta"}, "additionalProperties": {"$dynamicRef": "#meta"}, "pro
perties": {"type": "object", "additionalProperties": {"$dynamicRef": "#meta"},
"default": {}}, "patternProperties": {"type": "object", "additionalProperties":
{"$dynamicRef": "#meta"}, "propertyNames": {"format": "regex"}, "default": {}},
"dependentSchemas": {"type": "object", "additionalProperties": {"$dynamicRef":
"#meta"}, "default": {}}, "propertyNames": {"$dynamicRef": "#meta"}, "if":
{"$dynamicRef": "#meta"}, "then": {"$dynamicRef": "#meta"}, "else":
{"$dynamicRef": "#meta"}, "allOf": {"$ref": "#/$defs/schemaArray"}, "anyOf":
{"$ref": "#/$defs/schemaArray"}, "oneOf": {"$ref": "#/$defs/schemaArray"},
"not": {"$dynamicRef": "#meta"}}, "$defs": {"schemaArray": {"type": "array",
"minItems": 1, "items": {"$dynamicRef": "#meta"}}}},
"https://json-schema.org/draft/2020-12/meta/meta-data": {"$schema":
"https://json-schema.org/draft/2020-12/schema";, "$id":
"https://json-schema.org/draft/2020-12/meta/meta-data";, "$vocabulary":
{"https://json-schema.org/draft/2020-12/vocab/meta-data": tr
ue}, "$dynamicAnchor": "meta", "title": "Meta-data vocabulary meta-schema",
"type": ["object", "boolean"], "properties": {"title": {"type": "string"},
"description": {"type": "string"}, "default": true, "deprecated": {"type":
"boolean", "default": false}, "readOnly": {"type": "boolean", "default":
false}, "writeOnly": {"type": "boolean", "default": false}, "examples":
{"type": "array", "items": true}}},
"https://json-schema.org/draft/2020-12/meta/core": {"$schema":
"https://json-schema.org/draft/2020-12/schema";, "$id":
"https://json-schema.org/draft/2020-12/meta/core";, "$vocabulary":
{"https://json-schema.org/draft/2020-12/vocab/core": true}, "$dynamicAnchor":
"meta", "title": "Core vocabulary meta-schema", "type": ["object", "boolean"],
"properties": {"$id": {"$ref": "#/$defs/uriReferenceString", "$comment":
"Non-empty fragments not allowed.", "pattern": "^[^#]*#?$"}, "$schema":
{"$ref": "#/$defs/uriString"}, "$ref": {"$ref": "#/$defs/uriReferenceString"},
"$anchor": {"$ref": "#/$d
efs/anchorString"}, "$dynamicRef": {"$ref": "#/$defs/uriReferenceString"},
"$dynamicAnchor": {"$ref": "#/$defs/anchorString"}, "$vocabulary": {"type":
"object", "propertyNames": {"$ref": "#/$defs/uriString"},
"additionalProperties": {"type": "boolean"}}, "$comment": {"type": "string"},
"$defs": {"type": "object", "additionalProperties": {"$dynamicRef": "#meta"}}},
"$defs": {"anchorString": {"type": "string", "pattern":
"^[A-Za-z_][-A-Za-z0-9._]*$"}, "uriString": {"type": "string", "format":
"uri"}, "uriReferenceString": {"type": "string", "format": "uri-reference"}}},
"https://json-schema.org/draft/2020-12/meta/validation": {"$schema":
"https://json-schema.org/draft/2020-12/schema";, "$id":
"https://json-schema.org/draft/2020-12/meta/validation";, "$vocabulary":
{"https://json-schema.org/draft/2020-12/vocab/validation": true},
"$dynamicAnchor": "meta", "title": "Validation vocabulary meta-schema", "type":
["object", "boolean"], "properties": {"type": {"anyOf": [{"$ref": "#/$defs/simpl
eTypes"}, {"type": "array", "items": {"$ref": "#/$defs/simpleTypes"},
"minItems": 1, "uniqueItems": true}]}, "const": true, "enum": {"type": "array",
"items": true}, "multipleOf": {"type": "number", "exclusiveMinimum": 0},
"maximum": {"type": "number"}, "exclusiveMaximum": {"type": "number"},
"minimum": {"type": "number"}, "exclusiveMinimum": {"type": "number"},
"maxLength": {"$ref": "#/$defs/nonNegativeInteger"}, "minLength": {"$ref":
"#/$defs/nonNegativeIntegerDefault0"}, "pattern": {"type": "string", "format":
"regex"}, "maxItems": {"$ref": "#/$defs/nonNegativeInteger"}, "minItems":
{"$ref": "#/$defs/nonNegativeIntegerDefault0"}, "uniqueItems": {"type":
"boolean", "default": false}, "maxContains": {"$ref":
"#/$defs/nonNegativeInteger"}, "minContains": {"$ref":
"#/$defs/nonNegativeInteger", "default": 1}, "maxProperties": {"$ref":
"#/$defs/nonNegativeInteger"}, "minProperties": {"$ref":
"#/$defs/nonNegativeIntegerDefault0"}, "required": {"$ref":
"#/$defs/stringArray"}, "dependentR
equired": {"type": "object", "additionalProperties": {"$ref":
"#/$defs/stringArray"}}}, "$defs": {"nonNegativeInteger": {"type": "integer",
"minimum": 0}, "nonNegativeIntegerDefault0": {"$ref":
"#/$defs/nonNegativeInteger", "default": 0}, "simpleTypes": {"enum": ["array",
"boolean", "integer", "null", "number", "object", "string"]}, "stringArray":
{"type": "array", "items": {"type": "string"}, "uniqueItems": true, "default":
[]}}}, "https://json-schema.org/draft/2019-09/meta/content": {"$schema":
"https://json-schema.org/draft/2019-09/schema";, "$id":
"https://json-schema.org/draft/2019-09/meta/content";, "$vocabulary":
{"https://json-schema.org/draft/2019-09/vocab/content": true},
"$recursiveAnchor": true, "title": "Content vocabulary meta-schema", "type":
["object", "boolean"], "properties": {"contentMediaType": {"type": "string"},
"contentEncoding": {"type": "string"}, "contentSchema": {"$recursiveRef":
"#"}}}, "https://json-schema.org/draft/2019-09/meta/applicator": {"$schema": "h
ttps://json-schema.org/draft/2019-09/schema", "$id":
"https://json-schema.org/draft/2019-09/meta/applicator";, "$vocabulary":
{"https://json-schema.org/draft/2019-09/vocab/applicator": true},
"$recursiveAnchor": true, "title": "Applicator vocabulary meta-schema", "type":
["object", "boolean"], "properties": {"additionalItems": {"$recursiveRef":
"#"}, "unevaluatedItems": {"$recursiveRef": "#"}, "items": {"anyOf":
[{"$recursiveRef": "#"}, {"$ref": "#/$defs/schemaArray"}]}, "contains":
{"$recursiveRef": "#"}, "additionalProperties": {"$recursiveRef": "#"},
"unevaluatedProperties": {"$recursiveRef": "#"}, "properties": {"type":
"object", "additionalProperties": {"$recursiveRef": "#"}, "default": {}},
"patternProperties": {"type": "object", "additionalProperties":
{"$recursiveRef": "#"}, "propertyNames": {"format": "regex"}, "default": {}},
"dependentSchemas": {"type": "object", "additionalProperties":
{"$recursiveRef": "#"}}, "propertyNames": {"$recursiveRef": "#"}, "if":
{"$recursiveRef
": "#"}, "then": {"$recursiveRef": "#"}, "else": {"$recursiveRef": "#"},
"allOf": {"$ref": "#/$defs/schemaArray"}, "anyOf": {"$ref":
"#/$defs/schemaArray"}, "oneOf": {"$ref": "#/$defs/schemaArray"}, "not":
{"$recursiveRef": "#"}}, "$defs": {"schemaArray": {"type": "array", "minItems":
1, "items": {"$recursiveRef": "#"}}}},
"https://json-schema.org/draft/2019-09/meta/meta-data": {"$schema":
"https://json-schema.org/draft/2019-09/schema";, "$id":
"https://json-schema.org/draft/2019-09/meta/meta-data";, "$vocabulary":
{"https://json-schema.org/draft/2019-09/vocab/meta-data": true},
"$recursiveAnchor": true, "title": "Meta-data vocabulary meta-schema", "type":
["object", "boolean"], "properties": {"title": {"type": "string"},
"description": {"type": "string"}, "default": true, "deprecated": {"type":
"boolean", "default": false}, "readOnly": {"type": "boolean", "default":
false}, "writeOnly": {"type": "boolean", "default": false}, "examples":
{"type": "array", "items": true}}}, "https://js
on-schema.org/draft/2019-09/meta/core": {"$schema":
"https://json-schema.org/draft/2019-09/schema";, "$id":
"https://json-schema.org/draft/2019-09/meta/core";, "$vocabulary":
{"https://json-schema.org/draft/2019-09/vocab/core": true}, "$recursiveAnchor":
true, "title": "Core vocabulary meta-schema", "type": ["object", "boolean"],
"properties": {"$id": {"type": "string", "format": "uri-reference", "$comment":
"Non-empty fragments not allowed.", "pattern": "^[^#]*#?$"}, "$schema":
{"type": "string", "format": "uri"}, "$anchor": {"type": "string", "pattern":
"^[A-Za-z][-A-Za-z0-9.:_]*$"}, "$ref": {"type": "string", "format":
"uri-reference"}, "$recursiveRef": {"type": "string", "format":
"uri-reference"}, "$recursiveAnchor": {"type": "boolean", "default": false},
"$vocabulary": {"type": "object", "propertyNames": {"type": "string", "format":
"uri"}, "additionalProperties": {"type": "boolean"}}, "$comment": {"type":
"string"}, "$defs": {"type": "object", "additionalProperties": {"$recursi
veRef": "#"}, "default": {}}}},
"https://json-schema.org/draft/2019-09/meta/validation": {"$schema":
"https://json-schema.org/draft/2019-09/schema";, "$id":
"https://json-schema.org/draft/2019-09/meta/validation";, "$vocabulary":
{"https://json-schema.org/draft/2019-09/vocab/validation": true},
"$recursiveAnchor": true, "title": "Validation vocabulary meta-schema", "type":
["object", "boolean"], "properties": {"multipleOf": {"type": "number",
"exclusiveMinimum": 0}, "maximum": {"type": "number"}, "exclusiveMaximum":
{"type": "number"}, "minimum": {"type": "number"}, "exclusiveMinimum": {"type":
"number"}, "maxLength": {"$ref": "#/$defs/nonNegativeInteger"}, "minLength":
{"$ref": "#/$defs/nonNegativeIntegerDefault0"}, "pattern": {"type": "string",
"format": "regex"}, "maxItems": {"$ref": "#/$defs/nonNegativeInteger"},
"minItems": {"$ref": "#/$defs/nonNegativeIntegerDefault0"}, "uniqueItems":
{"type": "boolean", "default": false}, "maxContains": {"$ref":
"#/$defs/nonNegativeInteger"}, "
minContains": {"$ref": "#/$defs/nonNegativeInteger", "default": 1},
"maxProperties": {"$ref": "#/$defs/nonNegativeInteger"}, "minProperties":
{"$ref": "#/$defs/nonNegativeIntegerDefault0"}, "required": {"$ref":
"#/$defs/stringArray"}, "dependentRequired": {"type": "object",
"additionalProperties": {"$ref": "#/$defs/stringArray"}}, "const": true,
"enum": {"type": "array", "items": true}, "type": {"anyOf": [{"$ref":
"#/$defs/simpleTypes"}, {"type": "array", "items": {"$ref":
"#/$defs/simpleTypes"}, "minItems": 1, "uniqueItems": true}]}}, "$defs":
{"nonNegativeInteger": {"type": "integer", "minimum": 0},
"nonNegativeIntegerDefault0": {"$ref": "#/$defs/nonNegativeInteger", "default":
0}, "simpleTypes": {"enum": ["array", "boolean", "integer", "null", "number",
"object", "string"]}, "stringArray": {"type": "array", "items": {"type":
"string"}, "uniqueItems": true, "default": []}}},
"https://json-schema.org/draft/2019-09/meta/hyper-schema": {"$schema":
"https://json-schema.org/draft/2019-
09/hyper-schema", "$id":
"https://json-schema.org/draft/2019-09/meta/hyper-schema";, "$vocabulary":
{"https://json-schema.org/draft/2019-09/vocab/hyper-schema": true},
"$recursiveAnchor": true, "title": "JSON Hyper-Schema Vocabulary Schema",
"type": ["object", "boolean"], "properties": {"base": {"type": "string",
"format": "uri-template"}, "links": {"type": "array", "items": {"$ref":
"https://json-schema.org/draft/2019-09/links"}}}, "links": [{"rel": "self",
"href": "{+%24id}"}]}, "https://json-schema.org/draft/2019-09/meta/format":
{"$schema": "https://json-schema.org/draft/2019-09/schema";, "$id":
"https://json-schema.org/draft/2019-09/meta/format";, "$vocabulary":
{"https://json-schema.org/draft/2019-09/vocab/format": true},
"$recursiveAnchor": true, "title": "Format vocabulary meta-schema", "type":
["object", "boolean"], "properties": {"format": {"type": "string"}}}}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/jsonschema-4.17.0/jsonschema/tests/test_deprecations.py
new/jsonschema-4.17.1/jsonschema/tests/test_deprecations.py
--- old/jsonschema-4.17.0/jsonschema/tests/test_deprecations.py 2020-02-02
01:00:00.000000000 +0100
+++ new/jsonschema-4.17.1/jsonschema/tests/test_deprecations.py 2020-02-02
01:00:00.000000000 +0100
@@ -1,4 +1,5 @@
from unittest import TestCase
+import importlib
import subprocess
import sys
@@ -264,6 +265,22 @@
with self.assertRaises(ImportError):
from jsonschema import draft1234_format_checker # noqa
+ def test_import_cli(self):
+ """
+ As of v4.17.0, importing jsonschema.cli is deprecated.
+ """
+
+ with self.assertWarns(DeprecationWarning) as w:
+ import jsonschema.cli
+ importlib.reload(jsonschema.cli)
+
+ self.assertEqual(w.filename, importlib.__file__)
+ self.assertTrue(
+ str(w.warning).startswith(
+ "The jsonschema CLI is deprecated and will be removed ",
+ ),
+ )
+
def test_cli(self):
"""
As of v4.17.0, the jsonschema CLI is deprecated.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/jsonschema-4.17.0/jsonschema/tests/test_validators.py
new/jsonschema-4.17.1/jsonschema/tests/test_validators.py
--- old/jsonschema-4.17.0/jsonschema/tests/test_validators.py 2020-02-02
01:00:00.000000000 +0100
+++ new/jsonschema-4.17.1/jsonschema/tests/test_validators.py 2020-02-02
01:00:00.000000000 +0100
@@ -634,7 +634,26 @@
message = self.message_for(instance="foo", schema=schema)
self.assertEqual(message, "'foo' is not of type 'array'")
- def test_unevaluated_properties(self):
+ def test_unevaluated_properties_invalid_against_subschema(self):
+ schema = {
+ "properties": {"foo": {"type": "string"}},
+ "unevaluatedProperties": {"const": 12},
+ }
+ message = self.message_for(
+ instance={
+ "foo": "foo",
+ "bar": "bar",
+ "baz": 12,
+ },
+ schema=schema,
+ )
+ self.assertEqual(
+ message,
+ "Unevaluated properties are not valid under the given schema "
+ "('bar' was unevaluated and invalid)",
+ )
+
+ def test_unevaluated_properties_disallowed(self):
schema = {"type": "object", "unevaluatedProperties": False}
message = self.message_for(
instance={
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/jsonschema-4.17.0/jsonschema/validators.py
new/jsonschema-4.17.1/jsonschema/validators.py
--- old/jsonschema-4.17.0/jsonschema/validators.py 2020-02-02
01:00:00.000000000 +0100
+++ new/jsonschema-4.17.1/jsonschema/validators.py 2020-02-02
01:00:00.000000000 +0100
@@ -103,7 +103,11 @@
def _store_schema_list():
if not _VOCABULARIES:
- _VOCABULARIES.extend(_utils.load_schema("vocabularies").items())
+ package = _utils.resources.files(__package__)
+ for version in package.joinpath("schemas", "vocabularies").iterdir():
+ for path in version.iterdir():
+ vocabulary = json.loads(path.read_text())
+ _VOCABULARIES.append((vocabulary["$id"], vocabulary))
return [
(id, validator.META_SCHEMA) for id, validator in _META_SCHEMAS.items()
] + _VOCABULARIES
