Add files using upload-large-folder tool

.gitattributes

@@ -293,3 +293,5 @@ llm_tutorial/llm_recipes/datasets/bin/common_crawl_and_extended_common_crawl.doc
 tuning-competition-baseline/.venv/lib/python3.11/site-packages/torch/lib/libtorch_cuda.so filter=lfs diff=lfs merge=lfs -text
 tuning-competition-baseline/.venv/lib/python3.11/site-packages/nvidia/cudnn/lib/libcudnn_cnn_infer.so.8 filter=lfs diff=lfs merge=lfs -text
 .venv/bin/py-spy filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/_cffi_backend.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/jsonschema/tests/__pycache__/test_validators.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text

.venv/bin/f2py

@@ -0,0 +1,8 @@
+#!/home/koiwa/work/.venv/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from numpy.f2py.f2py2e import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

.venv/bin/get_gprof

@@ -0,0 +1,75 @@
+#!/home/koiwa/work/.venv/bin/python3
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2024 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+'''
+build profile graph for the given instance
+
+running:
+  $ get_gprof <args> <instance>
+
+executes:
+  gprof2dot -f pstats <args> <type>.prof | dot -Tpng -o <type>.call.png
+
+where:
+  <args> are arguments for gprof2dot, such as "-n 5 -e 5"
+  <instance> is code to create the instance to profile
+  <type> is the class of the instance (i.e. type(instance))
+
+For example:
+  $ get_gprof -n 5 -e 1 "import numpy; numpy.array([1,2])"
+
+will create 'ndarray.call.png' with the profile graph for numpy.array([1,2]),
+where '-n 5' eliminates nodes below 5% threshold, similarly '-e 1' eliminates
+edges below 1% threshold
+'''
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) < 2:
+        print ("Please provide an object instance (e.g. 'import math; math.pi')")
+        sys.exit()
+    # grab args for gprof2dot
+    args = sys.argv[1:-1]
+    args = ' '.join(args)
+    # last arg builds the object
+    obj = sys.argv[-1]
+    obj = obj.split(';')
+    # multi-line prep for generating an instance
+    for line in obj[:-1]:
+        exec(line)
+    # one-line generation of an instance
+    try:
+        obj = eval(obj[-1])
+    except Exception:
+        print ("Error processing object instance")
+        sys.exit()
+
+    # get object 'name'
+    objtype = type(obj)
+    name = getattr(objtype, '__name__', getattr(objtype, '__class__', objtype))
+
+    # profile dumping an object
+    import dill
+    import os
+    import cProfile
+    #name = os.path.splitext(os.path.basename(__file__))[0]
+    cProfile.run("dill.dumps(obj)", filename="%s.prof" % name)
+    msg = "gprof2dot -f pstats %s %s.prof | dot -Tpng -o %s.call.png" % (args, name, name)
+    try:
+        res = os.system(msg)
+    except Exception:
+        print ("Please verify install of 'gprof2dot' to view profile graphs")
+    if res:
+        print ("Please verify install of 'gprof2dot' to view profile graphs")
+
+    # get stats
+    f_prof = "%s.prof" % name
+    import pstats
+    stats = pstats.Stats(f_prof, stream=sys.stdout)
+    stats.strip_dirs().sort_stats('cumtime')
+    stats.print_stats(20) #XXX: save to file instead of print top 20?
+    os.remove(f_prof)

.venv/bin/json-playground

@@ -0,0 +1,8 @@
+#!/home/koiwa/work/.venv/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from partial_json_parser.playground import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

.venv/bin/proton-viewer

@@ -0,0 +1,8 @@
+#!/home/koiwa/work/.venv/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from triton.profiler.viewer import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

.venv/bin/pyrsa-sign

@@ -0,0 +1,8 @@
+#!/home/koiwa/work/.venv/bin/python3
+# -*- coding: utf-8 -*-
+import re
+import sys
+from rsa.cli import sign
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(sign())

.venv/lib/python3.11/site-packages/_cffi_backend.cpython-311-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2b7220efa1b67cd192ede7fdc9a7623fe80d8e90875ddf89d59373befea37d0b
+size 1068624

.venv/lib/python3.11/site-packages/charset_normalizer-3.4.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

.venv/lib/python3.11/site-packages/charset_normalizer-3.4.1.dist-info/RECORD

@@ -0,0 +1,35 @@
+../../../bin/normalizer,sha256=-E3AlS62VPo0zlTQlnk4VlAcsExlyna6kXwCg1_mDWo,244
+charset_normalizer-3.4.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+charset_normalizer-3.4.1.dist-info/LICENSE,sha256=bQ1Bv-FwrGx9wkjJpj4lTQ-0WmDVCoJX0K-SxuJJuIc,1071
+charset_normalizer-3.4.1.dist-info/METADATA,sha256=JbyHzhmqZh_ugEn1Y7TY7CDYZA9FoU6BP25hrCNDf50,35313
+charset_normalizer-3.4.1.dist-info/RECORD,,
+charset_normalizer-3.4.1.dist-info/WHEEL,sha256=9BFfIe-Zq441iQ0ehutX65O5faGDpmB1Uw3WaQGk4f0,151
+charset_normalizer-3.4.1.dist-info/entry_points.txt,sha256=8C-Y3iXIfyXQ83Tpir2B8t-XLJYpxF5xbb38d_js-h4,65
+charset_normalizer-3.4.1.dist-info/top_level.txt,sha256=7ASyzePr8_xuZWJsnqJjIBtyV8vhEo0wBCv1MPRRi3Q,19
+charset_normalizer/__init__.py,sha256=OKRxRv2Zhnqk00tqkN0c1BtJjm165fWXLydE52IKuHc,1590
+charset_normalizer/__main__.py,sha256=yzYxMR-IhKRHYwcSlavEv8oGdwxsR89mr2X09qXGdps,109
+charset_normalizer/__pycache__/__init__.cpython-311.pyc,,
+charset_normalizer/__pycache__/__main__.cpython-311.pyc,,
+charset_normalizer/__pycache__/api.cpython-311.pyc,,
+charset_normalizer/__pycache__/cd.cpython-311.pyc,,
+charset_normalizer/__pycache__/constant.cpython-311.pyc,,
+charset_normalizer/__pycache__/legacy.cpython-311.pyc,,
+charset_normalizer/__pycache__/md.cpython-311.pyc,,
+charset_normalizer/__pycache__/models.cpython-311.pyc,,
+charset_normalizer/__pycache__/utils.cpython-311.pyc,,
+charset_normalizer/__pycache__/version.cpython-311.pyc,,
+charset_normalizer/api.py,sha256=qBRz8mJ_R5E713R6TOyqHEdnmyxbEDnCSHvx32ubDGg,22617
+charset_normalizer/cd.py,sha256=WKTo1HDb-H9HfCDc3Bfwq5jzS25Ziy9SE2a74SgTq88,12522
+charset_normalizer/cli/__init__.py,sha256=D8I86lFk2-py45JvqxniTirSj_sFyE6sjaY_0-G1shc,136
+charset_normalizer/cli/__main__.py,sha256=VGC9klOoi6_R2z8rmyrc936kv7u2A1udjjHtlmNPDTM,10410
+charset_normalizer/cli/__pycache__/__init__.cpython-311.pyc,,
+charset_normalizer/cli/__pycache__/__main__.cpython-311.pyc,,
+charset_normalizer/constant.py,sha256=4VuTcZNLew1j_8ixA-Rt_VVqNWD4pwgHOHMCMlr0964,40477
+charset_normalizer/legacy.py,sha256=yhNXsPHkBfqPXKRb-sPXNj3Bscp9-mFGcYOkJ62tg9c,2328
+charset_normalizer/md.cpython-311-x86_64-linux-gnu.so,sha256=Y7QSLD5QLoSFAWys0-tL7R6QB7oi5864zM6zr7RWek4,16064
+charset_normalizer/md.py,sha256=iyXXQGWl54nnLQLueMWTmUtlivO0-rTBgVkmJxIIAGU,20036
+charset_normalizer/md__mypyc.cpython-311-x86_64-linux-gnu.so,sha256=XhkMX4lYOzNR-a68sp24uNetCg-njAJCHj14aJM6dY8,272624
+charset_normalizer/models.py,sha256=lKXhOnIPtiakbK3i__J9wpOfzx3JDTKj7Dn3Rg0VaRI,12394
+charset_normalizer/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+charset_normalizer/utils.py,sha256=T5UHo8AS7NVMmgruWoZyqEf0WrZVcQpgUNetRoborSk,12002
+charset_normalizer/version.py,sha256=Ambcj3O8FfvdLfDLc8dkaxZx97O1IM_R4_aKGD_TDdE,115

.venv/lib/python3.11/site-packages/charset_normalizer-3.4.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+normalizer = charset_normalizer:cli.cli_detect

.venv/lib/python3.11/site-packages/charset_normalizer-3.4.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+charset_normalizer

.venv/lib/python3.11/site-packages/distutils-precedence.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2638ce9e2500e572a5e0de7faed6661eb569d1b696fcba07b0dd223da5f5d224
+size 151

.venv/lib/python3.11/site-packages/example.py

@@ -0,0 +1,169 @@
+#################################################################################
+# Copyright (c) 2020, NVIDIA Corporation.  All rights reserved.                 #
+#                                                                               #
+# Redistribution and use in source and binary forms, with or without            #
+# modification, are permitted provided that the following conditions are met:   #
+#                                                                               #
+#    * Redistributions of source code must retain the above copyright notice,   #
+#      this list of conditions and the following disclaimer.                    #
+#    * Redistributions in binary form must reproduce the above copyright        #
+#      notice, this list of conditions and the following disclaimer in the      #
+#      documentation and/or other materials provided with the distribution.     #
+#    * Neither the name of the NVIDIA Corporation nor the names of its          #
+#      contributors may be used to endorse or promote products derived from     #
+#      this software without specific prior written permission.                 #
+#                                                                               #
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"   #
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE     #
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE    #
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE     #
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR           #
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF          #
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS      #
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN       #
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)       #
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF        #
+# THE POSSIBILITY OF SUCH DAMAGE.                                               #
+#################################################################################
+
+#
+# Sample script to demonstrate the usage of NVML API python bindings
+#
+
+# To Run:
+# $ python ./example.py
+
+from pynvml import *
+
+#
+# Helper function
+#
+def StrVirt(mode):
+    if mode == NVML_GPU_VIRTUALIZATION_MODE_NONE:
+        return "None";
+    elif mode == NVML_GPU_VIRTUALIZATION_MODE_PASSTHROUGH:
+        return "Pass-Through";
+    elif mode == NVML_GPU_VIRTUALIZATION_MODE_VGPU:
+        return "VGPU";
+    elif mode == NVML_GPU_VIRTUALIZATION_MODE_HOST_VGPU:
+        return "Host VGPU";
+    elif mode == NVML_GPU_VIRTUALIZATION_MODE_HOST_VSGA:
+        return "Host VSGA";
+    else:
+        return "Unknown";
+
+#
+# Converts errors into string messages
+#
+def handleError(err):
+    if (err.value == NVML_ERROR_NOT_SUPPORTED):
+        return "N/A"
+    else:
+        return err.__str__()
+
+#######
+def deviceQuery():
+
+    strResult = ''
+    try:
+        #
+        # Initialize NVML
+        #
+        nvmlInit()
+
+        strResult += '  <driver_version>' + str(nvmlSystemGetDriverVersion()) + '</driver_version>\n'
+
+        deviceCount = nvmlDeviceGetCount()
+        strResult += '  <attached_gpus>' + str(deviceCount) + '</attached_gpus>\n'
+
+        for i in range(0, deviceCount):
+            handle = nvmlDeviceGetHandleByIndex(i)
+
+            pciInfo = nvmlDeviceGetPciInfo(handle)
+
+            strResult += '  <gpu id="%s">\n' % pciInfo.busId
+
+            strResult += '    <product_name>' + nvmlDeviceGetName(handle) + '</product_name>\n'
+
+            brandNames = {NVML_BRAND_UNKNOWN             :  "Unknown",
+                          NVML_BRAND_QUADRO              :  "Quadro",
+                          NVML_BRAND_TESLA               :  "Tesla",
+                          NVML_BRAND_NVS                 :  "NVS",
+                          NVML_BRAND_GRID                :  "Grid",
+                          NVML_BRAND_TITAN               :  "Titan",
+                          NVML_BRAND_GEFORCE             :  "GeForce",
+                          NVML_BRAND_NVIDIA_VAPPS        :  "NVIDIA Virtual Applications",
+                          NVML_BRAND_NVIDIA_VPC          :  "NVIDIA Virtual PC",
+                          NVML_BRAND_NVIDIA_VCS          :  "NVIDIA Virtual Compute Server",
+                          NVML_BRAND_NVIDIA_VWS          :  "NVIDIA RTX Virtual Workstation",
+                          NVML_BRAND_NVIDIA_CLOUD_GAMING :  "NVIDIA Cloud Gaming",
+                          NVML_BRAND_QUADRO_RTX          :  "Quadro RTX",
+                          NVML_BRAND_NVIDIA_RTX          :  "NVIDIA RTX",
+                          NVML_BRAND_NVIDIA              :  "NVIDIA",
+                          NVML_BRAND_GEFORCE_RTX         :  "GeForce RTX",
+                          NVML_BRAND_TITAN_RTX           :  "TITAN RTX",
+
+            }
+
+            try:
+                # If nvmlDeviceGetBrand() succeeds it is guaranteed to be in the dictionary
+                brandName = brandNames[nvmlDeviceGetBrand(handle)]
+            except NVMLError as err:
+                brandName = handleError(err)
+
+            strResult += '    <product_brand>' + brandName + '</product_brand>\n'
+
+            try:
+                serial = nvmlDeviceGetSerial(handle)
+            except NVMLError as err:
+                serial = handleError(err)
+
+            strResult += '    <serial>' + serial + '</serial>\n'
+
+            try:
+                uuid = nvmlDeviceGetUUID(handle)
+            except NVMLError as err:
+                uuid = handleError(err)
+
+            strResult += '    <uuid>' + uuid + '</uuid>\n'
+
+            strResult += '    <gpu_virtualization_mode>\n'
+            try:
+                mode = StrVirt(nvmlDeviceGetVirtualizationMode(handle))
+            except NVMLError as err:
+                mode = handleError(err)
+            strResult += '      <virtualization_mode>' + mode + '</virtualization_mode>\n'
+            strResult += '    </gpu_virtualization_mode>\n'
+
+            try:
+                gridLicensableFeatures = nvmlDeviceGetGridLicensableFeatures(handle)
+                if gridLicensableFeatures.isGridLicenseSupported == 1:
+                    strResult += '    <vgpu_software_licensed_product>\n'
+                    for i in range(gridLicensableFeatures.licensableFeaturesCount):
+                        if gridLicensableFeatures.gridLicensableFeatures[i].featureState == 0:
+                            if nvmlDeviceGetVirtualizationMode(handle) == NVML_GPU_VIRTUALIZATION_MODE_PASSTHROUGH:
+                                strResult += '        <licensed_product_name>' + 'NVIDIA Virtual Applications' + '</licensed_product_name>\n'
+                                strResult += '        <license_status>' + 'Licensed' + '</license_status>\n'
+                            else:
+                                strResult += '        <licensed_product_name>' + gridLicensableFeatures.gridLicensableFeatures[i].productName + '</licensed_product_name>\n'
+                                strResult += '        <license_status>' + 'Unlicensed' + '</license_status>\n'
+                        else:
+                            strResult += '        <licensed_product_name>' + gridLicensableFeatures.gridLicensableFeatures[i].productName + '</licensed_product_name>\n'
+                            strResult += '        <license_status>' + 'Licensed' + '</license_status>\n'
+                    strResult += '    </vgpu_software_licensed_product>\n'
+            except NVMLError as err:
+                gridLicensableFeatures = handleError(err)
+
+            strResult += '  </gpu>\n'
+
+    except NVMLError as err:
+        strResult += 'example.py: ' + err.__str__() + '\n'
+
+    nvmlShutdown()
+
+    return strResult
+
+# If this is not exectued when module is imported
+if __name__ == "__main__":
+    print(deviceQuery())
+

