def validate(value, **kwds):
  """ Validate a python value against json schema:
  validate(value, schemaPath)
  validate(value, schemaDict)

  value:          python object to validate against the schema

  The json schema may be specified either as a path of the file containing
  the json schema or as a python dictionary using one of the
  following keywords as arguments:
    schemaPath:     Path of file containing the json schema object.
    schemaDict:     Python dictionary containing the json schema object

  Returns: nothing

  Raises:
          ValidationError when value fails json validation
  """

  assert len(kwds.keys()) >= 1
  assert 'schemaPath' in kwds or 'schemaDict' in kwds

  schemaDict = None
  if 'schemaPath' in kwds:
    schemaPath = kwds.pop('schemaPath')
    schemaDict = loadJsonValueFromFile(schemaPath)
  elif 'schemaDict' in kwds:
    schemaDict = kwds.pop('schemaDict')

  try:
    validictory.validate(value, schemaDict, **kwds)
  except validictory.ValidationError as e:
    raise ValidationError(e)

    def test_patternproperties_nonmatch(self):
        data = { 'a': True, 'd': 'foo' }

        try:
            validictory.validate(data, self.schema)
        except ValueError as e:
            self.fail("Unexpected failure: %s" % e)

    def test_format_utcmillisec_pass(self):
        data = 1294915735

        try:
            validictory.validate(data, self.schema_utcmillisec)
        except ValueError as e:
            self.fail("Unexpected failure: %s" % e)

    def test_additionalItems_false_no_additional_items_pass(self):
        data = [12482, "Yes, more strings", False]

        try:
            validictory.validate(data, self.schema1)
        except ValueError, e:
            self.fail("Unexpected failure: %s" % e)

    def test_pattern_pass_nonstring(self):
        data = 123

        try:
            validictory.validate(data, self.schema)
        except ValueError as e:
            self.fail("Unexpected failure: %s" % e)

    def test_format_date_pass(self):
        data = "2011-01-13"

        try:
            validictory.validate(data, self.schema_date)
        except ValueError as e:
            self.fail("Unexpected failure: %s" % e)

def validate(json_object, orderly_object):
    """Validates the JSON object with an Orderly definition"""
    if type(orderly_object) in (str, unicode):
        orderly_object = parse(orderly_object)
    if type(json_object) in (str, unicode):
        json_object = json.loads(json_object)
    validictory.validate(json_object, orderly_object)

def step_args_validator(node, value):
    if value:
        try:
            validictory.validate(value.split(), _STEP_ARGS_VALIDICTORY_SCHEMA)
        except Exception as err:
            raise colander.Invalid(node, _(u'Got Error: ${err}',
                                   mapping=dict(err=err)))

 def validate(self, value, model_instance):
     super(JSONField, self).validate(value, model_instance)
     if self.schema:
         try:
             validictory.validate(value, self.schema)
         except ValueError as e:
             raise self.ValidationError(e)

def validate(dictionary, schema_id):
    """
        Validate a dictionary using a schema.

        !! DEPRECATED !! Always return True. It just log call stack to var/log/schema.log

        :param dictionary: Dictionary to validate.
        :type dictionary: dict

        :param schema_id: Schema identifier (value of _id field in Mongo document).
        :type schema_id: str

        :returns: True if the validation succeed, False otherwise.
        WARNING: disabled, always returns True.
    """
    call_stack = ''.join(traceback.format_stack())
    schema_logger.critical(
        'call to canopsis.schema.__init__.validate: {}\n'.format(call_stack))

    # FIXIT: Look at the code under this one: we just avoid useless computation
    # while we completely remove calls to this function.
    return True

    schema = get(schema_id)

    try:
        validictory.validate(dictionary, schema, required_by_default=False)
        return True

    except validictory.ValidationError:
        return True

    def test_format_datetime_with_microseconds_pass(self):
        data = "2011-01-13T10:56:53.0438Z"

        try:
            validictory.validate(data, self.schema_datetime)
        except ValueError as e:
            self.fail("Unexpected failure: %s" % e)

        def validate_wrap(*args, **kwargs):
            '''
            :param args: function to accept an arbitrary number of arguments.
            :param kwargs: function to accept an arbitrary number of keyword arguments.
            '''
            params = {}
            request = None
            for arg in args:
                if type(arg) == pyramid.request.Request or type(arg) == pyramid.testing.DummyRequest:
                    try:
                        request = arg
                        params = Validator.fix_types_for_schema(schema.get('properties'), arg.GET, True)
                        if getattr(arg, 'method', 'GET') == 'POST' and len(arg.json_body) > 0:  # parse request params in POST
                            params.update(arg.json_body)
                    except ValueError:
                        raise EdApiHTTPPreconditionFailed('Payload cannot be parsed')
                    except Exception as e:
                        raise EdApiHTTPPreconditionFailed('Payload cannot be parsed')
            # validate params against schema

            try:
                validictory.validate(params, schema)

                def validated(request):
                    '''
                    Return validated parameters for this request
                    '''
                    return params
                request.set_property(validated, 'validated_params', reify=True)
            except Exception as e:
                raise EdApiHTTPPreconditionFailed(e)
            return request_handler(*args, **kwargs)

