code: def validate(instance, schema, cls=None, *args, **kwargs):
      """
      Validate an instance under the given schema.
  
          >>> validate([2, 3, 4], {"maxItems": 2})
          Traceback (most recent call last):
              ...
          ValidationError: [2, 3, 4] is too long
  
      :func:`validate` will first verify that the provided schema is
      itself valid, since not doing so can lead to less obvious error
      messages and fail in less obvious or consistent ways.
  
      If you know you have a valid schema already, especially if you
      intend to validate multiple instances with the same schema, you
      likely would prefer using the `IValidator.validate` method directly
      on a specific validator (e.g. ``Draft7Validator.validate``).
  
  
      Arguments:
  
          instance:
  
              The instance to validate
  
          schema:
  
              The schema to validate with
  
          cls (IValidator):
  
              The class that will be used to validate the instance.
  
      If the ``cls`` argument is not provided, two things will happen
      in accordance with the specification. First, if the schema has a
      :validator:`$schema` property containing a known meta-schema [#]_
      then the proper validator will be used. The specification recommends
      that all schemas contain :validator:`$schema` properties for this
      reason. If no :validator:`$schema` property is found, the default
      validator class is the latest released draft.
  
      Any other provided positional and keyword arguments will be passed
      on when instantiating the ``cls``.
  
      Raises:
  
          `jsonschema.exceptions.ValidationError` if the instance
              is invalid
  
          `jsonschema.exceptions.SchemaError` if the schema itself
              is invalid
  
      .. rubric:: Footnotes
      .. [#] known by a validator registered with
          `jsonschema.validators.validates`
      """
      if cls is None:
          cls = validator_for(schema)
  
      cls.check_schema(schema)
      validator = cls(schema, *args, **kwargs)
      error = exceptions.best_match(validator.iter_errors(instance))
      if error is not None:
          raise error
  
imports: from __future__ import division
  from warnings import warn
  import contextlib
  import json
  import numbers
  from six import add_metaclass
  from jsonschema import _legacy_validators, _types, _utils, _validators, exceptions
  from jsonschema.compat import Sequence, int_types, iteritems, lru_cache, str_types, unquote, urldefrag, urljoin, urlopen, urlsplit
  from jsonschema.exceptions import ErrorTree
label_desc: Use image node_id 7 for calling a global function with example usage: validate(instance, schema, cls) without return types