.venv/lib/python3.11/site-packages/google_auth_httplib2.py

@@ -0,0 +1,307 @@
+# Copyright 2016 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Transport adapter for httplib2."""
+
+from __future__ import absolute_import
+
+import http.client
+import logging
+
+from google.auth import exceptions
+from google.auth import transport
+import httplib2
+
+
+_LOGGER = logging.getLogger(__name__)
+# Properties present in file-like streams / buffers.
+_STREAM_PROPERTIES = ("read", "seek", "tell")
+
+
+class _Response(transport.Response):
+    """httplib2 transport response adapter.
+
+    Args:
+        response (httplib2.Response): The raw httplib2 response.
+        data (bytes): The response body.
+    """
+
+    def __init__(self, response, data):
+        self._response = response
+        self._data = data
+
+    @property
+    def status(self):
+        """int: The HTTP status code."""
+        return self._response.status
+
+    @property
+    def headers(self):
+        """Mapping[str, str]: The HTTP response headers."""
+        return dict(self._response)
+
+    @property
+    def data(self):
+        """bytes: The response body."""
+        return self._data
+
+
+class Request(transport.Request):
+    """httplib2 request adapter.
+
+    This class is used internally for making requests using various transports
+    in a consistent way. If you use :class:`AuthorizedHttp` you do not need
+    to construct or use this class directly.
+
+    This class can be useful if you want to manually refresh a
+    :class:`~google.auth.credentials.Credentials` instance::
+
+        import google_auth_httplib2
+        import httplib2
+
+        http = httplib2.Http()
+        request = google_auth_httplib2.Request(http)
+
+        credentials.refresh(request)
+
+    Args:
+        http (httplib2.Http): The underlying http object to use to make
+            requests.
+
+    .. automethod:: __call__
+    """
+
+    def __init__(self, http):
+        self.http = http
+
+    def __call__(
+        self, url, method="GET", body=None, headers=None, timeout=None, **kwargs
+    ):
+        """Make an HTTP request using httplib2.
+
+        Args:
+            url (str): The URI to be requested.
+            method (str): The HTTP method to use for the request. Defaults
+                to 'GET'.
+            body (bytes): The payload / body in HTTP request.
+            headers (Mapping[str, str]): Request headers.
+            timeout (Optional[int]): The number of seconds to wait for a
+                response from the server. This is ignored by httplib2 and will
+                issue a warning.
+            kwargs: Additional arguments passed throught to the underlying
+                :meth:`httplib2.Http.request` method.
+
+        Returns:
+            google.auth.transport.Response: The HTTP response.
+
+        Raises:
+            google.auth.exceptions.TransportError: If any exception occurred.
+        """
+        if timeout is not None:
+            _LOGGER.warning(
+                "httplib2 transport does not support per-request timeout. "
+                "Set the timeout when constructing the httplib2.Http instance."
+            )
+
+        try:
+            _LOGGER.debug("Making request: %s %s", method, url)
+            response, data = self.http.request(
+                url, method=method, body=body, headers=headers, **kwargs
+            )
+            return _Response(response, data)
+        # httplib2 should catch the lower http error, this is a bug and
+        # needs to be fixed there.  Catch the error for the meanwhile.
+        except (httplib2.HttpLib2Error, http.client.HTTPException) as exc:
+            raise exceptions.TransportError(exc)
+
+
+def _make_default_http():
+    """Returns a default httplib2.Http instance."""
+    return httplib2.Http()
+
+
+class AuthorizedHttp(object):
+    """A httplib2 HTTP class with credentials.
+
+    This class is used to perform requests to API endpoints that require
+    authorization::
+
+        from google.auth.transport._httplib2 import AuthorizedHttp
+
+        authed_http = AuthorizedHttp(credentials)
+
+        response = authed_http.request(
+            'https://www.googleapis.com/storage/v1/b')
+
+    This class implements :meth:`request` in the same way as
+    :class:`httplib2.Http` and can usually be used just like any other
+    instance of :class:``httplib2.Http`.
+
+    The underlying :meth:`request` implementation handles adding the
+    credentials' headers to the request and refreshing credentials as needed.
+    """
+
+    def __init__(
+        self,
+        credentials,
+        http=None,
+        refresh_status_codes=transport.DEFAULT_REFRESH_STATUS_CODES,
+        max_refresh_attempts=transport.DEFAULT_MAX_REFRESH_ATTEMPTS,
+    ):
+        """
+        Args:
+            credentials (google.auth.credentials.Credentials): The credentials
+                to add to the request.
+            http (httplib2.Http): The underlying HTTP object to
+                use to make requests. If not specified, a
+                :class:`httplib2.Http` instance will be constructed.
+            refresh_status_codes (Sequence[int]): Which HTTP status codes
+                indicate that credentials should be refreshed and the request
+                should be retried.
+            max_refresh_attempts (int): The maximum number of times to attempt
+                to refresh the credentials and retry the request.
+        """
+
+        if http is None:
+            http = _make_default_http()
+
+        self.http = http
+        self.credentials = credentials
+        self._refresh_status_codes = refresh_status_codes
+        self._max_refresh_attempts = max_refresh_attempts
+        # Request instance used by internal methods (for example,
+        # credentials.refresh).
+        self._request = Request(self.http)
+
+    def close(self):
+        """Calls httplib2's Http.close"""
+        self.http.close()
+
+    def request(
+        self,
+        uri,
+        method="GET",
+        body=None,
+        headers=None,
+        redirections=httplib2.DEFAULT_MAX_REDIRECTS,
+        connection_type=None,
+        **kwargs
+    ):
+        """Implementation of httplib2's Http.request."""
+
+        _credential_refresh_attempt = kwargs.pop("_credential_refresh_attempt", 0)
+
+        # Make a copy of the headers. They will be modified by the credentials
+        # and we want to pass the original headers if we recurse.
+        request_headers = headers.copy() if headers is not None else {}
+
+        self.credentials.before_request(self._request, method, uri, request_headers)
+
+        # Check if the body is a file-like stream, and if so, save the body
+        # stream position so that it can be restored in case of refresh.
+        body_stream_position = None
+        if all(getattr(body, stream_prop, None) for stream_prop in _STREAM_PROPERTIES):
+            body_stream_position = body.tell()
+
+        # Make the request.
+        response, content = self.http.request(
+            uri,
+            method,
+            body=body,
+            headers=request_headers,
+            redirections=redirections,
+            connection_type=connection_type,
+            **kwargs
+        )
+
+        # If the response indicated that the credentials needed to be
+        # refreshed, then refresh the credentials and re-attempt the
+        # request.
+        # A stored token may expire between the time it is retrieved and
+        # the time the request is made, so we may need to try twice.
+        if (
+            response.status in self._refresh_status_codes
+            and _credential_refresh_attempt < self._max_refresh_attempts
+        ):
+
+            _LOGGER.info(
+                "Refreshing credentials due to a %s response. Attempt %s/%s.",
+                response.status,
+                _credential_refresh_attempt + 1,
+                self._max_refresh_attempts,
+            )
+
+            self.credentials.refresh(self._request)
+
+            # Restore the body's stream position if needed.
+            if body_stream_position is not None:
+                body.seek(body_stream_position)
+
+            # Recurse. Pass in the original headers, not our modified set.
+            return self.request(
+                uri,
+                method,
+                body=body,
+                headers=headers,
+                redirections=redirections,
+                connection_type=connection_type,
+                _credential_refresh_attempt=_credential_refresh_attempt + 1,
+                **kwargs
+            )
+
+        return response, content
+
+    def add_certificate(self, key, cert, domain, password=None):
+        """Proxy to httplib2.Http.add_certificate."""
+        self.http.add_certificate(key, cert, domain, password=password)
+
+    @property
+    def connections(self):
+        """Proxy to httplib2.Http.connections."""
+        return self.http.connections
+
+    @connections.setter
+    def connections(self, value):
+        """Proxy to httplib2.Http.connections."""
+        self.http.connections = value
+
+    @property
+    def follow_redirects(self):
+        """Proxy to httplib2.Http.follow_redirects."""
+        return self.http.follow_redirects
+
+    @follow_redirects.setter
+    def follow_redirects(self, value):
+        """Proxy to httplib2.Http.follow_redirects."""
+        self.http.follow_redirects = value
+
+    @property
+    def timeout(self):
+        """Proxy to httplib2.Http.timeout."""
+        return self.http.timeout
+
+    @timeout.setter
+    def timeout(self, value):
+        """Proxy to httplib2.Http.timeout."""
+        self.http.timeout = value
+
+    @property
+    def redirect_codes(self):
+        """Proxy to httplib2.Http.redirect_codes."""
+        return self.http.redirect_codes
+
+    @redirect_codes.setter
+    def redirect_codes(self, value):
+        """Proxy to httplib2.Http.redirect_codes."""
+        self.http.redirect_codes = value

.venv/lib/python3.11/site-packages/google_generativeai-0.8.4-py3.12-nspkg.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:492187369ed89466a43eca61c645a6d1f2a0de9ceb7d0611438d993ed88f17ee
+size 467

.venv/lib/python3.11/site-packages/isympy.py