def validate_geojson(test_geojson):
    geojson_types = {
        'Point': point,
        'MultiPoint': multipoint,
        'LineString': linestring,
        'MultiLineString': multilinestring,
        'Polygon': polygon,
        'MultiPolygon': multipolygon,
        'GeometryCollection': geometrycollection,
        'Feature': feature,
        'FeatureCollection': featurecollection,
    }

    if not test_geojson['type'] in geojson_types:
        raise GeoJSONValidationException('"%s" is not a valid GeoJSON type.' % test_geojson['type'])

    if test_geojson['type'] in ('Feature', 'FeatureCollection', 'GeometryCollection'):
        #
        # These are special cases that every JSON schema library
        # I've tried doesn't seem to handle properly.
        #
        _validate_special_case(test_geojson)
    else:
        try:
            validictory.validate(test_geojson, geojson_types[test_geojson['type']])
        except validictory.validator.ValidationError as error:
            raise GeoJSONValidationException(str(error))

    if test_geojson['type'] == 'Polygon':
        # First and last coordinates must be coincident
        _validate_polygon(test_geojson)

    return

    def test_uniqueitems_false_pass(self):
        data = [1, 1, 1]

        try:
            validictory.validate(data, self.schema_false)
        except ValueError as e:
            self.fail("Unexpected failure: %s" % e)

def WebSection_setObject(self, id, ob, **kw):
  """
    Make any change related to the file uploaded.
  """
  portal = self.getPortalObject()
  data = self.REQUEST.get('BODY')
  schema = self.WebSite_getJSONSchema()
  structure = json.loads(data)
  # 0 elementh in structure is json in json
  # 1 elementh is just signature
  structure = [json.loads(structure[0]), structure[1]]

  validictory.validate(structure, schema)

  file_name = structure[0].get('file', None)
  expiration_date = structure[0].get('expiration_date', None)

  data_set = portal.portal_catalog.getResultValue(portal_type='Data Set',
                                                  reference=id)
  if data_set is None:
    data_set = portal.data_set_module.newContent(portal_type='Data Set',
                                                 reference=id)
    data_set.publish()


  reference = hashlib.sha512(data).hexdigest()
  ob.setFilename(file_name)
  ob.setFollowUp(data_set.getRelativeUrl())
  ob.setContentType('application/json')
  ob.setReference(reference)
  if expiration_date is not None:
    ob.setExpirationDate(expiration_date)
  ob.publish()
  return ob

    def test_pattern_pass(self):
        data = "[email protected]"

        try:
            validictory.validate(data, self.schema)
        except ValueError as e:
            self.fail("Unexpected failure: %s" % e)

def update_schedule(username, sid, mongodb):
    '''
    Input: json schedule document with updates
    Output: Status 204 No Content, and Location with the schedule id

    Checks for valid user session. If the session checks out, the schedule
    is updated with the new values in the request. If the session is not valid,
    status 401 Unauthorized is returned.
    '''
    # Check session cookie. Returns username if matched; otherwise, None.
    session_user = request.get_cookie('session', secret=secret_key)
    if session_user:    # Do your thing, man.
        user = mongodb.users.find_one({'username': username}, {'_id': 1})
        if user:
            if session_user in [username, 'admin']:
                try:
                    # Validate json data from request.
                    validictory.validate(request.json, schedule_schema)
                    # Update schedule
                    if 'courses' not in request.json.keys():
                        # Clears all courses from schedule document if courses is
                        # not in the json object in the request.
                        request.json['courses'] = []
                    mongodb.schedules.update({'_id': ObjectId(sid)}, {'$set': request.json})
                except ValueError, error:
                    # Return 400 status and error from validation.
                    return HTTPResponse(status=400, output=error)

                response.status = 204
                response.headers['location'] = '/api/users/%s/schedules/%s' % (username, sid)
                return
            else:
                return HTTPResponse(status=401, output="You do not have permission.")
        else:
            return HTTPResponse(status=401, output="Not a valid user.")

 def test_blank_true(self):
     try:
         validictory.validate("", {"blank": True}, blank_by_default=False)
         validictory.validate("test", {"blank": True},
                              blank_by_default=False)
     except ValueError as e:
         self.fail("Unexpected failure: %s" % e)

    def testComposeModelCommandResultForDeleteFail(self, repoMock, *_args):
        """ Make sure we can compose a model command result message for publishing
    a failed "deleteModel" on the AMQP exchange
    """
        repoMock.getMetric.side_effect = Exception("getMetric should not have been called here")

        service = anomaly_service.AnomalyService()

        modelID = "123456abcdef"
        result = anomaly_service.ModelCommandResult(
            commandID="123", method="deleteModel", status=1, errorMessage="bad, bad, bad"
        )

        msg = service._composeModelCommandResultMessage(modelID=modelID, cmdResult=result)

        # Validate the message against its JSON schema
        schemaStream = pkg_resources.resource_stream(
            "htmengine.runtime.json_schema", "model_command_result_amqp_message.json"
        )
        jsonSchema = json.load(schemaStream)

        validictory.validate(msg, jsonSchema)

        self.assertEqual(msg.pop("method"), result.method)
        self.assertEqual(msg.pop("modelId"), modelID)
        self.assertEqual(msg.pop("commandId"), result.commandID)
        self.assertEqual(msg.pop("status"), result.status)
        self.assertEqual(msg.pop("errorMessage"), result.errorMessage)

        self.assertFalse(msg)

    def test_format_time_pass(self):
        data = "10:56:53"

        try:
            validictory.validate(data, self.schema_time)
        except ValueError as e:
            self.fail("Unexpected failure: %s" % e)