import sys
import logging
import yaml
from voluptuous import Schema, MultipleInvalid, Invalid
from voluptuous import Required, All, Range, Length
_schema = Schema({
Required('username', default='root'): All(str, Length(min=1)),
Required('password', default='password'): All(str, Length(min=1)),
Required('port'): All(int, Range(min=1, max=65535)),
Required('motd', default='Hi'): str,
Required('simple_commands'): dict,
Required('pem_key'): str,
Required('pub_key'): str
})
def _get_config():
with open('./config/config.yml') as config_file:
text = config_file.read()
config = yaml.load(text)
try:
_schema(config)
except (MultipleInvalid, Invalid) as e:
logging.error('Invalid config.yml')
logging.error(str(e))
sys.exit(1)
return config
def skip_repo_fs_check():
return {
Optional('skip_repo_fs_check', default=False):
Any(bool, All(Any(*string_types), Boolean()))
}
def delay():
return {
Optional('delay', default=0):
All(Coerce(float), Range(min=0.0, max=3600.0))
}
def continue_if_exception():
return {
Optional('continue_if_exception', default=False):
Any(bool, All(Any(*string_types), Boolean()))
}
def retry_interval():
return {
Optional('retry_interval', default=120):
All(Coerce(int), Range(min=1, max=600))
}
def partial():
return {
Optional('partial', default=False):
Any(bool, All(Any(*string_types), Boolean()))
}
def refresh():
return {
Optional('refresh', default=True):
Any(bool, All(Any(*string_types), Boolean()))
}
'NETWORK_FAILURE': NetworkFailure,
'SERVICE_FAILURE': ServiceFailure,
'FIREWALL_TIMEOUT': FirewallTimeout,
'DELAY': Delay,
'PACKET_LOSS': PacketLoss
}
def alphabetical_keys(a_dict):
keys = a_dict.keys()
keys.sort()
return keys
BASE_SCHEMA = {
Required('name'): All(string, Length(min=1)),
Required('type'): All(string, OneOf(alphabetical_keys(FAULT_TYPES))),
Required('direction'): All(string, OneOf(alphabetical_keys(DIRECTIONS))),
Required('to_port'): All(int),
Optional('from'): All(string),
Optional('to'): All(string),
Optional('protocol'): All(string)
}
def build_add_fault_command(shell, params):
if not params.has_key('type') or params['type'] not in FAULT_TYPES.keys():
message = 'must be present and one of ' + str(
alphabetical_keys(FAULT_TYPES))
exception = MultipleInvalid()
exception.add(Invalid(message, ['type'], message))
def extra_schema(self):
return {Required('timeout'): All(int)}
# -*- coding: utf-8 -*-
from pagseguro.validators import Email, PhoneArea, PhoneNumber, BrState
from voluptuous import Schema, Required, All, Length, Range, Optional, Match, \
Any
item_schema = Schema({
Required('item_id'):
All(unicode, Length(min=1, max=100)),
Required('description'):
All(unicode, Length(min=1, max=100)),
Required('amount'):
All(float, Range(min=0.01, max=9999999)),
Required('quantity'):
All(int, Range(min=1, max=999)),
Optional('weight'):
All(int, Range(max=30000)),
})
#: .. todo:: Validar born_date e CPF
client_schema = Schema({
'name':
unicode,
'email':
All(Email(), Length(max=60)),
'phone_area_code':
All(PhoneArea(), Length(min=2, max=2)),
'phone_number':
All(PhoneNumber(), Length(min=7, max=9)),
'cpf':
All(
Match('[\d]{11}',
return None
if isinstance(types, str):
types = [typ.strip() for typ in types.split(",")]
unsupported = set(types) - {"reflink", "hardlink", "symlink", "copy"}
if unsupported:
raise Invalid("Unsupported cache type(s): {}".format(
", ".join(unsupported)))
return types
# Checks that value is either true or false and converts it to bool
to_bool = Bool = All(
Lower,
Any("true", "false"),
lambda v: v == "true",
msg="expected true or false",
)
def Choices(*choices):
"""Checks that value belongs to the specified set of values
Args:
*choices: pass allowed values as arguments, or pass a list or
tuple as a single argument
"""
return Any(*choices, msg="expected one of {}".format(", ".join(choices)))
def ByUrl(mapping):
def difficulty_validator(value):
"""
Check if value is a valid difficulty.
"""
try:
return Difficulty(value)
except ValueError:
expected_values = tuple(member.value for member in Difficulty)
raise Invalid("Value should be one of: {}".format(expected_values))
CREATE_TEAM_MEMBER_VALIDATOR = Schema({
Required("name"):
str,
Required("level", default=1):
All(int, Range(min=1)),
Required("theme", default=""):
str,
Required("level_max", default=None):
Any(None, All(int, Range(min=1))),
Required("difficulty", default=Difficulty.EASY):
difficulty_validator,
})
class TeamMember(ModelMixin):
"""
A TeamMember is a player, each Game has one or multiple TeamMember.
A TeamMember cannot play multiple games.
"""
def _device_commands_schema():
return Schema({
All(str): Any(list, dict, str),
Optional('connections'): _device_connections_commands(),
Optional('users'): _device_user_commands()
})
"singer": str,
"album": str,
"state": In(["normal", "banned"])
})
create_election = Schema(
{
"name": str,
"state": In(["ongoing", "finished"]),
"type": In(["topic", "song"])
},
required=True)
get_elections = Schema({
"offset":
All(int, Range(min=0)),
Required("limit"):
All(int, Range(min=1, max=100)),
Required("type", default="any"):
In(["topic", "song", "any"])
})
add_option = Schema({
Required("electionUid"): str,
Required("name"): str,
Required("type"): In(["topic", "song"]),
"singer": str,
"cutCommentary": str,
"album": str,
"serviceLink": str
})
def number_of_replicas():
return {
Optional('number_of_replicas', default=1):
All(Coerce(int), Range(min=0, max=10))
}
def extra_schema(self):
return {
Optional('probability'): All(float),
Optional('correlation'): All(int)
}
def number_of_shards():
return {
Optional('number_of_shards', default=1):
All(Coerce(int), Range(min=1, max=99))
}
def argument_spec_schema(for_collection):
any_string_types = Any(*string_types)
schema = {
any_string_types: {
'type':
Any(is_callable, *argument_spec_types),
'elements':
Any(*argument_spec_types),
'default':
object,
'fallback':
Any(
(is_callable, list_string_types),
[is_callable, list_string_types],
),
'choices':
Any([object], (object, )),
'required':
bool,
'no_log':
bool,
'aliases':
Any(list_string_types, tuple(list_string_types)),
'apply_defaults':
bool,
'removed_in_version':
version(for_collection),
'removed_at_date':
date(),
'removed_from_collection':
collection_name,
'options':
Self,
'deprecated_aliases':
Any([
All(
Any(
{
Required('name'): Any(*string_types),
Required('date'): date(),
Required('collection_name'): collection_name,
},
{
Required('name'): Any(*string_types),
Required('version'): version(for_collection),
Required('collection_name'): collection_name,
},
),
partial(check_removal_version,
version_field='version',
collection_name_field='collection_name',
error_code='invalid-removal-version'))
]),
}
}
schema[any_string_types].update(argument_spec_modifiers)
schemas = All(
schema,
Schema({any_string_types: no_required_with_default}),
Schema({any_string_types: elements_with_list}),
Schema({any_string_types: options_with_apply_defaults}),
Schema({any_string_types: option_deprecation}),
)
return Schema(schemas)
def preserve_existing():
return {
Optional('preserve_existing', default=False):
Any(bool, All(Any(*string_types), Boolean()))
}
def list_dict_option_schema(for_collection):
suboption_schema = Schema(
{
Required('description'):
Any(list_string_types, *string_types),
'required':
bool,
'choices':
list,
'aliases':
Any(list_string_types),
'version_added':
version(for_collection),
'version_added_collection':
collection_name,
'default':
json_value,
# Note: Types are strings, not literal bools, such as True or False
'type':
Any(None, 'bits', 'bool', 'bytes', 'dict', 'float', 'int', 'json',
'jsonarg', 'list', 'path', 'raw', 'sid', 'str'),
# in case of type='list' elements define type of individual item in list
'elements':
Any(None, 'bits', 'bool', 'bytes', 'dict', 'float', 'int', 'json',
'jsonarg', 'list', 'path', 'raw', 'sid', 'str'),
# Recursive suboptions
'suboptions':
Any(None, *list({str_type: Self} for str_type in string_types)),
},
extra=PREVENT_EXTRA)
# This generates list of dicts with keys from string_types and suboption_schema value
# for example in Python 3: {str: suboption_schema}
list_dict_suboption_schema = [{
str_type: suboption_schema
} for str_type in string_types]
option_schema = Schema(
{
Required('description'):
Any(list_string_types, *string_types),
'required':
bool,
'choices':
list,
'aliases':
Any(list_string_types),
'version_added':
version(for_collection),
'version_added_collection':
collection_name,
'default':
json_value,
'suboptions':
Any(None, *list_dict_suboption_schema),
# Note: Types are strings, not literal bools, such as True or False
'type':
Any(None, 'bits', 'bool', 'bytes', 'dict', 'float', 'int', 'json',
'jsonarg', 'list', 'path', 'raw', 'sid', 'str'),
# in case of type='list' elements define type of individual item in list
'elements':
Any(None, 'bits', 'bool', 'bytes', 'dict', 'float', 'int', 'json',
'jsonarg', 'list', 'path', 'raw', 'sid', 'str'),
},
extra=PREVENT_EXTRA)
option_version_added = Schema(All(
{
'suboptions':
Any(None, *[{
str_type: Self
} for str_type in string_types]),
}, partial(version_added, error_code='option-invalid-version-added')),
extra=ALLOW_EXTRA)
# This generates list of dicts with keys from string_types and option_schema value
# for example in Python 3: {str: option_schema}
return [{
str_type: All(option_schema, option_version_added)
} for str_type in string_types]
def remote_ssl_no_validate():
return {
Optional('remote_ssl_no_validate', default=False):
Any(bool, All(Any(*string_types), Boolean()))
}
def return_schema(for_collection):
return_contains_schema = Any(
All(
Schema({
Required('description'):
Any(list_string_types, *string_types),
'returned':
Any(*string_types), # only returned on top level
Required('type'):
Any('bool', 'complex', 'dict', 'float', 'int', 'list', 'str'),
'version_added':
version(for_collection),
'version_added_collection':
collection_name,
'sample':
json_value,
'example':
json_value,
'contains':
Any(None,
*list({str_type: Self} for str_type in string_types)),
# in case of type='list' elements define type of individual item in list
'elements':
Any(None, 'bits', 'bool', 'bytes', 'dict', 'float', 'int',
'json', 'jsonarg', 'list', 'path', 'raw', 'sid', 'str'),
}),
Schema(return_contains),
Schema(
partial(version_added,
error_code='option-invalid-version-added')),
),
Schema(type(None)),
)
# This generates list of dicts with keys from string_types and return_contains_schema value
# for example in Python 3: {str: return_contains_schema}
list_dict_return_contains_schema = [{
str_type: return_contains_schema
} for str_type in string_types]
return Any(
All(
Schema({
any_string_types: {
Required('description'):
Any(list_string_types, *string_types),
Required('returned'):
Any(*string_types),
Required('type'):
Any('bool', 'complex', 'dict', 'float', 'int', 'list',
'str'),
'version_added':
version(for_collection),
'version_added_collection':
collection_name,
'sample':
json_value,
'example':
json_value,
'contains':
Any(None, *list_dict_return_contains_schema),
# in case of type='list' elements define type of individual item in list
'elements':
Any(None, 'bits', 'bool', 'bytes', 'dict', 'float', 'int',
'json', 'jsonarg', 'list', 'path', 'raw', 'sid',
'str'),
}
}),
Schema({any_string_types: return_contains}),
Schema({
any_string_types:
partial(version_added,
error_code='option-invalid-version-added')
}),
),
Schema(type(None)),
)
def retry_count():
return {
Optional('retry_count', default=3): All(Coerce(int),
Range(min=0, max=100))
}
def doc_schema(module_name, for_collection=False, deprecated_module=False):
if module_name.startswith('_'):
module_name = module_name[1:]
deprecated_module = True
doc_schema_dict = {
Required('module'):
module_name,
Required('short_description'):
Any(*string_types),
Required('description'):
Any(list_string_types, *string_types),
Required('author'):
All(Any(None, list_string_types, *string_types), author),
'notes':
Any(None, list_string_types),
'seealso':
Any(None, seealso_schema),
'requirements':
list_string_types,
'todo':
Any(None, list_string_types, *string_types),
'options':
Any(None, *list_dict_option_schema(for_collection)),
'extends_documentation_fragment':
Any(list_string_types, *string_types),
'version_added_collection':
collection_name,
}
if for_collection:
# Optional
doc_schema_dict['version_added'] = version(for_collection=True)
else:
doc_schema_dict[Required('version_added')] = version(
for_collection=False)
if deprecated_module:
deprecation_required_scheme = {
Required('deprecated'):
Any(deprecation_schema(for_collection=for_collection)),
}
doc_schema_dict.update(deprecation_required_scheme)
def add_default_attributes(more=None):
schema = {
'description': any_string_types,
'support': any_string_types,
'version_added_collection': any_string_types,
'version_added': any_string_types,
}
if more:
schema.update(more)
return schema
doc_schema_dict['attributes'] = Schema(
All(
Schema(
{
any_string_types: {
Required('description'): any_string_types,
Required('support'): Any('full', 'partial', 'none'),
'version_added_collection': collection_name,
'version_added':
version(for_collection=for_collection),
},
},
extra=ALLOW_EXTRA),
partial(version_added,
error_code='attribute-invalid-version-added',
accept_historical=False),
Schema(
{
any_string_types:
add_default_attributes(),
'action_group':
add_default_attributes({
Required('membership'):
list_string_types,
}),
'forced_action_plugin':
add_default_attributes({
Required('action_plugin'):
any_string_types,
}),
'proprietary':
add_default_attributes({
Required('platforms'):
list_string_types,
}),
},
extra=PREVENT_EXTRA),
))
return Schema(
All(
Schema(doc_schema_dict, extra=PREVENT_EXTRA),
partial(version_added,
error_code='module-invalid-version-added',
accept_historical=not for_collection),
))
def count():
return {Required('count'): All(Coerce(int), Range(min=0, max=10))}
def max_num_segments():
return {
Required('max_num_segments'): All(Coerce(int), Range(min=1, max=32768))
}
def slices():
return {
Optional('slices', default=1):
Any(All(Coerce(int), Range(min=1, max=500)), None)
}
def allow_ilm_indices():
return {
Optional('allow_ilm_indices', default=False):
Any(bool, All(Any(*string_types), Boolean()))
}
def wait_for_rebalance():
return {
Optional('wait_for_rebalance', default=True):
Any(bool, All(Any(*string_types), Boolean()))
}
def test_fix_157():
s = Schema(All([Any('one', 'two', 'three')]), Length(min=1))
assert_equal(['one'], s(['one']))
assert_raises(MultipleInvalid, s, ['four'])