@@ -0,0 +1,342 @@
+"""
+Python shell for SymPy.
+
+This is just a normal Python shell (IPython shell if you have the
+IPython package installed), that executes the following commands for
+the user:
+
+    >>> from __future__ import division
+    >>> from sympy import *
+    >>> x, y, z, t = symbols('x y z t')
+    >>> k, m, n = symbols('k m n', integer=True)
+    >>> f, g, h = symbols('f g h', cls=Function)
+    >>> init_printing()
+
+So starting 'isympy' is equivalent to starting Python (or IPython) and
+executing the above commands by hand.  It is intended for easy and quick
+experimentation with SymPy.  isympy is a good way to use SymPy as an
+interactive calculator. If you have IPython and Matplotlib installed, then
+interactive plotting is enabled by default.
+
+COMMAND LINE OPTIONS
+--------------------
+
+-c CONSOLE, --console=CONSOLE
+
+     Use the specified shell (Python or IPython) shell as the console
+     backend instead of the default one (IPython if present, Python
+     otherwise), e.g.:
+
+        $isympy -c python
+
+    CONSOLE must be one of 'ipython' or 'python'
+
+-p PRETTY, --pretty PRETTY
+
+    Setup pretty-printing in SymPy. When pretty-printing is enabled,
+    expressions can be printed with Unicode or ASCII. The default is
+    to use pretty-printing (with Unicode if the terminal supports it).
+    When this option is 'no', expressions will not be pretty-printed
+    and ASCII will be used:
+
+        $isympy -p no
+
+    PRETTY must be one of 'unicode', 'ascii', or 'no'
+
+-t TYPES, --types=TYPES
+
+    Setup the ground types for the polys.  By default, gmpy ground types
+    are used if gmpy2 or gmpy is installed, otherwise it falls back to python
+    ground types, which are a little bit slower.  You can manually
+    choose python ground types even if gmpy is installed (e.g., for
+    testing purposes):
+
+        $isympy -t python
+
+    TYPES must be one of 'gmpy', 'gmpy1' or 'python'
+
+    Note that the ground type gmpy1 is primarily intended for testing; it
+    forces the use of gmpy version 1 even if gmpy2 is available.
+
+    This is the same as setting the environment variable
+    SYMPY_GROUND_TYPES to the given ground type (e.g.,
+    SYMPY_GROUND_TYPES='gmpy')
+
+    The ground types can be determined interactively from the variable
+    sympy.polys.domains.GROUND_TYPES.
+
+-o ORDER, --order ORDER
+
+    Setup the ordering of terms for printing.  The default is lex, which
+    orders terms lexicographically (e.g., x**2 + x + 1). You can choose
+    other orderings, such as rev-lex, which will use reverse
+    lexicographic ordering (e.g., 1 + x + x**2):
+
+        $isympy -o rev-lex
+
+    ORDER must be one of 'lex', 'rev-lex', 'grlex', 'rev-grlex',
+    'grevlex', 'rev-grevlex', 'old', or 'none'.
+
+    Note that for very large expressions, ORDER='none' may speed up
+    printing considerably but the terms will have no canonical order.
+
+-q, --quiet
+
+    Print only Python's and SymPy's versions to stdout at startup.
+
+-d, --doctest
+
+    Use the same format that should be used for doctests.  This is
+    equivalent to -c python -p no.
+
+-C, --no-cache
+
+    Disable the caching mechanism.  Disabling the cache may slow certain
+    operations down considerably.  This is useful for testing the cache,
+    or for benchmarking, as the cache can result in deceptive timings.
+
+    This is equivalent to setting the environment variable
+    SYMPY_USE_CACHE to 'no'.
+
+-a, --auto-symbols (requires at least IPython 0.11)
+
+    Automatically create missing symbols.  Normally, typing a name of a
+    Symbol that has not been instantiated first would raise NameError,
+    but with this option enabled, any undefined name will be
+    automatically created as a Symbol.
+
+    Note that this is intended only for interactive, calculator style
+    usage. In a script that uses SymPy, Symbols should be instantiated
+    at the top, so that it's clear what they are.
+
+    This will not override any names that are already defined, which
+    includes the single character letters represented by the mnemonic
+    QCOSINE (see the "Gotchas and Pitfalls" document in the
+    documentation). You can delete existing names by executing "del
+    name".  If a name is defined, typing "'name' in dir()" will return True.
+
+    The Symbols that are created using this have default assumptions.
+    If you want to place assumptions on symbols, you should create them
+    using symbols() or var().
+
+    Finally, this only works in the top level namespace. So, for
+    example, if you define a function in isympy with an undefined
+    Symbol, it will not work.
+
+    See also the -i and -I options.
+
+-i, --int-to-Integer (requires at least IPython 0.11)
+
+    Automatically wrap int literals with Integer.  This makes it so that
+    things like 1/2 will come out as Rational(1, 2), rather than 0.5.  This
+    works by preprocessing the source and wrapping all int literals with
+    Integer.  Note that this will not change the behavior of int literals
+    assigned to variables, and it also won't change the behavior of functions
+    that return int literals.
+
+    If you want an int, you can wrap the literal in int(), e.g. int(3)/int(2)
+    gives 1.5 (with division imported from __future__).
+
+-I, --interactive (requires at least IPython 0.11)
+
+    This is equivalent to --auto-symbols --int-to-Integer.  Future options
+    designed for ease of interactive use may be added to this.
+
+-D, --debug
+
+    Enable debugging output.  This is the same as setting the
+    environment variable SYMPY_DEBUG to 'True'.  The debug status is set
+    in the variable SYMPY_DEBUG within isympy.
+
+-- IPython options
+
+    Additionally you can pass command line options directly to the IPython
+    interpreter (the standard Python shell is not supported).  However you
+    need to add the '--' separator between two types of options, e.g the
+    startup banner option and the colors option. You need to enter the
+    options as required by the version of IPython that you are using, too:
+
+    in IPython 0.11,
+
+        $isympy -q -- --colors=NoColor
+
+    or older versions of IPython,
+
+        $isympy -q -- -colors NoColor
+
+See also isympy --help.
+"""
+
+import os
+import sys
+
+# DO NOT IMPORT SYMPY HERE! Or the setting of the sympy environment variables
+# by the command line will break.
+
+def main() -> None:
+    from argparse import ArgumentParser, RawDescriptionHelpFormatter
+
+    VERSION = None
+    if '--version' in sys.argv:
+        # We cannot import sympy before this is run, because flags like -C and
+        # -t set environment variables that must be set before SymPy is
+        # imported. The only thing we need to import it for is to get the
+        # version, which only matters with the --version flag.
+        import sympy
+        VERSION = sympy.__version__
+
+    usage = 'isympy [options] -- [ipython options]'
+    parser = ArgumentParser(
+        usage=usage,
+        description=__doc__,
+        formatter_class=RawDescriptionHelpFormatter,
+    )
+
+    parser.add_argument('--version', action='version', version=VERSION)
+
+    parser.add_argument(
+        '-c', '--console',
+        dest='console',
+        action='store',
+        default=None,
+        choices=['ipython', 'python'],
+        metavar='CONSOLE',
+        help='select type of interactive session: ipython | python; defaults '
+        'to ipython if IPython is installed, otherwise python')
+
+    parser.add_argument(
+        '-p', '--pretty',
+        dest='pretty',
+        action='store',
+        default=None,
+        metavar='PRETTY',
+        choices=['unicode', 'ascii', 'no'],
+        help='setup pretty printing: unicode | ascii | no; defaults to '
+        'unicode printing if the terminal supports it, otherwise ascii')
+
+    parser.add_argument(
+        '-t', '--types',
+        dest='types',
+        action='store',
+        default=None,
+        metavar='TYPES',
+        choices=['gmpy', 'gmpy1', 'python'],
+        help='setup ground types: gmpy | gmpy1 | python; defaults to gmpy if gmpy2 '
+        'or gmpy is installed, otherwise python')
+
+    parser.add_argument(
+        '-o', '--order',
+        dest='order',
+        action='store',
+        default=None,
+        metavar='ORDER',
+        choices=['lex', 'grlex', 'grevlex', 'rev-lex', 'rev-grlex', 'rev-grevlex', 'old', 'none'],
+        help='setup ordering of terms: [rev-]lex | [rev-]grlex | [rev-]grevlex | old | none; defaults to lex')
+
+    parser.add_argument(
+        '-q', '--quiet',
+        dest='quiet',
+        action='store_true',
+        default=False,
+        help='print only version information at startup')
+
+    parser.add_argument(
+        '-d', '--doctest',
+        dest='doctest',
+        action='store_true',
+        default=False,
+        help='use the doctest format for output (you can just copy and paste it)')
+
+    parser.add_argument(
+        '-C', '--no-cache',
+        dest='cache',
+        action='store_false',
+        default=True,
+        help='disable caching mechanism')
+
+    parser.add_argument(
+        '-a', '--auto-symbols',
+        dest='auto_symbols',
+        action='store_true',
+        default=False,
+        help='automatically construct missing symbols')
+
+    parser.add_argument(
+        '-i', '--int-to-Integer',
+        dest='auto_int_to_Integer',
+        action='store_true',
+        default=False,
+        help="automatically wrap int literals with Integer")
+
+    parser.add_argument(
+        '-I', '--interactive',
+        dest='interactive',
+        action='store_true',
+        default=False,
+        help="equivalent to -a -i")
+
+    parser.add_argument(
+        '-D', '--debug',
+        dest='debug',
+        action='store_true',
+        default=False,
+        help='enable debugging output')
+
+    (options, ipy_args) = parser.parse_known_args()
+    if '--' in ipy_args:
+        ipy_args.remove('--')
+
+    if not options.cache:
+        os.environ['SYMPY_USE_CACHE'] = 'no'
+
+    if options.types:
+        os.environ['SYMPY_GROUND_TYPES'] = options.types
+
+    if options.debug:
+        os.environ['SYMPY_DEBUG'] = str(options.debug)
+
+    if options.doctest:
+        options.pretty = 'no'
+        options.console = 'python'
+
+    session = options.console
+
+    if session is not None:
+        ipython = session == 'ipython'
+    else:
+        try:
+            import IPython
+            ipython = True
+        except ImportError:
+            if not options.quiet:
+                from sympy.interactive.session import no_ipython
+                print(no_ipython)
+            ipython = False
+
+    args = {
+        'pretty_print': True,
+        'use_unicode':  None,
+        'use_latex':    None,
+        'order':        None,
+        'argv':         ipy_args,
+    }
+
+    if options.pretty == 'unicode':
+        args['use_unicode'] = True
+    elif options.pretty == 'ascii':
+        args['use_unicode'] = False
+    elif options.pretty == 'no':
+        args['pretty_print'] = False
+
+    if options.order is not None:
+        args['order'] = options.order
+
+    args['quiet'] = options.quiet
+    args['auto_symbols'] = options.auto_symbols or options.interactive
+    args['auto_int_to_Integer'] = options.auto_int_to_Integer or options.interactive
+
+    from sympy.interactive import init_session
+    init_session(ipython, **args)
+
+if __name__ == "__main__":
+    main()

.venv/lib/python3.11/site-packages/jsonschema/__init__.py

