"""Represents a dict with a particular key order for yaml representing."""

def __init__(self, keys, data):

super(SortedDict, self).__init__()

self.keys = keys

self.update(data)

def ordered_items(self):

result = []

for key in self.keys:

if self.get(key) is not None:

result.append((key, self.get(key)))

"""For dumping `validation.Items`. Respects `SortedDict` key ordering."""

def represent_mapping(self, tag, mapping, flow_style=None):

if hasattr(mapping, 'ordered_items'):

return super(ItemDumper, self).represent_mapping(

tag, mapping.ordered_items(), flow_style=flow_style)

return super(ItemDumper, self).represent_mapping(

"""Base class for raising exceptions during validation."""

def __init__(self, message, cause=None):

"""Initialize exception."""

if hasattr(cause, 'args') and cause.args:

Error.__init__(self, message, *cause.args)

else:

Error.__init__(self, message)

self.message = message

self.cause = cause

def __str__(self):

"""Raised when a required attribute is missing from object."""

def __init__(self, key):

msg = 'Missing required value [{}].'.format(key)

"""Wrap various types as instances of a validator.

if (_IsPy2Basestring(validator)

or validator == six.string_types):

return StringValidator()

if isinstance(validator, (str, six.text_type)):

return Regex(validator, type(validator))

if isinstance(validator, type):

return Type(validator)

if isinstance(validator, (list, tuple, set)):

return Options(*tuple(validator))

if isinstance(validator, Validator):

return validator

else:

raise AttributeDefinitionError('%s is not a valid validator' %

"""Convert any value to simplified collections and basic types.

if isinstance(value, ValidatedBase):

return value.ToDict()

elif isinstance(value, (list, tuple)):

return [_SimplifiedValue(validator, item) for item in value]

elif isinstance(validator, Validator):

return validator.ToValue(value)

"""Base class for all validated objects."""

@classmethod

def GetValidator(cls, key):

"""Safely get the Validator corresponding to the given key.

raise NotImplementedError('Subclasses of ValidatedBase must '

'override GetValidator.')

def SetMultiple(self, attributes):

"""Set multiple values on Validated instance.

for key, value in attributes.items():

self.Set(key, value)

def Set(self, key, value):

"""Set a single value on Validated instance.

raise NotImplementedError('Subclasses of ValidatedBase must override Set.')

def CheckInitialized(self):

"""Checks for missing or conflicting attributes.

def ToDict(self):

"""Convert `ValidatedBase` object to a dictionary.

raise NotImplementedError('Subclasses of ValidatedBase must '

'override ToDict.')

def ToYAML(self):

"""Print validated object as simplified YAML.

return yaml.dump(self.ToDict(),

default_flow_style=False,

Dumper=ItemDumper)

def GetWarnings(self):

"""Return all the warnings we've got, along with their associated fields.

raise NotImplementedError('Subclasses of ValidatedBase must '

"""Base class for classes that require validation.

ATTRIBUTES = None

def __init__(self, **attributes):

"""Constructor for Validated classes.

super(Validated, self).__init__()

if not isinstance(self.ATTRIBUTES, dict):

raise AttributeDefinitionError(

'The class %s does not define an ATTRIBUTE variable.'

% self.__class__)

for key in self.ATTRIBUTES.keys():

object.__setattr__(self, key, self.GetValidator(key).default)

self.SetMultiple(attributes)

@classmethod

def GetValidator(cls, key):

"""Safely get the underlying attribute definition as a `Validator`.

if key not in cls.ATTRIBUTES:

raise ValidationError(

'Unexpected attribute \'%s\' for object of type %s.' %

(key, cls.__name__))

return AsValidator(cls.ATTRIBUTES[key])

def GetWarnings(self):

ret = []

for key in self.ATTRIBUTES.keys():

ret.extend(self.GetValidator(key).GetWarnings(

self.GetUnnormalized(key), key, self))

return ret

def Set(self, key, value):

"""Set a single value on `Validated` instance.

setattr(self, key, value)

def GetUnnormalized(self, key):

"""Get a single value on the `Validated` instance, without normalizing."""

validator = self.GetValidator(key)

try:

return super(Validated, self).__getattribute__(key)

except AttributeError:

return validator.default

def Get(self, key):

"""Get a single value on Validated instance.

self.GetValidator(key)

return getattr(self, key)

def __getattribute__(self, key):

ret = super(Validated, self).__getattribute__(key)

if key in ['ATTRIBUTES', 'GetValidator', '__name__', '__class__']:

return ret

try:

validator = self.GetValidator(key)

except ValidationError:

return ret

if isinstance(validator, Normalized):

return validator.Get(ret, key, self)

return ret

def CheckInitialized(self):

for key in self.ATTRIBUTES.keys():

value = self.GetUnnormalized(key)

self.GetValidator(key).CheckFieldInitialized(value, key, self)

def __setattr__(self, key, value):

"""Set attribute.

if value is not None:

value = self.GetValidator(key)(value, key)

object.__setattr__(self, key, value)

def __str__(self):

"""Formatted view of validated object and nested values."""

return repr(self)

def __repr__(self):

"""Formatted view of validated object and nested values."""

values = [(attr, getattr(self, attr)) for attr in self.ATTRIBUTES.keys()]

dent = ' '

value_list = []

for attr, value in values:

value_list.append('\n%s%s=%s' % (dent, attr, value))

return "<%s %s\n%s>" % (self.__class__.__name__, ' '.join(value_list), dent)

def __eq__(self, other):

"""Equality operator.

if type(self) != type(other):

return False

for key in self.ATTRIBUTES.keys():

if getattr(self, key) != getattr(other, key):

return False

return True

def __ne__(self, other):

"""Inequality operator."""

return not self.__eq__(other)

def __hash__(self):

"""Hash function for using Validated objects in sets and maps.

result = 0

for key in self.ATTRIBUTES.keys():

value = getattr(self, key)

if isinstance(value, list):

value = tuple(value)

result = result ^ hash(key) ^ hash(value)

return result

def ToDict(self):

"""Convert Validated object to a dictionary.

result = {}

for name, validator in self.ATTRIBUTES.items():

value = self.GetUnnormalized(name)

if not(isinstance(validator, Validator) and value == validator.default):

result[name] = _SimplifiedValue(validator, value)

"""Base class for validated dictionaries.

KEY_VALIDATOR = None

VALUE_VALIDATOR = None

def __init__(self, **kwds):

"""Construct a validated dict by interpreting the key and value validators.

super(ValidatedDict, self).__init__()

self.update(kwds)

@classmethod

def GetValidator(cls, key):

"""Check the key for validity and return a corresponding value validator.

key = AsValidator(cls.KEY_VALIDATOR)(key, 'key in %s' % cls.__name__)

return AsValidator(cls.VALUE_VALIDATOR)

def __setitem__(self, key, value):

"""Set an item.

dict.__setitem__(self, key, self.GetValidator(key)(value, key))

def setdefault(self, key, value=None):

"""Trap setdefaultss to ensure all key/value pairs are valid.

return dict.setdefault(self, key, self.GetValidator(key)(value, key))

def update(self, other, **kwds):

"""Trap updates to ensure all key/value pairs are valid.

if hasattr(other, 'keys') and callable(getattr(other, 'keys')):

newother = {}

for k in other:

newother[k] = self.GetValidator(k)(other[k], k)

else:

newother = [(k, self.GetValidator(k)(v, k)) for (k, v) in other]

newkwds = {}

for k in kwds:

newkwds[k] = self.GetValidator(k)(kwds[k], k)

dict.update(self, newother, **newkwds)

def Set(self, key, value):

"""Set a single value on `Validated` instance.

self[key] = value

def GetWarnings(self):

ret = []

for name, value in self.items():

ret.extend(self.GetValidator(name).GetWarnings(value, name, self))

return ret

def ToDict(self):

"""Convert `ValidatedBase` object to a dictionary.

result = {}

for name, value in self.items():

validator = self.GetValidator(name)

result[name] = _SimplifiedValue(validator, value)

"""Validator base class.

expected_type = object

def __init__(self, default=None):

"""Constructor.

self.default = default

def __call__(self, value, key='???'):

"""Main interface to validator is call mechanism."""

return self.Validate(value, key)

def Validate(self, value, key='???'):

"""Validate this field. Override to customize subclass behavior.

return value

def CheckFieldInitialized(self, value, key, obj):

"""Check for missing fields or conflicts between fields.

if value is None:

raise MissingAttribute(key)

def ToValue(self, value):

"""Convert `value` to a simplified collection or basic type.

return value

def GetWarnings(self, value, key, obj):

"""Return any warnings on this attribute.

del value, key, obj

"""Verifies property is a valid text string.

def Validate(self, value, key='???'):

if not isinstance(value, six.string_types):

raise ValidationError(

'Value %r for %s is not a valid text string.' % (

value, key))

"""Verifies property is of expected type.

def __init__(self, expected_type, convert=True, default=None):

"""Initialize Type validator.

super(Type, self).__init__(default)

self.expected_type = expected_type

self.convert = convert

def Validate(self, value, key):

"""Validate that `value` has the correct type.

if isinstance(value, self.expected_type):

return value

if self.expected_type is str and isinstance(value, six.string_types):

return value

if not self.convert:

raise ValidationError('Value %r for %s is not of the expected type %s' %

(value, key, self.expected_type.__name__))

try:

return self.expected_type(value)

except ValueError as e:

raise ValidationError(

'Value %r for %s could not be converted to type %s.' %

(value, key, self.expected_type.__name__), e)

except TypeError as e:

raise ValidationError(

'Value %r for %s is not of the expected type %s' %

(value, key, self.expected_type.__name__), e)

def GetWarnings(self, value, key, obj):

del obj

if issubclass(self.expected_type, ValidatedBase):

return [('%s.%s' % (key, subkey), warning)

for subkey, warning in value.GetWarnings()]

"""Coerces the value to accommodate Docker `CMD/ENTRYPOINT` requirements.

def __init__(self, default=None):

"""Initialize parent, a converting type validator for `str`."""

super(Exec, self).__init__(str, convert=True, default=default)

def Validate(self, value, key):

"""Validate according to parent behavior and coerce to start with `exec`."""

value = super(Exec, self).Validate(value, key)

if value.startswith('[') or value.startswith('exec'):

return value

else:

"""Limit field based on pre-determined values.

def __init__(self, *options, **kw):

"""Initialize options.

if 'default' in kw:

default = kw['default']

else:

default = None

alias_map = {}

def AddAlias(alias, original):

"""Set new alias on `alias_map`.

if not isinstance(alias, str):

raise AttributeDefinitionError(

'All option values must be of type str.')

elif alias in alias_map:

raise AttributeDefinitionError(

"Option '%s' already defined for options property." % alias)

alias_map[alias] = original

for option in options:

if isinstance(option, str):

AddAlias(option, option)

elif isinstance(option, (list, tuple)):

if len(option) != 2:

raise AttributeDefinitionError("Alias is defined as a list or tuple "

"with two items. The first is the "

"original option, while the second "

"is a list or tuple of str aliases.\n"

"\n Example:\n"

" ('original', ('alias1', "

"'alias2'")

original, aliases = option

AddAlias(original, original)

if not isinstance(aliases, (list, tuple)):

raise AttributeDefinitionError('Alias lists must be a list or tuple')

for alias in aliases:

AddAlias(alias, original)

else:

raise AttributeDefinitionError("All options must be of type str "

"or of the form (str, [str...]).")

super(Options, self).__init__(default)

self.options = alias_map

def Validate(self, value, key):

"""Validate options.

value = str(value)

if value not in self.options:

raise ValidationError('Value \'%s\' for %s not in %s.'

% (value, key, self.options))

"""Definition of optional attributes.

def __init__(self, validator, default=None):

"""Initializer.