CODEWITHSUNDEEP
pythonpython-3.xvalidationcerberus
crunk1
crunk1

Reputation: 2818

Python Cerberus how to check dynamic root keys

I have a dict with IDs as its root keys that I want to validate. In other words, the root keys of the dict I want to validate are dynamic. Is there a way to run keyschema against the root keys?

e.g. https://repl.it/@crunk1/cerberusrootkeys

import cerberus

v = cerberus.validator.Validator()
schema = {'keyschema': {'type': 'string'}}
d = {'foo': 'bar', 'baz': 'gaz'}

print('I want this to be true.')
print(v.validate(d, schema))

### Output:
# I want this to be true.
# False

I know I could do the following:

wrapper = {'nested': d}
schema = {'nested': {'keyschema': {'type': 'string'}}}
v.validate(wrapper, schema)

but the current structure of my project doesn't easily allow for that.

Any solutions/tips/suggestions?

Upvotes: 1

Views: 1025

Answers (1)

crunk1
crunk1

Reputation: 2818

I managed to hack something together (https://repl.it/@crunk1/Cerberus-root-types) subclassing Validator and overriding validate():

class V(cerberus.Validator):
  def validate(self, document, schema=None, update=False, normalize=True):
    doc = None
    wrapped = False
    if schema is not None:
      root_schema = schema.get('__root__', None)
      wrapped = root_schema is not None
      if wrapped:
        doc = {'__root__': document}
        schema = {'__root__': root_schema}
    elif self.schema is not None:
        root_schema = self.schema.get('__root__', None)
        wrapped = root_schema is not None
        if wrapped:
            doc = {'__root__': document}
            schema = {'__root__': root_schema}

    doc = doc or document
    result = super(V, self).validate(doc, schema, update, normalize)
    if wrapped:
      # Unwrap.
      self.document = self.document['__root__']
      for e in self._errors:
        e.schema_path = tuple(e.schema_path[1:])
        if len(e.document_path) > 1:
          e.document_path = tuple(e.document_path[1:])
    return result

This allows you to treat the root document as a 'type': 'dict' or 'type': 'list'.

v = V()
d = {'1': '1', '2': '2'}
schema = {'__root__': {
  'type': 'dict',
  'keyschema': {'coerce': int},
  'valueschema': {'coerce': int},
}}
print(v.validate(d, schema), v.document, v.errors)

l = ['1', '2']
schema = {'__root__': {
  'type': 'list',
  'schema': {'coerce': int},
}}
print(v.validate(l, schema), v.document, v.errors)

l = ['1', 'b']
print(v.validate(l, schema), v.document, v.errors)

Output:

True {1: 1, 2: 2} {}
True [1, 2] {}
False [1, 'b'] {1: ["field '1' cannot be coerced: invalid literal for int() with base 10: 'b'"]}

Upvotes: 1

Related Questions