@@ -0,0 +1,120 @@
+"""
+An implementation of JSON Schema for Python.
+
+The main functionality is provided by the validator classes for each of the
+supported JSON Schema versions.
+
+Most commonly, `jsonschema.validators.validate` is the quickest way to simply
+validate a given instance under a schema, and will create a validator
+for you.
+"""
+import warnings
+
+from jsonschema._format import FormatChecker
+from jsonschema._types import TypeChecker
+from jsonschema.exceptions import SchemaError, ValidationError
+from jsonschema.validators import (
+    Draft3Validator,
+    Draft4Validator,
+    Draft6Validator,
+    Draft7Validator,
+    Draft201909Validator,
+    Draft202012Validator,
+    validate,
+)
+
+
+def __getattr__(name):
+    if name == "__version__":
+        warnings.warn(
+            "Accessing jsonschema.__version__ is deprecated and will be "
+            "removed in a future release. Use importlib.metadata directly "
+            "to query for jsonschema's version.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+        from importlib import metadata
+        return metadata.version("jsonschema")
+    elif name == "RefResolver":
+        from jsonschema.validators import _RefResolver
+        warnings.warn(
+            _RefResolver._DEPRECATION_MESSAGE,
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return _RefResolver
+    elif name == "ErrorTree":
+        warnings.warn(
+            "Importing ErrorTree directly from the jsonschema package "
+            "is deprecated and will become an ImportError. Import it from "
+            "jsonschema.exceptions instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        from jsonschema.exceptions import ErrorTree
+        return ErrorTree
+    elif name == "FormatError":
+        warnings.warn(
+            "Importing FormatError directly from the jsonschema package "
+            "is deprecated and will become an ImportError. Import it from "
+            "jsonschema.exceptions instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        from jsonschema.exceptions import FormatError
+        return FormatError
+    elif name == "Validator":
+        warnings.warn(
+            "Importing Validator directly from the jsonschema package "
+            "is deprecated and will become an ImportError. Import it from "
+            "jsonschema.protocols instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        from jsonschema.protocols import Validator
+        return Validator
+    elif name == "RefResolutionError":
+        from jsonschema.exceptions import _RefResolutionError
+        warnings.warn(
+            _RefResolutionError._DEPRECATION_MESSAGE,
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return _RefResolutionError
+
+    format_checkers = {
+        "draft3_format_checker": Draft3Validator,
+        "draft4_format_checker": Draft4Validator,
+        "draft6_format_checker": Draft6Validator,
+        "draft7_format_checker": Draft7Validator,
+        "draft201909_format_checker": Draft201909Validator,
+        "draft202012_format_checker": Draft202012Validator,
+    }
+    ValidatorForFormat = format_checkers.get(name)
+    if ValidatorForFormat is not None:
+        warnings.warn(
+            f"Accessing jsonschema.{name} is deprecated and will be "
+            "removed in a future release. Instead, use the FORMAT_CHECKER "
+            "attribute on the corresponding Validator.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return ValidatorForFormat.FORMAT_CHECKER
+
+    raise AttributeError(f"module {__name__} has no attribute {name}")
+
+
+__all__ = [
+    "Draft201909Validator",
+    "Draft202012Validator",
+    "Draft3Validator",
+    "Draft4Validator",
+    "Draft6Validator",
+    "Draft7Validator",
+    "FormatChecker",
+    "SchemaError",
+    "TypeChecker",
+    "ValidationError",
+    "validate",
+]

.venv/lib/python3.11/site-packages/jsonschema/__main__.py

@@ -0,0 +1,6 @@
+"""
+The jsonschema CLI is now deprecated in favor of check-jsonschema.
+"""
+from jsonschema.cli import main
+
+main()

.venv/lib/python3.11/site-packages/jsonschema/_format.py

@@ -0,0 +1,519 @@
+from __future__ import annotations
+
+from contextlib import suppress
+from datetime import date, datetime
+from uuid import UUID
+import ipaddress
+import re
+import typing
+import warnings
+
+from jsonschema.exceptions import FormatError
+
+_FormatCheckCallable = typing.Callable[[object], bool]
+#: A format checker callable.
+_F = typing.TypeVar("_F", bound=_FormatCheckCallable)
+_RaisesType = typing.Union[
+    typing.Type[Exception], typing.Tuple[typing.Type[Exception], ...],
+]
+
+_RE_DATE = re.compile(r"^\d{4}-\d{2}-\d{2}$", re.ASCII)
+
+
+class FormatChecker:
+    """
+    A ``format`` property checker.
+
+    JSON Schema does not mandate that the ``format`` property actually do any
+    validation. If validation is desired however, instances of this class can
+    be hooked into validators to enable format validation.
+
+    `FormatChecker` objects always return ``True`` when asked about
+    formats that they do not know how to validate.
+
+    To add a check for a custom format use the `FormatChecker.checks`
+    decorator.
+
+    Arguments:
+
+        formats:
+
+            The known formats to validate. This argument can be used to
+            limit which formats will be used during validation.
+
+    """
+
+    checkers: dict[
+        str,
+        tuple[_FormatCheckCallable, _RaisesType],
+    ] = {}  # noqa: RUF012
+
+    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}
+
+    def __repr__(self):
+        return f"<FormatChecker checkers={sorted(self.checkers)}>"
+
+    def checks(
+        self, format: str, raises: _RaisesType = (),
+    ) -> typing.Callable[[_F], _F]:
+        """
+        Register a decorated function as validating a new format.
+
+        Arguments:
+
+            format:
+
+                The format that the decorated function will check.
+
+            raises:
+
+                The exception(s) raised by the decorated function when an
+                invalid instance is found.
+
+                The exception object will be accessible as the
+                `jsonschema.exceptions.ValidationError.cause` attribute of the
+                resulting validation error.
+
+        """
+
+        def _checks(func: _F) -> _F:
+            self.checkers[format] = (func, raises)
+            return func
+
+        return _checks
+
+    @classmethod
+    def cls_checks(
+        cls, format: str, raises: _RaisesType = (),
+    ) -> typing.Callable[[_F], _F]:
+        warnings.warn(
+            (
+                "FormatChecker.cls_checks is deprecated. Call "
+                "FormatChecker.checks on a specific FormatChecker instance "
+                "instead."
+            ),
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return cls._cls_checks(format=format, raises=raises)
+
+    @classmethod
+    def _cls_checks(
+        cls, format: str, raises: _RaisesType = (),
+    ) -> typing.Callable[[_F], _F]:
+        def _checks(func: _F) -> _F:
+            cls.checkers[format] = (func, raises)
+            return func
+
+        return _checks
+
+    def check(self, instance: object, format: str) -> None:
+        """
+        Check whether the instance conforms to the given format.
+
+        Arguments:
+
+            instance (*any primitive type*, i.e. str, number, bool):
+
+                The instance to check
+
+            format:
+
+                The format that instance should conform to
+
+        Raises:
+
+            FormatError:
+
+                if the instance does not conform to ``format``
+
+        """
+        if format not in self.checkers:
+            return
+
+        func, raises = self.checkers[format]
+        result, cause = None, None
+        try:
+            result = func(instance)
+        except raises as e:
+            cause = e
+        if not result:
+            raise FormatError(f"{instance!r} is not a {format!r}", cause=cause)
+
+    def conforms(self, instance: object, format: str) -> bool:
+        """
+        Check whether the instance conforms to the given format.
+
+        Arguments:
+
+            instance (*any primitive type*, i.e. str, number, bool):
+
+                The instance to check
+
+            format:
+
+                The format that instance should conform to
+
+        Returns:
+
+            bool: whether it conformed
+
+        """
+        try:
+            self.check(instance, format)
+        except FormatError:
+            return False
+        else:
+            return True
+
+
+draft3_format_checker = FormatChecker()
+draft4_format_checker = FormatChecker()
+draft6_format_checker = FormatChecker()
+draft7_format_checker = FormatChecker()
+draft201909_format_checker = FormatChecker()
+draft202012_format_checker = FormatChecker()
+
+_draft_checkers: dict[str, FormatChecker] = dict(
+    draft3=draft3_format_checker,
+    draft4=draft4_format_checker,
+    draft6=draft6_format_checker,
+    draft7=draft7_format_checker,
+    draft201909=draft201909_format_checker,
+    draft202012=draft202012_format_checker,
+)
+
+
+def _checks_drafts(
+    name=None,
+    draft3=None,
+    draft4=None,
+    draft6=None,
+    draft7=None,
+    draft201909=None,
+    draft202012=None,
+    raises=(),
+) -> typing.Callable[[_F], _F]:
+    draft3 = draft3 or name
+    draft4 = draft4 or name
+    draft6 = draft6 or name
+    draft7 = draft7 or name
+    draft201909 = draft201909 or name
+    draft202012 = draft202012 or name
+
+    def wrap(func: _F) -> _F:
+        if draft3:
+            func = _draft_checkers["draft3"].checks(draft3, raises)(func)
+        if draft4:
+            func = _draft_checkers["draft4"].checks(draft4, raises)(func)
+        if draft6:
+            func = _draft_checkers["draft6"].checks(draft6, raises)(func)
+        if draft7:
+            func = _draft_checkers["draft7"].checks(draft7, raises)(func)
+        if draft201909:
+            func = _draft_checkers["draft201909"].checks(draft201909, raises)(
+                func,
+            )
+        if draft202012:
+            func = _draft_checkers["draft202012"].checks(draft202012, raises)(
+                func,
+            )
+
+        # Oy. This is bad global state, but relied upon for now, until
+        # deprecation. See #519 and test_format_checkers_come_with_defaults
+        FormatChecker._cls_checks(
+            draft202012 or draft201909 or draft7 or draft6 or draft4 or draft3,
+            raises,
+        )(func)
+        return func
+
+    return wrap
+
+
+@_checks_drafts(name="idn-email")
+@_checks_drafts(name="email")
+def is_email(instance: object) -> bool:
+    if not isinstance(instance, str):
+        return True
+    return "@" in instance
+
+
+@_checks_drafts(
+    draft3="ip-address",
+    draft4="ipv4",
+    draft6="ipv4",
+    draft7="ipv4",
+    draft201909="ipv4",
+    draft202012="ipv4",
+    raises=ipaddress.AddressValueError,
+)
+def is_ipv4(instance: object) -> bool:
+    if not isinstance(instance, str):
+        return True
+    return bool(ipaddress.IPv4Address(instance))
+
+
+@_checks_drafts(name="ipv6", raises=ipaddress.AddressValueError)
+def is_ipv6(instance: object) -> bool:
+    if not isinstance(instance, str):
+        return True
+    address = ipaddress.IPv6Address(instance)
+    return not getattr(address, "scope_id", "")
+
+
+with suppress(ImportError):
+    from fqdn import FQDN
+
+    @_checks_drafts(
+        draft3="host-name",
+        draft4="hostname",
+        draft6="hostname",
+        draft7="hostname",
+        draft201909="hostname",
+        draft202012="hostname",
+    )
+    def is_host_name(instance: object) -> bool:
+        if not isinstance(instance, str):
+            return True
+        return FQDN(instance, min_labels=1).is_valid
+
+
+with suppress(ImportError):
+    # The built-in `idna` codec only implements RFC 3890, so we go elsewhere.
+    import idna
+
+    @_checks_drafts(
+        draft7="idn-hostname",
+        draft201909="idn-hostname",
+        draft202012="idn-hostname",
+        raises=(idna.IDNAError, UnicodeError),
+    )
+    def is_idn_host_name(instance: object) -> bool:
+        if not isinstance(instance, str):
+            return True
+        idna.encode(instance)
+        return True
+
+
+try:
+    import rfc3987
+except ImportError:
+    with suppress(ImportError):
+        from rfc3986_validator import validate_rfc3986
+
+        @_checks_drafts(name="uri")
+        def is_uri(instance: object) -> bool:
+            if not isinstance(instance, str):
+                return True
+            return validate_rfc3986(instance, rule="URI")
+
+        @_checks_drafts(
+            draft6="uri-reference",
+            draft7="uri-reference",
+            draft201909="uri-reference",
+            draft202012="uri-reference",
+            raises=ValueError,
+        )
+        def is_uri_reference(instance: object) -> bool:
+            if not isinstance(instance, str):
+                return True
+            return validate_rfc3986(instance, rule="URI_reference")
+
+else:
+
+    @_checks_drafts(
+        draft7="iri",
+        draft201909="iri",
+        draft202012="iri",
+        raises=ValueError,
+    )
+    def is_iri(instance: object) -> bool:
+        if not isinstance(instance, str):
+            return True
+        return rfc3987.parse(instance, rule="IRI")
+
+    @_checks_drafts(
+        draft7="iri-reference",
+        draft201909="iri-reference",
+        draft202012="iri-reference",
+        raises=ValueError,
+    )
+    def is_iri_reference(instance: object) -> bool:
+        if not isinstance(instance, str):
+            return True
+        return rfc3987.parse(instance, rule="IRI_reference")
+
+    @_checks_drafts(name="uri", raises=ValueError)
+    def is_uri(instance: object) -> bool:
+        if not isinstance(instance, str):
+            return True
+        return rfc3987.parse(instance, rule="URI")
+
+    @_checks_drafts(
+        draft6="uri-reference",
+        draft7="uri-reference",
+        draft201909="uri-reference",
+        draft202012="uri-reference",
+        raises=ValueError,
+    )
+    def is_uri_reference(instance: object) -> bool:
+        if not isinstance(instance, str):
+            return True
+        return rfc3987.parse(instance, rule="URI_reference")
+
+
+with suppress(ImportError):
+    from rfc3339_validator import validate_rfc3339
+
+    @_checks_drafts(name="date-time")
+    def is_datetime(instance: object) -> bool:
+        if not isinstance(instance, str):
+            return True
+        return validate_rfc3339(instance.upper())
+
+    @_checks_drafts(
+        draft7="time",
+        draft201909="time",
+        draft202012="time",
+    )
+    def is_time(instance: object) -> bool:
+        if not isinstance(instance, str):
+            return True
+        return is_datetime("1970-01-01T" + instance)
+
+
+@_checks_drafts(name="regex", raises=re.error)
+def is_regex(instance: object) -> bool:
+    if not isinstance(instance, str):
+        return True
+    return bool(re.compile(instance))
+
+
+@_checks_drafts(
+    draft3="date",
+    draft7="date",
+    draft201909="date",
+    draft202012="date",
+    raises=ValueError,
+)
+def is_date(instance: object) -> bool:
+    if not isinstance(instance, str):
+        return True
+    return bool(_RE_DATE.fullmatch(instance) and date.fromisoformat(instance))
+
+
+@_checks_drafts(draft3="time", raises=ValueError)
+def is_draft3_time(instance: object) -> bool:
+    if not isinstance(instance, str):
+        return True
+    return bool(datetime.strptime(instance, "%H:%M:%S"))  # noqa: DTZ007
+
+
+with suppress(ImportError):
+    import webcolors
+
+    @_checks_drafts(draft3="color", raises=(ValueError, TypeError))
+    def is_css21_color(instance: object) -> bool:
+        if isinstance(instance, str):
+            try:
+                webcolors.name_to_hex(instance)
+            except ValueError:
+                webcolors.normalize_hex(instance.lower())
+        return True
+
+
+with suppress(ImportError):
+    import jsonpointer
+
+    @_checks_drafts(
+        draft6="json-pointer",
+        draft7="json-pointer",
+        draft201909="json-pointer",
+        draft202012="json-pointer",
+        raises=jsonpointer.JsonPointerException,
+    )
+    def is_json_pointer(instance: object) -> bool:
+        if not isinstance(instance, str):
+            return True
+        return bool(jsonpointer.JsonPointer(instance))
+
+    # TODO: I don't want to maintain this, so it
+    #       needs to go either into jsonpointer (pending
+    #       https://github.com/stefankoegl/python-json-pointer/issues/34) or
+    #       into a new external library.
+    @_checks_drafts(
+        draft7="relative-json-pointer",
+        draft201909="relative-json-pointer",
+        draft202012="relative-json-pointer",
+        raises=jsonpointer.JsonPointerException,
+    )
+    def is_relative_json_pointer(instance: object) -> bool:
+        # Definition taken from:
+        # https://tools.ietf.org/html/draft-handrews-relative-json-pointer-01#section-3
+        if not isinstance(instance, str):
+            return True
+        if not instance:
+            return False
+
+        non_negative_integer, rest = [], ""
+        for i, character in enumerate(instance):
+            if character.isdigit():
+                # digits with a leading "0" are not allowed
+                if i > 0 and int(instance[i - 1]) == 0:
+                    return False
+
+                non_negative_integer.append(character)
+                continue
+
+            if not non_negative_integer:
+                return False
+
+            rest = instance[i:]
+            break
+        return (rest == "#") or bool(jsonpointer.JsonPointer(rest))
+
+
+with suppress(ImportError):
+    import uri_template
+
+    @_checks_drafts(
+        draft6="uri-template",
+        draft7="uri-template",
+        draft201909="uri-template",
+        draft202012="uri-template",
+    )
+    def is_uri_template(instance: object) -> bool:
+        if not isinstance(instance, str):
+            return True
+        return uri_template.validate(instance)
+
+
+with suppress(ImportError):
+    import isoduration
+
+    @_checks_drafts(
+        draft201909="duration",
+        draft202012="duration",
+        raises=isoduration.DurationParsingException,
+    )
+    def is_duration(instance: object) -> bool:
+        if not isinstance(instance, str):
+            return True
+        isoduration.parse_duration(instance)
+        # FIXME: See bolsote/isoduration#25 and bolsote/isoduration#21
+        return instance.endswith(tuple("DMYWHMS"))
+
+
+@_checks_drafts(
+    draft201909="uuid",
+    draft202012="uuid",
+    raises=ValueError,
+)
+def is_uuid(instance: object) -> bool:
+    if not isinstance(instance, str):
+        return True
+    UUID(instance)
+    return all(instance[position] == "-" for position in (8, 13, 18, 23))

.venv/lib/python3.11/site-packages/jsonschema/_legacy_keywords.py

@@ -0,0 +1,449 @@
+import re
+
+from referencing.jsonschema import lookup_recursive_ref
+
+from jsonschema import _utils
+from jsonschema.exceptions import ValidationError
+
+
+def ignore_ref_siblings(schema):
+    """
+    Ignore siblings of ``$ref`` if it is present.
+
+    Otherwise, return all keywords.
+
+    Suitable for use with `create`'s ``applicable_validators`` argument.
+    """
+    ref = schema.get("$ref")
+    if ref is not None:
+        return [("$ref", ref)]
+    else:
+        return schema.items()
+
+
+def dependencies_draft3(validator, dependencies, instance, schema):
+    if not validator.is_type(instance, "object"):
+        return
+
+    for property, dependency in dependencies.items():
+        if property not in instance:
+            continue
+
+        if validator.is_type(dependency, "object"):
+            yield from validator.descend(
+                instance, dependency, schema_path=property,
+            )
+        elif validator.is_type(dependency, "string"):
+            if dependency not in instance:
+                message = f"{dependency!r} is a dependency of {property!r}"
+                yield ValidationError(message)
+        else:
+            for each in dependency:
+                if each not in instance:
+                    message = f"{each!r} is a dependency of {property!r}"
+                    yield ValidationError(message)
+
+
+def dependencies_draft4_draft6_draft7(
+    validator,
+    dependencies,
+    instance,
+    schema,
+):
+    """
+    Support for the ``dependencies`` keyword from pre-draft 2019-09.
+
+    In later drafts, the keyword was split into separate
+    ``dependentRequired`` and ``dependentSchemas`` validators.
+    """
+    if not validator.is_type(instance, "object"):
+        return
+
+    for property, dependency in dependencies.items():
+        if property not in instance:
+            continue
+
+        if validator.is_type(dependency, "array"):
+            for each in dependency:
+                if each not in instance:
+                    message = f"{each!r} is a dependency of {property!r}"
+                    yield ValidationError(message)
+        else:
+            yield from validator.descend(
+                instance, dependency, schema_path=property,
+            )
+
+
+def disallow_draft3(validator, disallow, instance, schema):
+    for disallowed in _utils.ensure_list(disallow):
+        if validator.evolve(schema={"type": [disallowed]}).is_valid(instance):
+            message = f"{disallowed!r} is disallowed for {instance!r}"
+            yield ValidationError(message)
+
+
+def extends_draft3(validator, extends, instance, schema):
+    if validator.is_type(extends, "object"):
+        yield from validator.descend(instance, extends)
+        return
+    for index, subschema in enumerate(extends):
+        yield from validator.descend(instance, subschema, schema_path=index)
+
+
+def items_draft3_draft4(validator, items, instance, schema):
+    if not validator.is_type(instance, "array"):
+        return
+
+    if validator.is_type(items, "object"):
+        for index, item in enumerate(instance):
+            yield from validator.descend(item, items, path=index)
+    else:
+        for (index, item), subschema in zip(enumerate(instance), items):
+            yield from validator.descend(
+                item, subschema, path=index, schema_path=index,
+            )
+
+
+def additionalItems(validator, aI, instance, schema):
+    if (
+        not validator.is_type(instance, "array")
+        or validator.is_type(schema.get("items", {}), "object")
+    ):
+        return
+
+    len_items = len(schema.get("items", []))
+    if validator.is_type(aI, "object"):
+        for index, item in enumerate(instance[len_items:], start=len_items):
+            yield from validator.descend(item, aI, path=index)
+    elif not aI and len(instance) > len(schema.get("items", [])):
+        error = "Additional items are not allowed (%s %s unexpected)"
+        yield ValidationError(
+            error % _utils.extras_msg(instance[len(schema.get("items", [])):]),
+        )
+
+
+def items_draft6_draft7_draft201909(validator, items, instance, schema):
+    if not validator.is_type(instance, "array"):
+        return
+
+    if validator.is_type(items, "array"):
+        for (index, item), subschema in zip(enumerate(instance), items):
+            yield from validator.descend(
+                item, subschema, path=index, schema_path=index,
+            )
+    else:
+        for index, item in enumerate(instance):
+            yield from validator.descend(item, items, path=index)
+
+
+def minimum_draft3_draft4(validator, minimum, instance, schema):
+    if not validator.is_type(instance, "number"):
+        return
+
+    if schema.get("exclusiveMinimum", False):
+        failed = instance <= minimum
+        cmp = "less than or equal to"
+    else:
+        failed = instance < minimum
+        cmp = "less than"
+
+    if failed:
+        message = f"{instance!r} is {cmp} the minimum of {minimum!r}"
+        yield ValidationError(message)
+
+
+def maximum_draft3_draft4(validator, maximum, instance, schema):
+    if not validator.is_type(instance, "number"):
+        return
+
+    if schema.get("exclusiveMaximum", False):
+        failed = instance >= maximum
+        cmp = "greater than or equal to"
+    else:
+        failed = instance > maximum
+        cmp = "greater than"
+
+    if failed:
+        message = f"{instance!r} is {cmp} the maximum of {maximum!r}"
+        yield ValidationError(message)
+
+
+def properties_draft3(validator, properties, instance, schema):
+    if not validator.is_type(instance, "object"):
+        return
+
+    for property, subschema in properties.items():
+        if property in instance:
+            yield from validator.descend(
+                instance[property],
+                subschema,
+                path=property,
+                schema_path=property,
+            )
+        elif subschema.get("required", False):
+            error = ValidationError(f"{property!r} is a required property")
+            error._set(
+                validator="required",
+                validator_value=subschema["required"],
+                instance=instance,
+                schema=schema,
+            )
+            error.path.appendleft(property)
+            error.schema_path.extend([property, "required"])
+            yield error
+
+
+def type_draft3(validator, types, instance, schema):
+    types = _utils.ensure_list(types)
+
+    all_errors = []
+    for index, type in enumerate(types):
+        if validator.is_type(type, "object"):
+            errors = list(validator.descend(instance, type, schema_path=index))
+            if not errors:
+                return
+            all_errors.extend(errors)
+        elif validator.is_type(instance, type):
+                return
+
+    reprs = []
+    for type in types:
+        try:
+            reprs.append(repr(type["name"]))
+        except Exception:  # noqa: BLE001
+            reprs.append(repr(type))
+    yield ValidationError(
+        f"{instance!r} is not of type {', '.join(reprs)}",
+        context=all_errors,
+    )
+
+
+def contains_draft6_draft7(validator, contains, instance, schema):
+    if not validator.is_type(instance, "array"):
+        return
+
+    if not any(
+        validator.evolve(schema=contains).is_valid(element)
+        for element in instance
+    ):
+        yield ValidationError(
+            f"None of {instance!r} are valid under the given schema",
+        )
+
+
+def recursiveRef(validator, recursiveRef, instance, schema):
+    resolved = lookup_recursive_ref(validator._resolver)
+    yield from validator.descend(
+        instance,
+        resolved.contents,
+        resolver=resolved.resolver,
+    )
+
+
+def find_evaluated_item_indexes_by_schema(validator, instance, schema):
+    """
+    Get all indexes of items that get evaluated under the current schema.
+
+    Covers all keywords related to unevaluatedItems: items, prefixItems, if,
+    then, else, contains, unevaluatedItems, allOf, oneOf, anyOf
+    """
+    if validator.is_type(schema, "boolean"):
+        return []
+    evaluated_indexes = []
+
+    ref = schema.get("$ref")
+    if ref is not None:
+        resolved = validator._resolver.lookup(ref)
+        evaluated_indexes.extend(
+            find_evaluated_item_indexes_by_schema(
+                validator.evolve(
+                    schema=resolved.contents,
+                    _resolver=resolved.resolver,
+                ),
+                instance,
+                resolved.contents,
+            ),
+        )
+
+    if "$recursiveRef" in schema:
+        resolved = lookup_recursive_ref(validator._resolver)
+        evaluated_indexes.extend(
+            find_evaluated_item_indexes_by_schema(
+                validator.evolve(
+                    schema=resolved.contents,
+                    _resolver=resolved.resolver,
+                ),
+                instance,
+                resolved.contents,
+            ),
+        )
+
+    if "items" in schema:
+        if "additionalItems" in schema:
+            return list(range(len(instance)))
+
+        if validator.is_type(schema["items"], "object"):
+            return list(range(len(instance)))
+        evaluated_indexes += list(range(len(schema["items"])))
+
+    if "if" in schema:
+        if validator.evolve(schema=schema["if"]).is_valid(instance):
+            evaluated_indexes += find_evaluated_item_indexes_by_schema(
+                validator, instance, schema["if"],
+            )
+            if "then" in schema:
+                evaluated_indexes += find_evaluated_item_indexes_by_schema(
+                    validator, instance, schema["then"],
+                )
+        elif "else" in schema:
+            evaluated_indexes += find_evaluated_item_indexes_by_schema(
+                validator, instance, schema["else"],
+            )
+
+    for keyword in ["contains", "unevaluatedItems"]:
+        if keyword in schema:
+            for k, v in enumerate(instance):
+                if validator.evolve(schema=schema[keyword]).is_valid(v):
+                    evaluated_indexes.append(k)
+
+    for keyword in ["allOf", "oneOf", "anyOf"]:
+        if keyword in schema:
+            for subschema in schema[keyword]:
+                errs = next(validator.descend(instance, subschema), None)
+                if errs is None:
+                    evaluated_indexes += find_evaluated_item_indexes_by_schema(
+                        validator, instance, subschema,
+                    )
+
+    return evaluated_indexes
+
+
+def unevaluatedItems_draft2019(validator, unevaluatedItems, instance, schema):
+    if not validator.is_type(instance, "array"):
+        return
+    evaluated_item_indexes = find_evaluated_item_indexes_by_schema(
+        validator, instance, schema,
+    )
+    unevaluated_items = [
+        item for index, item in enumerate(instance)
+        if index not in evaluated_item_indexes
+    ]
+    if unevaluated_items:
+        error = "Unevaluated items are not allowed (%s %s unexpected)"
+        yield ValidationError(error % _utils.extras_msg(unevaluated_items))
+
+
+def find_evaluated_property_keys_by_schema(validator, instance, schema):
+    if validator.is_type(schema, "boolean"):
+        return []
+    evaluated_keys = []
+
+    ref = schema.get("$ref")
+    if ref is not None:
+        resolved = validator._resolver.lookup(ref)
+        evaluated_keys.extend(
+            find_evaluated_property_keys_by_schema(
+                validator.evolve(
+                    schema=resolved.contents,
+                    _resolver=resolved.resolver,
+                ),
+                instance,
+                resolved.contents,
+            ),
+        )
+
+    if "$recursiveRef" in schema:
+        resolved = lookup_recursive_ref(validator._resolver)
+        evaluated_keys.extend(
+            find_evaluated_property_keys_by_schema(
+                validator.evolve(
+                    schema=resolved.contents,
+                    _resolver=resolved.resolver,
+                ),
+                instance,
+                resolved.contents,
+            ),
+        )
+
+    for keyword in [
+        "properties", "additionalProperties", "unevaluatedProperties",
+    ]:
+        if keyword in schema:
+            schema_value = schema[keyword]
+            if validator.is_type(schema_value, "boolean") and schema_value:
+                evaluated_keys += instance.keys()
+
+            elif validator.is_type(schema_value, "object"):
+                for property in schema_value:
+                    if property in instance:
+                        evaluated_keys.append(property)
+
+    if "patternProperties" in schema:
+        for property in instance:
+            for pattern in schema["patternProperties"]:
+                if re.search(pattern, property):
+                    evaluated_keys.append(property)
+
+    if "dependentSchemas" in schema:
+        for property, subschema in schema["dependentSchemas"].items():
+            if property not in instance:
+                continue
+            evaluated_keys += find_evaluated_property_keys_by_schema(
+                validator, instance, subschema,
+            )
+
+    for keyword in ["allOf", "oneOf", "anyOf"]:
+        if keyword in schema:
+            for subschema in schema[keyword]:
+                errs = next(validator.descend(instance, subschema), None)
+                if errs is None:
+                    evaluated_keys += find_evaluated_property_keys_by_schema(
+                        validator, instance, subschema,
+                    )
+
+    if "if" in schema:
+        if validator.evolve(schema=schema["if"]).is_valid(instance):
+            evaluated_keys += find_evaluated_property_keys_by_schema(
+                validator, instance, schema["if"],
+            )
+            if "then" in schema:
+                evaluated_keys += find_evaluated_property_keys_by_schema(
+                    validator, instance, schema["then"],
+                )
+        elif "else" in schema:
+            evaluated_keys += find_evaluated_property_keys_by_schema(
+                validator, instance, schema["else"],
+            )
+
+    return evaluated_keys
+
+
+def unevaluatedProperties_draft2019(validator, uP, instance, schema):
+    if not validator.is_type(instance, "object"):
+        return
+    evaluated_keys = find_evaluated_property_keys_by_schema(
+        validator, instance, schema,
+    )
+    unevaluated_keys = []
+    for property in instance:
+        if property not in evaluated_keys:
+            for _ in validator.descend(
+                instance[property],
+                uP,
+                path=property,
+                schema_path=property,
+            ):
+                # FIXME: Include context for each unevaluated property
+                #        indicating why it's invalid under the subschema.
+                unevaluated_keys.append(property)  # noqa: PERF401
+
+    if unevaluated_keys:
+        if uP is False:
+            error = "Unevaluated properties are not allowed (%s %s unexpected)"
+            extras = sorted(unevaluated_keys, key=str)
+            yield ValidationError(error % _utils.extras_msg(extras))
+        else:
+            error = (
+                "Unevaluated properties are not valid under "
+                "the given schema (%s %s unevaluated and invalid)"
+            )
+            yield ValidationError(error % _utils.extras_msg(unevaluated_keys))

.venv/lib/python3.11/site-packages/jsonschema/_types.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+from typing import Any, Callable, Mapping
+import numbers
+
+from attrs import evolve, field, frozen
+from rpds import HashTrieMap
+
+from jsonschema.exceptions import UndefinedTypeCheck
+
+
+# unfortunately, the type of HashTrieMap is generic, and if used as an attrs
+# converter, the generic type is presented to mypy, which then fails to match
+# the concrete type of a type checker mapping
+# this "do nothing" wrapper presents the correct information to mypy
+def _typed_map_converter(
+    init_val: Mapping[str, Callable[[TypeChecker, Any], bool]],
+) -> HashTrieMap[str, Callable[[TypeChecker, Any], bool]]:
+    return HashTrieMap.convert(init_val)
+
+
+def is_array(checker, instance):
+    return isinstance(instance, list)
+
+
+def is_bool(checker, instance):
+    return isinstance(instance, bool)
+
+
+def is_integer(checker, instance):
+    # bool inherits from int, so ensure bools aren't reported as ints
+    if isinstance(instance, bool):
+        return False
+    return isinstance(instance, int)
+
+
+def is_null(checker, instance):
+    return instance is None
+
+
+def is_number(checker, instance):
+    # bool inherits from int, so ensure bools aren't reported as ints
+    if isinstance(instance, bool):
+        return False
+    return isinstance(instance, numbers.Number)
+
+
+def is_object(checker, instance):
+    return isinstance(instance, dict)
+
+
+def is_string(checker, instance):
+    return isinstance(instance, str)
+
+
+def is_any(checker, instance):
+    return True
+
+
+@frozen(repr=False)
+class TypeChecker:
+    """
+    A :kw:`type` property checker.
+
+    A `TypeChecker` performs type checking for a `Validator`, converting
+    between the defined JSON Schema types and some associated Python types or
+    objects.
+
+    Modifying the behavior just mentioned by redefining which Python objects
+    are considered to be of which JSON Schema types can be done using
+    `TypeChecker.redefine` or `TypeChecker.redefine_many`, and types can be
+    removed via `TypeChecker.remove`. Each of these return a new `TypeChecker`.
+
+    Arguments:
+
+        type_checkers:
+
+            The initial mapping of types to their checking functions.
+
+    """
+
+    _type_checkers: HashTrieMap[
+        str, Callable[[TypeChecker, Any], bool],
+    ] = field(default=HashTrieMap(), converter=_typed_map_converter)
+
+    def __repr__(self):
+        types = ", ".join(repr(k) for k in sorted(self._type_checkers))
+        return f"<{self.__class__.__name__} types={{{types}}}>"
+
+    def is_type(self, instance, type: str) -> bool:
+        """
+        Check if the instance is of the appropriate type.
+
+        Arguments:
+
+            instance:
+
+                The instance to check
+
+            type:
+
+                The name of the type that is expected.
+
+        Raises:
+
+            `jsonschema.exceptions.UndefinedTypeCheck`:
+
+                if ``type`` is unknown to this object.
+
+        """
+        try:
+            fn = self._type_checkers[type]
+        except KeyError:
+            raise UndefinedTypeCheck(type) from None
+
+        return fn(self, instance)
+
+    def redefine(self, type: str, fn) -> TypeChecker:
+        """
+        Produce a new checker with the given type redefined.
+
+        Arguments:
+
+            type:
+
+                The name of the type to check.
+
+            fn (collections.abc.Callable):
+
+                A callable taking exactly two parameters - the type
+                checker calling the function and the instance to check.
+                The function should return true if instance is of this
+                type and false otherwise.
+
+        """
+        return self.redefine_many({type: fn})
+
+    def redefine_many(self, definitions=()) -> TypeChecker:
+        """
+        Produce a new checker with the given types redefined.
+
+        Arguments:
+
+            definitions (dict):
+
+                A dictionary mapping types to their checking functions.
+
+        """
+        type_checkers = self._type_checkers.update(definitions)
+        return evolve(self, type_checkers=type_checkers)
+
+    def remove(self, *types) -> TypeChecker:
+        """
+        Produce a new checker with the given types forgotten.
+
+        Arguments:
+
+            types:
+
+                the names of the types to remove.
+
+        Raises:
+
+            `jsonschema.exceptions.UndefinedTypeCheck`:
+
+                if any given type is unknown to this object
+
+        """
+        type_checkers = self._type_checkers
+        for each in types:
+            try:
+                type_checkers = type_checkers.remove(each)
+            except KeyError:
+                raise UndefinedTypeCheck(each) from None
+        return evolve(self, type_checkers=type_checkers)
+
+
+draft3_type_checker = TypeChecker(
+    {
+        "any": is_any,
+        "array": is_array,
+        "boolean": is_bool,
+        "integer": is_integer,
+        "object": is_object,
+        "null": is_null,
+        "number": is_number,
+        "string": is_string,
+    },
+)
+draft4_type_checker = draft3_type_checker.remove("any")
+draft6_type_checker = draft4_type_checker.redefine(
+    "integer",
+    lambda checker, instance: (
+        is_integer(checker, instance)
+        or isinstance(instance, float) and instance.is_integer()
+    ),
+)
+draft7_type_checker = draft6_type_checker
+draft201909_type_checker = draft7_type_checker
+draft202012_type_checker = draft201909_type_checker

.venv/lib/python3.11/site-packages/jsonschema/_typing.py

@@ -0,0 +1,28 @@
+"""
+Some (initially private) typing helpers for jsonschema's types.
+"""
+from typing import Any, Callable, Iterable, Protocol, Tuple, Union
+
+import referencing.jsonschema
+
+from jsonschema.protocols import Validator
+
+
+class SchemaKeywordValidator(Protocol):
+    def __call__(
+        self,
+        validator: Validator,
+        value: Any,
+        instance: Any,
+        schema: referencing.jsonschema.Schema,
+    ) -> None:
+        ...
+
+
+id_of = Callable[[referencing.jsonschema.Schema], Union[str, None]]
+
+
+ApplicableValidators = Callable[
+    [referencing.jsonschema.Schema],
+    Iterable[Tuple[str, Any]],
+]

.venv/lib/python3.11/site-packages/jsonschema/_utils.py

@@ -0,0 +1,351 @@
+from collections.abc import Mapping, MutableMapping, Sequence
+from urllib.parse import urlsplit
+import itertools
+import re
+
+
+class URIDict(MutableMapping):
+    """
+    Dictionary which uses normalized URIs as keys.
+    """
+
+    def normalize(self, uri):
+        return urlsplit(uri).geturl()
+
+    def __init__(self, *args, **kwargs):
+        self.store = dict()
+        self.store.update(*args, **kwargs)
+
+    def __getitem__(self, uri):
+        return self.store[self.normalize(uri)]
+
+    def __setitem__(self, uri, value):
+        self.store[self.normalize(uri)] = value
+
+    def __delitem__(self, uri):
+        del self.store[self.normalize(uri)]
+
+    def __iter__(self):
+        return iter(self.store)
+
+    def __len__(self):  # pragma: no cover -- untested, but to be removed
+        return len(self.store)
+
+    def __repr__(self):  # pragma: no cover -- untested, but to be removed
+        return repr(self.store)
+
+
+class Unset:
+    """
+    An as-of-yet unset attribute or unprovided default parameter.
+    """
+
+    def __repr__(self):  # pragma: no cover
+        return "<unset>"
+
+
+def format_as_index(container, indices):
+    """
+    Construct a single string containing indexing operations for the indices.
+
+    For example for a container ``bar``, [1, 2, "foo"] -> bar[1][2]["foo"]
+
+    Arguments:
+
+        container (str):
+
+            A word to use for the thing being indexed
+
+        indices (sequence):
+
+            The indices to format.
+
+    """
+    if not indices:
+        return container
+    return f"{container}[{']['.join(repr(index) for index in indices)}]"
+
+
+def find_additional_properties(instance, schema):
+    """
+    Return the set of additional properties for the given ``instance``.
+
+    Weeds out properties that should have been validated by ``properties`` and
+    / or ``patternProperties``.
+
+    Assumes ``instance`` is dict-like already.
+    """
+    properties = schema.get("properties", {})
+    patterns = "|".join(schema.get("patternProperties", {}))
+    for property in instance:
+        if property not in properties:
+            if patterns and re.search(patterns, property):
+                continue
+            yield property
+
+
+def extras_msg(extras):
+    """
+    Create an error message for extra items or properties.
+    """
+    verb = "was" if len(extras) == 1 else "were"
+    return ", ".join(repr(extra) for extra in extras), verb
+
+
+def ensure_list(thing):
+    """
+    Wrap ``thing`` in a list if it's a single str.
+
+    Otherwise, return it unchanged.
+    """
+    if isinstance(thing, str):
+        return [thing]
+    return thing
+
+
+def _mapping_equal(one, two):
+    """
+    Check if two mappings are equal using the semantics of `equal`.
+    """
+    if len(one) != len(two):
+        return False
+    return all(
+        key in two and equal(value, two[key])
+        for key, value in one.items()
+    )
+
+
+def _sequence_equal(one, two):
+    """
+    Check if two sequences are equal using the semantics of `equal`.
+    """
+    if len(one) != len(two):
+        return False
+    return all(equal(i, j) for i, j in zip(one, two))
+
+
+def equal(one, two):
+    """
+    Check if two things are equal evading some Python type hierarchy semantics.
+
+    Specifically in JSON Schema, evade `bool` inheriting from `int`,
+    recursing into sequences to do the same.
+    """
+    if one is two:
+        return True
+    if isinstance(one, str) or isinstance(two, str):
+        return one == two
+    if isinstance(one, Sequence) and isinstance(two, Sequence):
+        return _sequence_equal(one, two)
+    if isinstance(one, Mapping) and isinstance(two, Mapping):
+        return _mapping_equal(one, two)
+    return unbool(one) == unbool(two)
+
+
+def unbool(element, true=object(), false=object()):
+    """
+    A hack to make True and 1 and False and 0 unique for ``uniq``.
+    """
+    if element is True:
+        return true
+    elif element is False:
+        return false
+    return element
+
+
+def uniq(container):
+    """
+    Check if all of a container's elements are unique.
+
+    Tries to rely on the container being recursively sortable, or otherwise
+    falls back on (slow) brute force.
+    """
+    try:
+        sort = sorted(unbool(i) for i in container)
+        sliced = itertools.islice(sort, 1, None)
+
+        for i, j in zip(sort, sliced):
+            if equal(i, j):
+                return False
+
+    except (NotImplementedError, TypeError):
+        seen = []
+        for e in container:
+            e = unbool(e)
+
+            for i in seen:
+                if equal(i, e):
+                    return False
+
+            seen.append(e)
+    return True
+
+
+def find_evaluated_item_indexes_by_schema(validator, instance, schema):
+    """
+    Get all indexes of items that get evaluated under the current schema.
+
+    Covers all keywords related to unevaluatedItems: items, prefixItems, if,
+    then, else, contains, unevaluatedItems, allOf, oneOf, anyOf
+    """
+    if validator.is_type(schema, "boolean"):
+        return []
+    evaluated_indexes = []
+
+    if "items" in schema:
+        return list(range(len(instance)))
+
+    ref = schema.get("$ref")
+    if ref is not None:
+        resolved = validator._resolver.lookup(ref)
+        evaluated_indexes.extend(
+            find_evaluated_item_indexes_by_schema(
+                validator.evolve(
+                    schema=resolved.contents,
+                    _resolver=resolved.resolver,
+                ),
+                instance,
+                resolved.contents,
+            ),
+        )
+
+    dynamicRef = schema.get("$dynamicRef")
+    if dynamicRef is not None:
+        resolved = validator._resolver.lookup(dynamicRef)
+        evaluated_indexes.extend(
+            find_evaluated_item_indexes_by_schema(
+                validator.evolve(
+                    schema=resolved.contents,
+                    _resolver=resolved.resolver,
+                ),
+                instance,
+                resolved.contents,
+            ),
+        )
+
+    if "prefixItems" in schema:
+        evaluated_indexes += list(range(len(schema["prefixItems"])))
+
+    if "if" in schema:
+        if validator.evolve(schema=schema["if"]).is_valid(instance):
+            evaluated_indexes += find_evaluated_item_indexes_by_schema(
+                validator, instance, schema["if"],
+            )
+            if "then" in schema:
+                evaluated_indexes += find_evaluated_item_indexes_by_schema(
+                    validator, instance, schema["then"],
+                )
+        elif "else" in schema:
+            evaluated_indexes += find_evaluated_item_indexes_by_schema(
+                validator, instance, schema["else"],
+            )
+
+    for keyword in ["contains", "unevaluatedItems"]:
+        if keyword in schema:
+            for k, v in enumerate(instance):
+                if validator.evolve(schema=schema[keyword]).is_valid(v):
+                    evaluated_indexes.append(k)
+
+    for keyword in ["allOf", "oneOf", "anyOf"]:
+        if keyword in schema:
+            for subschema in schema[keyword]:
+                errs = next(validator.descend(instance, subschema), None)
+                if errs is None:
+                    evaluated_indexes += find_evaluated_item_indexes_by_schema(
+                        validator, instance, subschema,
+                    )
+
+    return evaluated_indexes
+
+
+def find_evaluated_property_keys_by_schema(validator, instance, schema):
+    """
+    Get all keys of items that get evaluated under the current schema.
+
+    Covers all keywords related to unevaluatedProperties: properties,
+    additionalProperties, unevaluatedProperties, patternProperties,
+    dependentSchemas, allOf, oneOf, anyOf, if, then, else
+    """
+    if validator.is_type(schema, "boolean"):
+        return []
+    evaluated_keys = []
+
+    ref = schema.get("$ref")
+    if ref is not None:
+        resolved = validator._resolver.lookup(ref)
+        evaluated_keys.extend(
+            find_evaluated_property_keys_by_schema(
+                validator.evolve(
+                    schema=resolved.contents,
+                    _resolver=resolved.resolver,
+                ),
+                instance,
+                resolved.contents,
+            ),
+        )
+
+    dynamicRef = schema.get("$dynamicRef")
+    if dynamicRef is not None:
+        resolved = validator._resolver.lookup(dynamicRef)
+        evaluated_keys.extend(
+            find_evaluated_property_keys_by_schema(
+                validator.evolve(
+                    schema=resolved.contents,
+                    _resolver=resolved.resolver,
+                ),
+                instance,
+                resolved.contents,
+            ),
+        )
+
+    for keyword in [
+        "properties", "additionalProperties", "unevaluatedProperties",
+    ]:
+        if keyword in schema:
+            schema_value = schema[keyword]
+            if validator.is_type(schema_value, "boolean") and schema_value:
+                evaluated_keys += instance.keys()
+
+            elif validator.is_type(schema_value, "object"):
+                for property in schema_value:
+                    if property in instance:
+                        evaluated_keys.append(property)
+
+    if "patternProperties" in schema:
+        for property in instance:
+            for pattern in schema["patternProperties"]:
+                if re.search(pattern, property):
+                    evaluated_keys.append(property)
+
+    if "dependentSchemas" in schema:
+        for property, subschema in schema["dependentSchemas"].items():
+            if property not in instance:
+                continue
+            evaluated_keys += find_evaluated_property_keys_by_schema(
+                validator, instance, subschema,
+            )
+
+    for keyword in ["allOf", "oneOf", "anyOf"]:
+        if keyword in schema:
+            for subschema in schema[keyword]:
+                errs = next(validator.descend(instance, subschema), None)
+                if errs is None:
+                    evaluated_keys += find_evaluated_property_keys_by_schema(
+                        validator, instance, subschema,
+                    )
+
+    if "if" in schema:
+        if validator.evolve(schema=schema["if"]).is_valid(instance):
+            evaluated_keys += find_evaluated_property_keys_by_schema(
+                validator, instance, schema["if"],
+            )
+            if "then" in schema:
+                evaluated_keys += find_evaluated_property_keys_by_schema(
+                    validator, instance, schema["then"],
+                )
+        elif "else" in schema:
+            evaluated_keys += find_evaluated_property_keys_by_schema(
+                validator, instance, schema["else"],
+            )
+
+    return evaluated_keys

.venv/lib/python3.11/site-packages/jsonschema/benchmarks/__init__.py

@@ -0,0 +1,5 @@
+"""
+Benchmarks for validation.
+
+This package is *not* public API.
+"""

.venv/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,
+    )

.venv/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),
+        )

.venv/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))

.venv/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),
+    )

