from voluptuous import Schema, Required, All, Any, Length, Range, Match, In schema = Schema({ Required('pipelineName'): All(str, Length(min=1)), Required('workingDirectory'): str, Required('crashLogDirectory'): str, Required('logDirectory'): str, Required('outputDirectory'): str, 'FSLDIR': str, 'runOnGrid': bool, 'resourceManager': str, 'parallelEnvironment': str, 'queue': str, 'awsOutputBucketCredentials': str, 's3Encryption': bool, # check/normalize 'maximumMemoryPerParticipant': float, 'maxCoresPerParticipant': All(int, Range(min=1)),
def test_fix_157(): s = Schema(All([Any('one', 'two', 'three')]), Length(min=1)) assert_equal(['one'], s(['one'])) assert_raises(MultipleInvalid, s, ['four'])
LOGGER = logging.getLogger(__name__) def get_lwt_topic(mqtt: dict) -> dict: if not mqtt["last_will_topic"]: mqtt["last_will_topic"] = f"{mqtt['client_id']}/lwt" return mqtt SCHEMA = Schema( All( { Required("broker"): str, Required("port", default=1883): int, Optional("username", default=None): Any(str, None), Optional("password", default=None): Any(str, None), Optional("client_id", default="viseron"): Any(str, None), Optional("discovery_prefix", default="homeassistant"): str, Optional("last_will_topic", default=None): Any(str, None), }, get_lwt_topic, )) class MQTTConfig: schema = SCHEMA def __init__(self, mqtt): self._broker = mqtt.broker self._port = mqtt.port self._username = mqtt.username self._password = mqtt.password
] schemas = { 'repos': [ { Required('name'): str, 'sortname': str, 'singular': str, Required('type'): Any('repository', 'site', 'modules'), Required('desc'): str, 'statsgroup': str, Required('family'): Any(*families), 'ruleset': Any(Any(*rulesets), [Any(*rulesets)]), # XXX: make required 'color': str, 'valid_till': date, 'default_maintainer': All(str, Contains('@')), 'update_period': Any(int, str), Required('minpackages'): int, Required('sources'): [ { Required('name'): Any(str, [str]), 'disabled': bool, Required('fetcher'): str, Required('parser'): str, 'url': str, # not Url(), as there may be rsync or cvs addresses # git fetcher args 'branch': str, 'subrepo': str, 'sparse_checkout': [str], 'depth': Any(int, None),
def LSValues(validator=None, msg=None): def f(v): if not isinstance(v, list): return [v] return v return All(f, All([LSValue(validator)], Length(min=1)))
from voluptuous import (Schema, All, Any, Lower, Coerce, DefaultTo, Optional) from udata.harvest.filters import (boolean, email, to_date, slug, normalize_tag, normalize_string, is_url, empty_none, hash) RESOURCE_TYPES = ('file', 'file.upload', 'api', 'documentation', 'image', 'visualization') resource = { 'id': basestring, 'position': int, 'name': All(DefaultTo(''), basestring), 'description': All(basestring, normalize_string), 'format': All(basestring, Lower), 'mimetype': Any(All(basestring, Lower), None), 'size': Any(Coerce(int), None), 'hash': Any(All(basestring, hash), None), 'created': All(basestring, to_date), 'last_modified': Any(All(basestring, to_date), None), 'url': All(basestring),
# -*- coding: utf-8 -*- from voluptuous import Schema, All, Required, Match, Length, Range, In, Coerce, Datetime from tlutil.validator import to_strip, to_split from tlutil.validator import email_validator, ipv4_validator, tfsUrl_validator, nickname_validator user_id_schema = Schema( {Required('user_id'): All(Coerce(int), Range(min=10001))}) user_ids_schema = Schema( {Required('user_ids'): All(Coerce(to_split), Range(min=10001))}) mobile_register_schema = Schema({ Required('mobile'): All(unicode, Length(min=11, max=15)), Required('nickname'): All(Coerce(unicode), Length(min=2, max=20), Match(nickname_validator)), Required('password'): All(unicode, Length(min=6, max=20)), Required('platform'): All(Coerce(int), Range(min=0, max=3)), Required('user_ip'): All(unicode, Match(ipv4_validator)), # f(female)表示女性,m(male)表示男性,u(unkown)表示未知 Required('gender', default='u'): In(frozenset(['f', 'm', 'u'])), Required('cover', default=''): All(unicode), Required('avatar', default=''): All(unicode),
MAP_SCHEMA = Schema( { "version": Any(int, None), Required("id"): str, Required("url"): Url, "url_valid_for_seconds": Any(int, None), Optional("run_id"): str, # documented, but not present "status": Any(str, None), "launched_from": Any(str, None), "error": Any(str, None), "category": Any(int, None), "mode": Any(int, None), "modifier": Any(int, None), "start_at": Any(str, None), "end_at": Any(str, None), "end_orientation_relative_degrees": All(int, Range(min=0, max=360)), "run_charge_at_start": All(int, Range(min=0, max=100)), "run_charge_at_end": All(int, Range(min=0, max=100)), "suspended_cleaning_charging_count": Any(int, None), "time_in_suspended_cleaning": Any(int, None), "time_in_error": Any(int, None), "time_in_pause": Any(int, None), "cleaned_area": Any(float, None), "base_count": Any(int, None), "is_docked": Any(bool, None), "delocalized": Any(bool, None), # Everything below this line is not documented, but still present "generated_at": Any(str, None), "persistent_map_id": Any(int, str, None), "cleaned_with_persistent_map_id": Any(int, str, None), "valid_as_persistent_map": Any(bool, None),
return schema(v) return v 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': Any(float, *string_types), 'sample': Any(None, list, dict, int, float, *string_types), 'example': Any(None, list, dict, int, float, *string_types), '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(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}
def __init__(self, paths): self.configfiles = self._list_config_files(paths) configparser = RawConfigParser() config_tmp = configparser.read(self.configfiles) self.conf = dict() for section in configparser.sections(): self.conf[section] = dict(configparser.items(section)) #self.conf = ConfigObj(self.configfile, interpolation=False) self.schemas = { "storage": Schema({ Optional("storage_path"): All(str), Optional("storage_type"): Any('yaml', 'json', 'pickle'), }), "cloud": Schema( { "provider": Any('ec2_boto', 'google', 'openstack'), "ec2_url": Url(str), Optional("ec2_access_key"): All(str, Length(min=1)), Optional("ec2_secret_key"): All(str, Length(min=1)), "ec2_region": All(str, Length(min=1)), "auth_url": All(str, Length(min=1)), "username": All(str, Length(min=1)), "password": All(str, Length(min=1)), "tenant_name": All(str, Length(min=1)), Optional("region_name"): All(str, Length(min=1)), "gce_project_id": All(str, Length(min=1)), "gce_client_id": All(str, Length(min=1)), "gce_client_secret": All(str, Length(min=1)), "nova_client_api": nova_api_version() }, extra=True), "cluster": Schema( { "cloud": All(str, Length(min=1)), "setup_provider": All(str, Length(min=1)), "login": All(str, Length(min=1)), }, required=True, extra=True), "setup": Schema({ "provider": All(str, Length(min=1)), }, required=True, extra=True), "login": Schema( { "image_user": All(str, Length(min=1)), "image_user_sudo": All(str, Length(min=1)), "image_sudo": Boolean(str), "user_key_name": All(str, Length(min=1)), "user_key_private": can_read_file(), "user_key_public": can_read_file() }, required=True) }
Length, Match, message, Optional, Range, Schema, ) from .misc import ( make_ts, parse_timedelta, ) key = All( str, Length(min=1), Match("^[a-zA-Z0-9-_@]+$"), ) dotted_key = All( str, Length(min=1), Match("^[a-zA-Z0-9-_@.]+$"), ) seasonality = Schema({ Optional('daytime', default=False): Boolean(), Optional('weekday', default=False): Boolean(), }) score = Any(All(Any(int, float), Range(min=0, max=100)), None)
def validate(self): """ Validate the given configuration, converting properties to native Python types. The configuration to check must have been given to the constructor and stored in :py:attr:`self.config`. :raises: :py:class:`voluptuous.Invalid` if one property is invalid :raises: :py:class:`voluptuous.MultipleInvalid` if multiple properties are not compliant """ self._pre_validate() # schema to validate all cluster properties schema = { "cluster": { "cloud": All(str, Length(min=1)), "setup_provider": All(str, Length(min=1)), "login": All(str, Length(min=1)), }, "setup": { "provider": All(str, Length(min=1)), Optional("playbook_path"): can_read_file(), Optional("ansible_command"): All(can_read_file(), can_execute_file()), Optional("ansible_extra_args"): All(str, Length(min=1)), Optional("ssh_pipelining"): Boolean(str), }, "login": { "image_user": All(str, Length(min=1)), "image_user_sudo": All(str, Length(min=1)), "image_sudo": Boolean(str), "user_key_name": All(str, Length(min=1)), "user_key_private": can_read_file(), "user_key_public": can_read_file(), }, } cloud_schema_ec2 = { "provider": 'ec2_boto', "ec2_url": Url(str), Optional("ec2_access_key"): All(str, Length(min=1)), Optional("ec2_secret_key"): All(str, Length(min=1)), "ec2_region": All(str, Length(min=1)), Optional("request_floating_ip"): Boolean(str), Optional("vpc"): All(str, Length(min=1)), Optional("instance_profile"): All(str, Length(min=1)), } cloud_schema_gce = { "provider": 'google', "gce_client_id": All(str, Length(min=1)), "gce_client_secret": All(str, Length(min=1)), "gce_project_id": All(str, Length(min=1)), Optional("noauth_local_webserver"): Boolean(str), Optional("zone"): All(str, Length(min=1)), Optional("network"): All(str, Length(min=1)), } cloud_schema_openstack = { "provider": 'openstack', "auth_url": All(str, Length(min=1)), "username": All(str, Length(min=1)), "password": All(str, Length(min=1)), "project_name": All(str, Length(min=1)), Optional("request_floating_ip"): Boolean(str), Optional("region_name"): All(str, Length(min=1)), Optional("nova_api_version"): nova_api_version(), } node_schema = { "flavor": All(str, Length(min=1)), "image_id": All(str, Length(min=1)), "security_group": All(str, Length(min=1)), Optional("network_ids"): All(str, Length(min=1)), } # validation validator = Schema(schema, required=True, extra=True) node_validator = Schema(node_schema, required=True, extra=True) ec2_validator = Schema(cloud_schema_ec2, required=True, extra=False) gce_validator = Schema(cloud_schema_gce, required=True, extra=False) openstack_validator = Schema(cloud_schema_openstack, required=True, extra=False) if not self.config: raise Invalid("No clusters found in configuration.") for cluster, properties in self.config.iteritems(): self.config[cluster] = validator(properties) if 'provider' not in properties['cloud']: raise Invalid("Missing `provider` option in cluster `%s`" % cluster) try: cloud_props = properties['cloud'] if properties['cloud']['provider'] == "ec2_boto": self.config[cluster]['cloud'] = ec2_validator(cloud_props) elif properties['cloud']['provider'] == "google": self.config[cluster]['cloud'] = gce_validator(cloud_props) elif properties['cloud']['provider'] == "openstack": self.config[cluster]['cloud'] = openstack_validator( cloud_props) except MultipleInvalid as ex: raise Invalid( "Invalid configuration for cloud section `cloud/%s`: %s" % (properties['cluster']['cloud'], str.join(", ", [str(i) for i in ex.errors]))) if 'nodes' not in properties or len(properties['nodes']) == 0: raise Invalid("No nodes configured for cluster `%s`" % cluster) for node, props in properties['nodes'].iteritems(): # check name pattern to conform hostnames match = re.search(r'^[a-zA-Z0-9-]*$', node) if not match: raise Invalid( "Invalid name `%s` for node group. A valid node group" " can only consist of letters, digits or the hyphen" " character (`-`)" % (node, )) node_validator(props) if (properties['cloud']['provider'] == 'ec2_boto' and 'vpc' in self.config[cluster]['cloud'] and 'network_ids' not in props): raise Invalid("Node group `%s/%s` is being used in" " a VPC, so it must specify network_ids." % (cluster, node)) if (properties['cloud']['provider'] == 'ec2_boto' and 'network_ids' in props and 'vpc' not in self.config[cluster]['cloud']): raise Invalid("Cluster `%s` must specify a VPC to place" " `%s` instances in %s" % (cluster, node, props['network_ids'])) self._post_validate()
extra=ALLOW_EXTRA ) if v.get('type') == 'complex': return schema(v) return v return_schema = Any( All( Schema( { any_string_types: { Required('description'): Any(list_string_types, *string_types), Required('returned'): Any(*string_types), Required('type'): Any('string', 'list', 'boolean', 'dict', 'complex', 'bool', 'float', 'int', 'dictionary', 'str'), 'version_added': Any(float, *string_types), 'sample': Any(None, list, dict, int, float, *string_types), 'example': Any(None, list, dict, int, float, *string_types), 'contains': object, } } ), Schema({any_string_types: return_contains}) ), Schema(type(None)), ) deprecation_schema = Schema( { # Only list branches that are deprecated or may have docs stubs in # Deprecation cycle changed at 2.4 (though not retroactively)
carbon2_batch = [carbon2(*sample, scrape_ts) for sample in batch] body = "\n".join(carbon2_batch).encode("utf-8") resp = self._sumo_session.post( self._config["sumo_http_url"], data=zlib.compress(body, level=1), headers={ "Content-Type": "application/vnd.sumologic.carbon2", "Content-Encoding": "gzip", }, ) resp.raise_for_status() global_config_schema = Schema({ Required("run_interval_seconds", default=60): All(int, Range(min=1)), Required("target_threads", default=10): All(int, Range(min=1, max=50)), Required("batch_size", default=1000): All(int, Range(min=1)), Required("retries", default=5): All(int, Range(min=1, max=20)), Required("backoff_factor", default=0.2): All(float, Range(min=0)), "source_category": str, "source_host": str, "source_name": str, "dimensions":
from yombo.constants import SENTINEL from yombo.core.entity import Entity from yombo.core.log import get_logger from yombo.core.library import YomboLibrary from yombo.core.schemas import StateSchema from yombo.mixins.library_db_child_mixin import LibraryDBChildMixin from yombo.mixins.library_db_parent_mixin import LibraryDBParentMixin from yombo.mixins.library_search_mixin import LibrarySearchMixin from yombo.mixins.systemdata_mixin import SystemDataParentMixin, SystemDataChildMixin from yombo.utils import random_int logger = get_logger("library.states") ACTION_STATE_SCHEMA = Schema({ Required('gateway_id'): All(str, Length(min=2)), Required('state_name'): All(str, Length(min=2)), Required('value'): All(str, Length(min=2)), Required('human_value'): All(str, Length(min=2)), Required('value_type'): ['str', 'dict', 'list', 'int', 'float', 'epoch'], Required('value'): All(str, Length(min=2)), Required('weight'): All(int, Range(min=0)), }) class State(Entity, LibraryDBChildMixin, SystemDataChildMixin):
config_contract = Schema( { Required('enabled'): bool, Required('materialized'): basestring, Required('post-hook'): [hook_contract], Required('pre-hook'): [hook_contract], Required('vars'): dict, Required('quoting'): dict, Required('column_types'): dict, }, extra=ALLOW_EXTRA) parsed_node_contract = unparsed_node_contract.extend({ # identifiers Required('unique_id'): All(basestring, Length(min=1, max=255)), Required('fqn'): All(list, [All(basestring)]), Required('schema'): basestring, Required('refs'): [All(tuple)], # parsed fields Required('depends_on'): { Required('nodes'): [All(basestring, Length(min=1, max=255))], Required('macros'): [All(basestring, Length(min=1, max=255))], }, Required('empty'): bool, Required('config'): config_contract,
), ] CONF = cfg.CONF CONF.register_opts(keystone_opts, COLLECTOR_MONASCA_OPTS) CONF.register_opts(collector_monasca_opts, COLLECTOR_MONASCA_OPTS) METRICS_CONF = ck_utils.load_conf(CONF.collect.metrics_conf) MONASCA_EXTRA_SCHEMA = { Required('extra_args'): { # Key corresponding to the resource id in a metric's dimensions # Allows to adapt the resource identifier. Should not need to be # modified in a standard OpenStack installation Required('resource_key', default='resource_id'): All(str, Length(min=1)), Required('aggregation_method', default='max'): In(['max', 'mean', 'min']), # In case the metrics in Monasca do not belong to the project # cloudkitty is identified in Required('forced_project_id', default=''): str, }, } class EndpointNotFound(Exception): """Exception raised if the Monasca endpoint is not found""" class MonascaCollector(collector.BaseCollector):
def custom_schema(): custom_dict = {} for tag, settings in ops_settings['column_mappings'].items(): custom_dict[tag] = Required(list, msg='Must be a list') return custom_dict geom_schema = { Optional('geojson'): Required(object, msg='Must be a geojson object'), Optional('bbox'): Required(All(list, Length(min=2, max=2)), msg='Must be length of {}'.format(2)), Optional('buffer'): Required(All( Coerce(int), Range(min=0, max=ops_settings['maximum_search_radius_for_points'])), msg='Must be between 1 and {}'.format( ops_settings['maximum_search_radius_for_points'])) } filters_schema = { Optional('category_group_ids'): Required(All(categories_tools.category_group_ids, Length(max=ops_settings['maximum_categories'])), msg='Must be one of {} and have a maximum amount of {}'.format( categories_tools.category_group_ids,
connection_contract = Schema({ Required('type'): Any('postgres', 'redshift', 'snowflake'), Required('name'): Any(None, basestring), Required('state'): Any('init', 'open', 'closed', 'fail'), Required('transaction_open'): bool, Required('handle'): Any(None, object), Required('credentials'): object, }) postgres_credentials_contract = Schema({ Required('dbname'): basestring, Required('host'): basestring, Required('user'): basestring, Required('pass'): basestring, Required('port'): All(int, Range(min=0, max=65535)), Required('schema'): basestring, }) snowflake_credentials_contract = Schema({ Required('account'): basestring, Required('user'): basestring, Required('password'): basestring, Required('database'): basestring, Required('schema'): basestring, Required('warehouse'): basestring, Optional('role'): basestring, }) credentials_mapping = { 'postgres': postgres_credentials_contract,
def validate(self, request): xmlstr = request.saml_request data = saml_to_dict(xmlstr) atcss = [] if self._action == 'login': req_type = 'AuthnRequest' service = 'single_sign_on_service' elif self._action == 'logout': req_type = 'LogoutRequest' service = 'single_logout_service' issuer_name = data.get( '{urn:oasis:names:tc:SAML:2.0:protocol}%s' % (req_type), {}).get('children', {}).get('{urn:oasis:names:tc:SAML:2.0:assertion}Issuer', {}).get('text') if issuer_name and issuer_name not in self._metadata.service_providers( ): raise UnknownEntityIDError( 'entity ID {} non registrato'.format(issuer_name)) for k, _md in self._metadata.items(): if k == issuer_name: _srvs = _md.get('spsso_descriptor', []) for _srv in _srvs: for _acs in _srv.get('attribute_consuming_service', []): atcss.append(_acs) try: ascss = self._metadata.assertion_consumer_service(issuer_name) except Exception: ascss = [] except Exception: ascss = [] attribute_consuming_service_indexes = [ str(el.get('index')) for el in atcss ] assertion_consumer_service_indexes = [ str(el.get('index')) for el in ascss ] receivers = self._config.receivers(service) issuer = Schema( { 'attrs': { 'Format': Equal( NAMEID_FORMAT_ENTITY, msg=DEFAULT_VALUE_ERROR.format(NAMEID_FORMAT_ENTITY)), 'NameQualifier': Equal(issuer_name, msg=DEFAULT_VALUE_ERROR.format(issuer_name)), }, 'children': {}, 'text': str, }, required=True, ) name_id = Schema( { 'attrs': { 'NameQualifier': str, 'Format': Equal(NAMEID_FORMAT_TRANSIENT, msg=DEFAULT_VALUE_ERROR.format( NAMEID_FORMAT_TRANSIENT)), }, 'children': {}, 'text': str }, required=True, ) name_id_policy = Schema( { 'attrs': { 'Format': Equal(NAMEID_FORMAT_TRANSIENT, msg=DEFAULT_VALUE_ERROR.format( NAMEID_FORMAT_TRANSIENT)), }, 'children': {}, 'text': None, }, required=True, ) conditions = Schema( { 'attrs': { 'NotBefore': All(str, self._check_utc_date), 'NotOnOrAfter': All(str, self._check_utc_date), }, 'children': {}, 'text': None, }, required=True, ) authn_context_class_ref = Schema( { 'attrs': {}, 'children': {}, 'text': All( str, In(SPID_LEVELS, msg=DEFAULT_LIST_VALUE_ERROR.format(SPID_LEVELS))) }, required=True, ) requested_authn_context = Schema( { 'attrs': { 'Comparison': str }, 'children': { '{%s}AuthnContextClassRef' % (ASSERTION): authn_context_class_ref }, 'text': None }, required=True, ) scoping = Schema( { 'attrs': { 'ProxyCount': Equal('0', msg=DEFAULT_VALUE_ERROR.format('0')) }, 'children': {}, 'text': None }, required=True, ) signature = Schema( { 'attrs': dict, 'children': dict, 'text': None }, required=True, ) subject = Schema( { 'attrs': { 'Format': Equal( NAMEID_FORMAT_ENTITY, msg=DEFAULT_VALUE_ERROR.format(NAMEID_FORMAT_ENTITY)), 'NameQualifier': str }, 'children': {}, 'text': None }, required=True, ) # LOGIN def check_assertion_consumer_service(attrs): keys = attrs.keys() if ('AssertionConsumerServiceURL' in keys and 'ProtocolBinding' in keys and 'AssertionConsumerServiceIndex' not in keys): if attrs['ProtocolBinding'] != BINDING_HTTP_POST: raise Invalid( DEFAULT_VALUE_ERROR.format(BINDING_HTTP_POST), path=['ProtocolBinding']) return attrs elif ('AssertionConsumerServiceURL' not in keys and 'ProtocolBinding' not in keys and 'AssertionConsumerServiceIndex' in keys): if attrs[ 'AssertionConsumerServiceIndex'] not in assertion_consumer_service_indexes: raise Invalid(DEFAULT_LIST_VALUE_ERROR.format( assertion_consumer_service_indexes), path=['AssertionConsumerServiceIndex']) return attrs else: raise Invalid( 'Uno e uno solo uno tra gli attributi o gruppi di attributi devono essere presenti: ' '[AssertionConsumerServiceIndex, [AssertionConsumerServiceUrl, ProtocolBinding]]' ) authnrequest_attr_schema = Schema(All( { 'ID': str, 'Version': Equal('2.0', msg=DEFAULT_VALUE_ERROR.format('2.0')), 'IssueInstant': All(str, self._check_utc_date, self._check_date_in_range), 'Destination': In(receivers, msg=DEFAULT_LIST_VALUE_ERROR.format(receivers)), Optional('ForceAuthn'): str, Optional('AttributeConsumingServiceIndex'): In(attribute_consuming_service_indexes, msg=DEFAULT_LIST_VALUE_ERROR.format( attribute_consuming_service_indexes)), Optional('AssertionConsumerServiceIndex'): str, Optional('AssertionConsumerServiceURL'): str, Optional('ProtocolBinding'): str, }, check_assertion_consumer_service, ), required=True) authnrequest_schema = { '{%s}AuthnRequest' % (PROTOCOL): { 'attrs': authnrequest_attr_schema, 'children': Schema( { Optional('{%s}Subject' % (ASSERTION)): subject, '{%s}Issuer' % (ASSERTION): issuer, '{%s}NameIDPolicy' % (PROTOCOL): name_id_policy, Optional('{%s}Conditions' % (ASSERTION)): conditions, '{%s}RequestedAuthnContext' % (PROTOCOL): requested_authn_context, Optional('{%s}Scoping' % (PROTOCOL)): scoping, }, required=True, ), 'text': None } } if self._binding == BINDING_HTTP_POST: authnrequest_schema['{%s}AuthnRequest' % (PROTOCOL)]['children'].extend = { '{%s}Signature' % (SIGNATURE): signature } authn_request = Schema( authnrequest_schema, required=True, ) # LOGOUT logout_request = Schema( { '{%s}LogoutRequest' % (PROTOCOL): { 'attrs': { 'ID': str, 'Version': Equal('2.0', msg=DEFAULT_VALUE_ERROR.format('2.0')), 'IssueInstant': All(str, self._check_utc_date, self._check_date_in_range), 'Destination': In(receivers, msg=DEFAULT_LIST_VALUE_ERROR.format(receivers)), }, 'children': { '{%s}Issuer' % (ASSERTION): issuer, '{%s}NameID' % (ASSERTION): name_id, '{%s}SessionIndex' % (PROTOCOL): dict, }, 'text': None } }, required=True, ) saml_schema = None if self._action == 'login': saml_schema = authn_request elif self._action == 'logout': saml_schema = logout_request errors = [] try: saml_schema(data) except MultipleInvalid as e: for err in e.errors: _val = data _paths = [] _attr = None for idx, _path in enumerate(err.path): if _path != 'children': if _path == 'attrs': try: _attr = err.path[(idx + 1)] except IndexError: _attr = '' break _paths.append(_path) path = '/'.join(_paths) path = 'xpath: {}'.format(path) if _attr is not None: path = '{} - attribute: {}'.format(path, _attr) for _ in err.path: _val = _val.get(_) errors.append( ValidationDetail(_val, None, None, None, None, err.msg, path)) raise SPIDValidationError(details=errors)
""" Configuration data and functions """ from socket import getfqdn from six import string_types from voluptuous import All, Any, Boolean, Coerce, Optional, Range, Schema # pylint: disable=no-value-for-parameter DEFAULTS = { # Configuration file: logging 'logging': { Optional('loglevel', default='INFO'): Any(None, 'NOTSET', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL', All(Coerce(int), Any(0, 10, 20, 30, 40, 50))), Optional('logfile', default=None): Any(None, *string_types), Optional('logformat', default='default'): Any('default', 'json', 'logstash'), Optional('blacklist', default=['elasticsearch', 'urllib3']): Any(None, list), }, # Configuration file: backend 'backend': { Optional('host', default='127.0.0.1'): Any(None, *string_types), Optional('port', default=7600): All(Coerce(int), Range(min=1025, max=65534)), Optional('debug', default=False): Boolean(), Optional('cache_timeout', default=60):
"DependentSamplers depend on undefined quantities: " + bad_symbols) # 2: Circular dependencies bad_symbols = ", ".join(sorted(unevaluated_dependents.keys())) raise ConfigError( "Circularly dependent DependentSamplers detected: " + bad_symbols) sample_list.append(sample_dict) return sample_list # Used by NumericalGrader schema_user_functions_no_random = All(has_keys_of_type(six.string_types), coerce_string_keys_to_text_type, {Extra: is_callable}) # Used by FormulaGrader and friends schema_user_functions = All( has_keys_of_type(six.string_types), coerce_string_keys_to_text_type, { Extra: Any(is_callable, All([is_callable], Coerce(SpecificFunctions)), FunctionSamplingSet) }, ) def construct_functions(default_functions, user_funcs): """
from voluptuous import Required, All from datatypes.core import DictionaryValidator from datatypes.validators import deed_validator entry_schema = { Required("template"): All(unicode), Required("full_text"): All(unicode), Required("fields"): {unicode: object}, Required("deeds"): [deed_validator.deed_schema], Required("notes"): [] } class Entry(DictionaryValidator): def define_schema(self): return entry_schema def define_error_dictionary(self): return { "template": "template is a required field", "full_text": "full_text is a required field", "fields": "fields are required", "deeds": "deeds are required", "notes": "notes are required" }
def validate_user_constants(*allow_types): return All( has_keys_of_type(six.string_types), coerce_string_keys_to_text_type, {Extra: Any(*allow_types)}, )
'values(%s, %s, %s, NOW(), %s, %s)', const.seq.PRE_PAYMENT, id, supplier_shop_account_id, external_money.amount, "减去给商户的预付款(前期销售额不能提现)") self.redirect('/external-money') list_schema = Schema({ 'supplier': str, 'source': str, }, extra=True) add_schema = Schema( { 'supplier': str, 'amount': All(Coerce(Decimal), Range(min=Decimal(0.1))), 'source': str, 'flag': str, 'id': str, 'type': str, 'expire_at': str, 'remark': str, 'short_name': str, 'action': Any('add_external_money', 'edit_external_money'), 'fee': str, 'received_at': str, 'fee_remark': str, 'received_type': Any('OPERATE_FEE', 'ADS_FEE', 'ONLINE_FEE') }, extra=True)
EXTRA_AGGREGATION_METHODS_FOR_ARCHIVE_POLICY = set( (str(i) + 'pct' for i in six.moves.range(1, 100))) for agg in list(EXTRA_AGGREGATION_METHODS_FOR_ARCHIVE_POLICY): EXTRA_AGGREGATION_METHODS_FOR_ARCHIVE_POLICY.add("rate:%s" % agg) # The aggregation method that one can use to configure the archive # policies also supports the 'pct' (percentile) operation. Therefore, # we also expose this as a configuration. VALID_AGGREGATION_METHODS_FOR_METRICS = BASIC_AGGREGATION_METHODS.union( EXTRA_AGGREGATION_METHODS_FOR_ARCHIVE_POLICY) GNOCCHI_EXTRA_SCHEMA = { Required('extra_args'): { Required('resource_type'): All(str, Length(min=1)), # Due to Gnocchi model, metric are grouped by resource. # This parameter permits to adapt the key of the resource identifier Required('resource_key', default='id'): All(str, Length(min=1)), Required('aggregation_method', default='max'): In(VALID_AGGREGATION_METHODS_FOR_METRICS), Required('re_aggregation_method', default='max'): In(BASIC_AGGREGATION_METHODS), Required('force_granularity', default=3600): All(int, Range(min=0)), }, } class AssociatedResourceNotFound(Exception): """Exception raised when no resource can be associated with a metric."""
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 validate_metadata_file(path, is_ansible, check_deprecation_dates=False): """Validate explicit runtime metadata file""" try: with open(path, 'r') as f_path: routing = yaml.safe_load(f_path) except yaml.error.MarkedYAMLError as ex: print('%s:%d:%d: YAML load failed: %s' % (path, ex.context_mark.line + 1, ex.context_mark.column + 1, re.sub(r'\s+', ' ', str(ex)))) return except Exception as ex: # pylint: disable=broad-except print('%s:%d:%d: YAML load failed: %s' % (path, 0, 0, re.sub(r'\s+', ' ', str(ex)))) return if is_ansible: current_version = get_ansible_version() else: current_version = get_collection_version() # Updates to schema MUST also be reflected in the documentation # ~https://docs.ansible.com/ansible/devel/dev_guide/developing_collections.html # plugin_routing schema avoid_additional_data = Schema(Any( { Required('removal_version'): any_value, 'warning_text': any_value, }, { Required('removal_date'): any_value, 'warning_text': any_value, }), extra=PREVENT_EXTRA) deprecation_schema = All( # The first schema validates the input, and the second makes sure no extra keys are specified Schema({ 'removal_version': partial(removal_version, is_ansible=is_ansible, current_version=current_version), 'removal_date': partial(isodate, check_deprecation_date=check_deprecation_dates), 'warning_text': Any(*string_types), }), avoid_additional_data) tombstoning_schema = All( # The first schema validates the input, and the second makes sure no extra keys are specified Schema({ 'removal_version': partial(removal_version, is_ansible=is_ansible, current_version=current_version, is_tombstone=True), 'removal_date': partial(isodate, is_tombstone=True), 'warning_text': Any(*string_types), }), avoid_additional_data) plugin_routing_schema = Any( Schema( { ('deprecation'): Any(deprecation_schema), ('tombstone'): Any(tombstoning_schema), ('redirect'): Any(*string_types), }, extra=PREVENT_EXTRA), ) list_dict_plugin_routing_schema = [{ str_type: plugin_routing_schema } for str_type in string_types] plugin_schema = Schema( { ('action'): Any(None, *list_dict_plugin_routing_schema), ('become'): Any(None, *list_dict_plugin_routing_schema), ('cache'): Any(None, *list_dict_plugin_routing_schema), ('callback'): Any(None, *list_dict_plugin_routing_schema), ('cliconf'): Any(None, *list_dict_plugin_routing_schema), ('connection'): Any(None, *list_dict_plugin_routing_schema), ('doc_fragments'): Any(None, *list_dict_plugin_routing_schema), ('filter'): Any(None, *list_dict_plugin_routing_schema), ('httpapi'): Any(None, *list_dict_plugin_routing_schema), ('inventory'): Any(None, *list_dict_plugin_routing_schema), ('lookup'): Any(None, *list_dict_plugin_routing_schema), ('module_utils'): Any(None, *list_dict_plugin_routing_schema), ('modules'): Any(None, *list_dict_plugin_routing_schema), ('netconf'): Any(None, *list_dict_plugin_routing_schema), ('shell'): Any(None, *list_dict_plugin_routing_schema), ('strategy'): Any(None, *list_dict_plugin_routing_schema), ('terminal'): Any(None, *list_dict_plugin_routing_schema), ('test'): Any(None, *list_dict_plugin_routing_schema), ('vars'): Any(None, *list_dict_plugin_routing_schema), }, extra=PREVENT_EXTRA) # import_redirection schema import_redirection_schema = Any( Schema( { ('redirect'): Any(*string_types), # import_redirect doesn't currently support deprecation }, extra=PREVENT_EXTRA)) list_dict_import_redirection_schema = [{ str_type: import_redirection_schema } for str_type in string_types] # top level schema schema = Schema( { # All of these are optional ('plugin_routing'): Any(plugin_schema), ('import_redirection'): Any(None, *list_dict_import_redirection_schema), # requires_ansible: In the future we should validate this with SpecifierSet ('requires_ansible'): Any(*string_types), ('action_groups'): dict, }, extra=PREVENT_EXTRA) # Ensure schema is valid try: schema(routing) except MultipleInvalid as ex: for error in ex.errors: # No way to get line/column numbers print('%s:%d:%d: %s' % (path, 0, 0, humanize_error(routing, error)))
Required('type'): 'decision-task', # Treeherder symbol for the cron task Required('treeherder-symbol'): basestring, # --target-tasks-method './mach taskgraph decision' argument 'target-tasks-method': basestring, }), # when to run it # Optional set of projects on which this job should run; if omitted, this will # run on all projects for which cron tasks are set up. This works just like the # `run_on_projects` attribute, where strings like "release" and "integration" are # expanded to cover multiple repositories. (taskcluster/docs/attributes.rst) 'run-on-projects': [basestring], # Array of times at which this task should run. These *must* be a # multiple of 15 minutes, the minimum scheduling interval. This field # can be keyed by project so that each project has a different schedule # for the same job. 'when': optionally_keyed_by( 'project', [{'hour': int, 'minute': All(int, even_15_minutes)}]), }], }) def validate(cron_yml): validate_schema(cron_yml_schema, cron_yml, "Invalid .cron.yml:")
def get_schema(cls, pin, version): return Schema({ Required('type'): cls.descriptor_name, Required('pin'): pin, Required('name'): All(str, NotEmpty()), })