.venv/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),
+            )

.venv/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))

.venv/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

.venv/lib/python3.11/site-packages/jsonschema/exceptions.py

@@ -0,0 +1,487 @@
+"""
+Validation errors, and some surrounding helpers.
+"""
+from __future__ import annotations
+
+from collections import defaultdict, deque
+from pprint import pformat
+from textwrap import dedent, indent
+from typing import TYPE_CHECKING, Any, ClassVar
+import heapq
+import itertools
+import warnings
+
+from attrs import define
+from referencing.exceptions import Unresolvable as _Unresolvable
+
+from jsonschema import _utils
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Mapping, MutableMapping, Sequence
+
+    from jsonschema import _types
+
+WEAK_MATCHES: frozenset[str] = frozenset(["anyOf", "oneOf"])
+STRONG_MATCHES: frozenset[str] = frozenset()
+
+_unset = _utils.Unset()
+
+
+def _pretty(thing: Any, prefix: str):
+    """
+    Format something for an error message as prettily as we currently can.
+    """
+    return indent(pformat(thing, width=72, sort_dicts=False), prefix).lstrip()
+
+
+def __getattr__(name):
+    if name == "RefResolutionError":
+        warnings.warn(
+            _RefResolutionError._DEPRECATION_MESSAGE,
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return _RefResolutionError
+    raise AttributeError(f"module {__name__} has no attribute {name}")
+
+
+class _Error(Exception):
+
+    _word_for_schema_in_error_message: ClassVar[str]
+    _word_for_instance_in_error_message: ClassVar[str]
+
+    def __init__(
+        self,
+        message: str,
+        validator: str = _unset,  # type: ignore[assignment]
+        path: Iterable[str | int] = (),
+        cause: Exception | None = None,
+        context=(),
+        validator_value: Any = _unset,
+        instance: Any = _unset,
+        schema: Mapping[str, Any] | bool = _unset,  # type: ignore[assignment]
+        schema_path: Iterable[str | int] = (),
+        parent: _Error | None = None,
+        type_checker: _types.TypeChecker = _unset,  # type: ignore[assignment]
+    ) -> None:
+        super().__init__(
+            message,
+            validator,
+            path,
+            cause,
+            context,
+            validator_value,
+            instance,
+            schema,
+            schema_path,
+            parent,
+        )
+        self.message = message
+        self.path = self.relative_path = deque(path)
+        self.schema_path = self.relative_schema_path = deque(schema_path)
+        self.context = list(context)
+        self.cause = self.__cause__ = cause
+        self.validator = validator
+        self.validator_value = validator_value
+        self.instance = instance
+        self.schema = schema
+        self.parent = parent
+        self._type_checker = type_checker
+
+        for error in context:
+            error.parent = self
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__}: {self.message!r}>"
+
+    def __str__(self) -> str:
+        essential_for_verbose = (
+            self.validator, self.validator_value, self.instance, self.schema,
+        )
+        if any(m is _unset for m in essential_for_verbose):
+            return self.message
+
+        schema_path = _utils.format_as_index(
+            container=self._word_for_schema_in_error_message,
+            indices=list(self.relative_schema_path)[:-1],
+        )
+        instance_path = _utils.format_as_index(
+            container=self._word_for_instance_in_error_message,
+            indices=self.relative_path,
+        )
+        prefix = 16 * " "
+
+        return dedent(
+            f"""\
+            {self.message}
+
+            Failed validating {self.validator!r} in {schema_path}:
+                {_pretty(self.schema, prefix=prefix)}
+
+            On {instance_path}:
+                {_pretty(self.instance, prefix=prefix)}
+            """.rstrip(),
+        )
+
+    @classmethod
+    def create_from(cls, other: _Error):
+        return cls(**other._contents())
+
+    @property
+    def absolute_path(self) -> Sequence[str | int]:
+        parent = self.parent
+        if parent is None:
+            return self.relative_path
+
+        path = deque(self.relative_path)
+        path.extendleft(reversed(parent.absolute_path))
+        return path
+
+    @property
+    def absolute_schema_path(self) -> Sequence[str | int]:
+        parent = self.parent
+        if parent is None:
+            return self.relative_schema_path
+
+        path = deque(self.relative_schema_path)
+        path.extendleft(reversed(parent.absolute_schema_path))
+        return path
+
+    @property
+    def json_path(self) -> str:
+        path = "$"
+        for elem in self.absolute_path:
+            if isinstance(elem, int):
+                path += "[" + str(elem) + "]"
+            else:
+                path += "." + elem
+        return path
+
+    def _set(
+        self,
+        type_checker: _types.TypeChecker | None = None,
+        **kwargs: Any,
+    ) -> None:
+        if type_checker is not None and self._type_checker is _unset:
+            self._type_checker = type_checker
+
+        for k, v in kwargs.items():
+            if getattr(self, k) is _unset:
+                setattr(self, k, v)
+
+    def _contents(self):
+        attrs = (
+            "message", "cause", "context", "validator", "validator_value",
+            "path", "schema_path", "instance", "schema", "parent",
+        )
+        return {attr: getattr(self, attr) for attr in attrs}
+
+    def _matches_type(self) -> bool:
+        try:
+            # We ignore this as we want to simply crash if this happens
+            expected = self.schema["type"]  # type: ignore[index]
+        except (KeyError, TypeError):
+            return False
+
+        if isinstance(expected, str):
+            return self._type_checker.is_type(self.instance, expected)
+
+        return any(
+            self._type_checker.is_type(self.instance, expected_type)
+            for expected_type in expected
+        )
+
+
+class ValidationError(_Error):
+    """
+    An instance was invalid under a provided schema.
+    """
+
+    _word_for_schema_in_error_message = "schema"
+    _word_for_instance_in_error_message = "instance"
+
+
+class SchemaError(_Error):
+    """
+    A schema was invalid under its corresponding metaschema.
+    """
+
+    _word_for_schema_in_error_message = "metaschema"
+    _word_for_instance_in_error_message = "schema"
+
+
+@define(slots=False)
+class _RefResolutionError(Exception):
+    """
+    A ref could not be resolved.
+    """
+
+    _DEPRECATION_MESSAGE = (
+        "jsonschema.exceptions.RefResolutionError is deprecated as of version "
+        "4.18.0. If you wish to catch potential reference resolution errors, "
+        "directly catch referencing.exceptions.Unresolvable."
+    )
+
+    _cause: Exception
+
+    def __eq__(self, other):
+        if self.__class__ is not other.__class__:
+            return NotImplemented  # pragma: no cover -- uncovered but deprecated  # noqa: E501
+        return self._cause == other._cause
+
+    def __str__(self) -> str:
+        return str(self._cause)
+
+
+class _WrappedReferencingError(_RefResolutionError, _Unresolvable):  # pragma: no cover -- partially uncovered but to be removed  # noqa: E501
+    def __init__(self, cause: _Unresolvable):
+        object.__setattr__(self, "_wrapped", cause)
+
+    def __eq__(self, other):
+        if other.__class__ is self.__class__:
+            return self._wrapped == other._wrapped
+        elif other.__class__ is self._wrapped.__class__:
+            return self._wrapped == other
+        return NotImplemented
+
+    def __getattr__(self, attr):
+        return getattr(self._wrapped, attr)
+
+    def __hash__(self):
+        return hash(self._wrapped)
+
+    def __repr__(self):
+        return f"<WrappedReferencingError {self._wrapped!r}>"
+
+    def __str__(self):
+        return f"{self._wrapped.__class__.__name__}: {self._wrapped}"
+
+
+class UndefinedTypeCheck(Exception):
+    """
+    A type checker was asked to check a type it did not have registered.
+    """
+
+    def __init__(self, type: str) -> None:
+        self.type = type
+
+    def __str__(self) -> str:
+        return f"Type {self.type!r} is unknown to this type checker"
+
+
+class UnknownType(Exception):
+    """
+    A validator was asked to validate an instance against an unknown type.
+    """
+
+    def __init__(self, type, instance, schema):
+        self.type = type
+        self.instance = instance
+        self.schema = schema
+
+    def __str__(self):
+        prefix = 16 * " "
+
+        return dedent(
+            f"""\
+            Unknown type {self.type!r} for validator with schema:
+                {_pretty(self.schema, prefix=prefix)}
+
+            While checking instance:
+                {_pretty(self.instance, prefix=prefix)}
+            """.rstrip(),
+        )
+
+
+class FormatError(Exception):
+    """
+    Validating a format failed.
+    """
+
+    def __init__(self, message, cause=None):
+        super().__init__(message, cause)
+        self.message = message
+        self.cause = self.__cause__ = cause
+
+    def __str__(self):
+        return self.message
+
+
+class ErrorTree:
+    """
+    ErrorTrees make it easier to check which validations failed.
+    """
+
+    _instance = _unset
+
+    def __init__(self, errors: Iterable[ValidationError] = ()):
+        self.errors: MutableMapping[str, ValidationError] = {}
+        self._contents: Mapping[str, ErrorTree] = defaultdict(self.__class__)
+
+        for error in errors:
+            container = self
+            for element in error.path:
+                container = container[element]
+            container.errors[error.validator] = error
+
+            container._instance = error.instance
+
+    def __contains__(self, index: str | int):
+        """
+        Check whether ``instance[index]`` has any errors.
+        """
+        return index in self._contents
+
+    def __getitem__(self, index):
+        """
+        Retrieve the child tree one level down at the given ``index``.
+
+        If the index is not in the instance that this tree corresponds
+        to and is not known by this tree, whatever error would be raised
+        by ``instance.__getitem__`` will be propagated (usually this is
+        some subclass of `LookupError`.
+        """
+        if self._instance is not _unset and index not in self:
+            self._instance[index]
+        return self._contents[index]
+
+    def __setitem__(self, index: str | int, value: ErrorTree):
+        """
+        Add an error to the tree at the given ``index``.
+
+        .. deprecated:: v4.20.0
+
+            Setting items on an `ErrorTree` is deprecated without replacement.
+            To populate a tree, provide all of its sub-errors when you
+            construct the tree.
+        """
+        warnings.warn(
+            "ErrorTree.__setitem__ is deprecated without replacement.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        self._contents[index] = value  # type: ignore[index]
+
+    def __iter__(self):
+        """
+        Iterate (non-recursively) over the indices in the instance with errors.
+        """
+        return iter(self._contents)
+
+    def __len__(self):
+        """
+        Return the `total_errors`.
+        """
+        return self.total_errors
+
+    def __repr__(self):
+        total = len(self)
+        errors = "error" if total == 1 else "errors"
+        return f"<{self.__class__.__name__} ({total} total {errors})>"
+
+    @property
+    def total_errors(self):
+        """
+        The total number of errors in the entire tree, including children.
+        """
+        child_errors = sum(len(tree) for _, tree in self._contents.items())
+        return len(self.errors) + child_errors
+
+
+def by_relevance(weak=WEAK_MATCHES, strong=STRONG_MATCHES):
+    """
+    Create a key function that can be used to sort errors by relevance.
+
+    Arguments:
+        weak (set):
+            a collection of validation keywords to consider to be
+            "weak".  If there are two errors at the same level of the
+            instance and one is in the set of weak validation keywords,
+            the other error will take priority. By default, :kw:`anyOf`
+            and :kw:`oneOf` are considered weak keywords and will be
+            superseded by other same-level validation errors.
+
+        strong (set):
+            a collection of validation keywords to consider to be
+            "strong"
+
+    """
+
+    def relevance(error):
+        validator = error.validator
+        return (                        # prefer errors which are ...
+            -len(error.path),           # 'deeper' and thereby more specific
+            error.path,                 # earlier (for sibling errors)
+            validator not in weak,      # for a non-low-priority keyword
+            validator in strong,        # for a high priority keyword
+            not error._matches_type(),  # at least match the instance's type
+        )                               # otherwise we'll treat them the same
+
+    return relevance
+
+
+relevance = by_relevance()
+"""
+A key function (e.g. to use with `sorted`) which sorts errors by relevance.
+
+Example:
+
+.. code:: python
+
+    sorted(validator.iter_errors(12), key=jsonschema.exceptions.relevance)
+"""
+
+
+def best_match(errors, key=relevance):
+    """
+    Try to find an error that appears to be the best match among given errors.
+
+    In general, errors that are higher up in the instance (i.e. for which
+    `ValidationError.path` is shorter) are considered better matches,
+    since they indicate "more" is wrong with the instance.
+
+    If the resulting match is either :kw:`oneOf` or :kw:`anyOf`, the
+    *opposite* assumption is made -- i.e. the deepest error is picked,
+    since these keywords only need to match once, and any other errors
+    may not be relevant.
+
+    Arguments:
+        errors (collections.abc.Iterable):
+
+            the errors to select from. Do not provide a mixture of
+            errors from different validation attempts (i.e. from
+            different instances or schemas), since it won't produce
+            sensical output.
+
+        key (collections.abc.Callable):
+
+            the key to use when sorting errors. See `relevance` and
+            transitively `by_relevance` for more details (the default is
+            to sort with the defaults of that function). Changing the
+            default is only useful if you want to change the function
+            that rates errors but still want the error context descent
+            done by this function.
+
+    Returns:
+        the best matching error, or ``None`` if the iterable was empty
+
+    .. note::
+
+        This function is a heuristic. Its return value may change for a given
+        set of inputs from version to version if better heuristics are added.
+
+    """
+    errors = iter(errors)
+    best = next(errors, None)
+    if best is None:
+        return
+    best = max(itertools.chain([best], errors), key=key)
+
+    while best.context:
+        # Calculate the minimum via nsmallest, because we don't recurse if
+        # all nested errors have the same relevance (i.e. if min == max == all)
+        smallest = heapq.nsmallest(2, best.context, key=key)
+        if len(smallest) == 2 and key(smallest[0]) == key(smallest[1]):  # noqa: PLR2004
+            return best
+        best = smallest[0]
+    return best

.venv/lib/python3.11/site-packages/jsonschema/protocols.py

@@ -0,0 +1,236 @@
+"""
+typing.Protocol classes for jsonschema interfaces.
+"""
+
+# for reference material on Protocols, see
+#   https://www.python.org/dev/peps/pep-0544/
+
+from __future__ import annotations
+
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    ClassVar,
+    Iterable,
+    Protocol,
+    runtime_checkable,
+)
+
+# in order for Sphinx to resolve references accurately from type annotations,
+# it needs to see names like `jsonschema.TypeChecker`
+# therefore, only import at type-checking time (to avoid circular references),
+# but use `jsonschema` for any types which will otherwise not be resolvable
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+    import referencing.jsonschema
+
+    from jsonschema import _typing
+    from jsonschema.exceptions import ValidationError
+    import jsonschema
+    import jsonschema.validators
+
+# For code authors working on the validator protocol, these are the three
+# use-cases which should be kept in mind:
+#
+# 1. As a protocol class, it can be used in type annotations to describe the
+#    available methods and attributes of a validator
+# 2. It is the source of autodoc for the validator documentation
+# 3. It is runtime_checkable, meaning that it can be used in isinstance()
+#    checks.
+#
+# Since protocols are not base classes, isinstance() checking is limited in
+# its capabilities. See docs on runtime_checkable for detail
+
+
+@runtime_checkable
+class Validator(Protocol):
+    """
+    The protocol to which all validator classes adhere.
+
+    Arguments:
+
+        schema:
+
+            The schema that the validator object will validate with.
+            It is assumed to be valid, and providing
+            an invalid schema can lead to undefined behavior. See
+            `Validator.check_schema` to validate a schema first.
+
+        registry:
+
+            a schema registry that will be used for looking up JSON references
+
+        resolver:
+
+            a resolver that will be used to resolve :kw:`$ref`
+            properties (JSON references). If unprovided, one will be created.
+
+            .. deprecated:: v4.18.0
+
+                `RefResolver <_RefResolver>` has been deprecated in favor of
+                `referencing`, and with it, this argument.
+
+        format_checker:
+
+            if provided, a checker which will be used to assert about
+            :kw:`format` properties present in the schema. If unprovided,
+            *no* format validation is done, and the presence of format
+            within schemas is strictly informational. Certain formats
+            require additional packages to be installed in order to assert
+            against instances. Ensure you've installed `jsonschema` with
+            its `extra (optional) dependencies <index:extras>` when
+            invoking ``pip``.
+
+    .. deprecated:: v4.12.0
+
+        Subclassing validator classes now explicitly warns this is not part of
+        their public API.
+
+    """
+
+    #: An object representing the validator's meta schema (the schema that
+    #: describes valid schemas in the given version).
+    META_SCHEMA: ClassVar[Mapping]
+
+    #: A mapping of validation keywords (`str`\s) to functions that
+    #: validate the keyword with that name. For more information see
+    #: `creating-validators`.
+    VALIDATORS: ClassVar[Mapping]
+
+    #: A `jsonschema.TypeChecker` that will be used when validating
+    #: :kw:`type` keywords in JSON schemas.
+    TYPE_CHECKER: ClassVar[jsonschema.TypeChecker]
+
+    #: A `jsonschema.FormatChecker` that will be used when validating
+    #: :kw:`format` keywords in JSON schemas.
+    FORMAT_CHECKER: ClassVar[jsonschema.FormatChecker]
+
+    #: A function which given a schema returns its ID.
+    ID_OF: _typing.id_of
+
+    #: The schema that will be used to validate instances
+    schema: Mapping | bool
+
+    def __init__(
+        self,
+        schema: Mapping | bool,
+        registry: referencing.jsonschema.SchemaRegistry,
+        format_checker: jsonschema.FormatChecker | None = None,
+    ) -> None:
+        ...
+
+    @classmethod
+    def check_schema(cls, schema: Mapping | bool) -> None:
+        """
+        Validate the given schema against the validator's `META_SCHEMA`.
+
+        Raises:
+
+            `jsonschema.exceptions.SchemaError`:
+
+                if the schema is invalid
+
+        """
+
+    def is_type(self, instance: Any, type: str) -> bool:
+        """
+        Check if the instance is of the given (JSON Schema) type.
+
+        Arguments:
+
+            instance:
+
+                the value to check
+
+            type:
+
+                the name of a known (JSON Schema) type
+
+        Returns:
+
+            whether the instance is of the given type
+
+        Raises:
+
+            `jsonschema.exceptions.UnknownType`:
+
+                if ``type`` is not a known type
+
+        """
+
+    def is_valid(self, instance: Any) -> bool:
+        """
+        Check if the instance is valid under the current `schema`.
+
+        Returns:
+
+            whether the instance is valid or not
+
+        >>> schema = {"maxItems" : 2}
+        >>> Draft202012Validator(schema).is_valid([2, 3, 4])
+        False
+
+        """
+
+    def iter_errors(self, instance: Any) -> Iterable[ValidationError]:
+        r"""
+        Lazily yield each of the validation errors in the given instance.
+
+        >>> schema = {
+        ...     "type" : "array",
+        ...     "items" : {"enum" : [1, 2, 3]},
+        ...     "maxItems" : 2,
+        ... }
+        >>> v = Draft202012Validator(schema)
+        >>> for error in sorted(v.iter_errors([2, 3, 4]), key=str):
+        ...     print(error.message)
+        4 is not one of [1, 2, 3]
+        [2, 3, 4] is too long
+
+        .. deprecated:: v4.0.0
+
+            Calling this function with a second schema argument is deprecated.
+            Use `Validator.evolve` instead.
+        """
+
+    def validate(self, instance: Any) -> None:
+        """
+        Check if the instance is valid under the current `schema`.
+
+        Raises:
+
+            `jsonschema.exceptions.ValidationError`:
+
+                if the instance is invalid
+
+        >>> schema = {"maxItems" : 2}
+        >>> Draft202012Validator(schema).validate([2, 3, 4])
+        Traceback (most recent call last):
+            ...
+        ValidationError: [2, 3, 4] is too long
+
+        """
+
+    def evolve(self, **kwargs) -> Validator:
+        """
+        Create a new validator like this one, but with given changes.
+
+        Preserves all other attributes, so can be used to e.g. create a
+        validator with a different schema but with the same :kw:`$ref`
+        resolution behavior.
+
+        >>> validator = Draft202012Validator({})
+        >>> validator.evolve(schema={"type": "number"})
+        Draft202012Validator(schema={'type': 'number'}, format_checker=None)
+
+        The returned object satisfies the validator protocol, but may not
+        be of the same concrete class! In particular this occurs
+        when a :kw:`$ref` occurs to a schema with a different
+        :kw:`$schema` than this one (i.e. for a different draft).
+
+        >>> validator.evolve(
+        ...     schema={"$schema": Draft7Validator.META_SCHEMA["$id"]}
+        ... )
+        Draft7Validator(schema=..., format_checker=None)
+        """