class DataCubeForm(Schema): """Define parser for datacube creation.""" datacube = fields.String(required=True, allow_none=False, validate=Regexp('^[a-zA-Z0-9]*$', error=INVALID_CUBE_NAME)) grs = fields.String(required=True, allow_none=False) resolution = fields.Integer(required=True, allow_none=False) temporal_schema = fields.Dict(required=True, allow_none=False) bands_quicklook = fields.List(fields.String, required=True, allow_none=False) composite_function = fields.String(required=True, allow_none=False, validate=OneOf(['MED', 'STK', 'IDT'])) bands = fields.Nested(BandDefinition, required=True, allow_none=False, many=True) quality_band = fields.String(required=True, allow_none=False) indexes = fields.Nested(BandDefinition, many=True) description = fields.String(required=True, allow_none=False) license = fields.String(required=False, allow_none=True) version = fields.Integer(required=True, allow_none=False, default=1) title = fields.String(required=True, allow_none=False) # Set cubes as public by default. public = fields.Boolean(required=False, allow_none=False, default=True) @pre_load def validate_indexes(self, data, **kwargs): """Ensure that both indexes and quality band is present in attribute 'bands'. Seeks for quality_band in attribute 'bands' and set as `common_name`. Raises: ValidationError when a band inside indexes or quality_band is duplicated with attribute bands. """ indexes = data['indexes'] band_names = [b['name'] for b in data['bands']] for band_index in indexes: if band_index['name'] in band_names: raise ValidationError(f'Duplicated band name in indices {band_index["name"]}') if 'quality_band' in data: if data['quality_band'] not in band_names: raise ValidationError(f'Quality band "{data["quality_band"]}" not found in key "bands"') band = next(filter(lambda band: band['name'] == data['quality_band'], data['bands'])) band['common_name'] = 'quality' if 'temporal_schema' in data: import pkgutil import bdc_catalog from jsonschema import validate, draft7_format_checker import json content = pkgutil.get_data(bdc_catalog.__name__, 'jsonschemas/collection-temporal-composition-schema.json') schema = json.loads(content) try: schema['$id'] = schema['$id'].replace('#', '') validate(instance=data['temporal_schema'], schema=schema, format_checker=draft7_format_checker) except Exception as e: print(e) raise return data
class DISADestinationSchema(ApplicationDestinationSchema): pin = fields.String( validate=(Predicate('isdigit'), Length(max=40)), allow_none=True, attribute='actionarg1', ) context = fields.String(validate=Regexp(CONTEXT_REGEX), attribute='actionarg2', required=True)
class NICDesciptionSchema(Schema): model = fields.Str(validate=OneOf( ['virtio-net', 'sungem', 'usb-net', 'rtl8139', 'pcnet', 'e1000']), default='virtio-net', missing='virtio-net') mac = fields.Str( validate=Regexp('^([0-9A-Fa-f]{2}[:]){5}([0-9A-Fa-f]{2})$'), required=True) master = fields.Str(allow_none=False, required=True)
def _validate_skill_rule_variables_value(self, variables): # with marshmallow 3.0 we can set this validator on the field declaration if not variables: return validator = Regexp(SKILL_RULE_VARIABLE_REGEX) for key, value in variables.items(): validator(key) validator(value)
class SchemaIdMatchInfoSchema(OpenAPISchema): """Path parameters and validators for request taking schema id.""" schema_id = fields.Str( description="Schema identifier", required=True, validate=Regexp(rf"^[1-9][0-9]*|[{B58}]{{21,22}}:2:.+:[0-9.]+$"), example=INDY_SCHEMA_ID["example"], )
class CustomDestinationSchema(BaseDestinationSchema): exten = fields.String(validate=Regexp(EXTEN_REGEX), required=True) @pre_load def remove_invalid_white_spaces(self, data, **kwargs): exten = data.get('exten') if exten and isinstance(exten, str): data['exten'] = exten.strip() return data
class Query(Schema): animal_type = fields.String( validate=[Regexp(regex=re.compile('^[a-zA-Z0-9]*$'))]) limit = fields.Integer(missing=lambda: 100, validate=[ Range(min=0, max=None, exclusive_min=False, exclusive_max=False) ])
class UserFilter(USchema): class Meta: unknown = EXCLUDE page = fields.Integer(required=True, allow_none=False) page_size = fields.Integer(required=False, allow_none=False) email = fields.String(required=False, allow_none=False, validate=Regexp(NOT_EMPTY_REGEX))
class MySchema(marshmallow.Schema): # byr = Number(required=True,validate=Range(min=1920,max=2002)) iyr = Number(required=True,validate=Range(min=2010,max=2020)) eyr = Number(required=True,validate=Range(min=2020,max=2030)) hgt = String(required=True) hcl = String(required=True,validate=Regexp('#[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]')) ecl = String(required=True,validate=OneOf(['amb','blu','brn','gry','grn','hzl','oth'])) pid = Integer(required=True) cid = String(required=False)
class BackendStatusSchema(BaseSchema): """Schema for BackendStatus.""" # Required properties. backend_name = String(required=True) backend_version = String(required=True, validate=Regexp("[0-9]+.[0-9]+.[0-9]+$")) operational = Boolean(required=True) pending_jobs = Integer(required=True, validate=Range(min=0)) status_msg = String(required=True)
class UserTypeSchema(ma.Schema): """Adding Schema validations to the UserType""" user_type = fields.Str(required=True, validate=(Length(max=20), Regexp(name_string))) class Meta: """Expose fields""" fields = ('id', 'user_type')
def _validate(config: dict, params: dict, confirm: bool): # noqa # Build Marshmallow Schema from configuration fields = { "appid": String(required=True), "lang": String(validate=Regexp(r"^[a-z]{2}$"), missing=None), } if confirm: fields["confirm"] = Email(required=True) for name, options in config.items(): field_class = String validate = [] required = False for opt in options: if opt == "boolean": field_class = Boolean elif opt == "email": field_class = Email elif opt == "forbidden": validate.append(Length(equal=0)) elif opt == "mandatory": field_class = Boolean required = True validate.append(Equal(True, error="Mandatory.")) elif opt == "required": required = True elif opt == "single-line": validate.append(Regexp(r"^[^\r\n]*$")) else: raise AppConfigError( "Invalid option {opt} for parameter {name}") kwargs = {"required": required, "validate": validate} if not required: kwargs["missing"] = None fields[name] = field_class(**kwargs) schema = Schema.from_dict(fields)() # Do the actual validation; don't use the deserialized values because we # want for example "yes" to remain "yes" and not change to True errors = schema.validate(params) if errors: messages = [k + ": " + " ".join(v) for k, v in errors.items()] abort(422, "\n".join(messages))
class CustomSchema(BaseSchema): id = fields.Integer(dump_only=True) tenant_uuid = fields.String(dump_only=True) interface = fields.String(validate=Regexp(INTERFACE_REGEX), required=True) interface_suffix = fields.String(validate=Length(max=32), allow_none=True) enabled = StrictBoolean() links = ListLink(Link('endpoint_custom')) trunk = Nested('TrunkSchema', only=['id', 'links'], dump_only=True) line = Nested('LineSchema', only=['id', 'links'], dump_only=True)
class PulseHamiltonianSchema(BaseSchema): """Schema for PulseHamiltonian.""" # Required properties. h_str = fields.List(fields.String(), validate=Length(min=1), required=True) dim_osc = fields.List(fields.Integer(validate=Range(min=1)), required=True) dim_qub = fields.List(fields.Integer(validate=Range(min=2)), required=True) vars = fields.Dict(validate=PatternProperties( {Regexp('^([a-z0-9])+$'): fields.InstructionParameter()}), required=True)
class PulseHamiltonianSchema(BaseSchema): """Schema for PulseHamiltonian.""" # pylint: disable=redefined-builtin # Required properties. h_str = List(String(), validate=Length(min=1), required=True) dim_osc = List(Integer(validate=Range(min=1)), required=True) dim_qub = List(Integer(validate=Range(min=2)), required=True) vars = Dict(validate=PatternProperties( {Regexp('^([a-z0-9])+$'): InstructionParameter()}), required=True)
class WizardSchema(BaseSchema): xivo_uuid = fields.UUID(dump_only=True) admin_username = fields.Constant(constant='root', dump_only=True) admin_password = fields.String(validate=Regexp(ADMIN_PASSWORD_REGEX), required=True) license = StrictBoolean(validate=Equal(True), required=True) language = fields.String(validate=OneOf(['en_US', 'fr_FR']), missing='en_US') timezone = fields.String(validate=Length(max=128), required=True) network = Nested(WizardNetworkSchema, required=True) steps = Nested(WizardStepsSchema, missing=WizardStepsSchema().load({}))
class SkillSchema(BaseSchema): id = fields.Integer(dump_only=True) tenant_uuid = fields.String(dump_only=True) name = fields.String(validate=(Regexp(NAME_REGEX), Length(max=64)), required=True) category = fields.String(validate=Length(max=64), allow_none=True) description = fields.String(allow_none=True) links = ListLink(Link('skills')) agents = fields.Nested( 'SkillAgentsSchema', attribute='agent_queue_skills', many=True, dump_only=True )
class ExperimentResultDataSchema(BaseSchema): """Schema for ExperimentResultData.""" counts = Nested(ObjSchema, validate=PatternProperties( {Regexp('^0x([0-9A-Fa-f])+$'): Integer()})) snapshots = Nested(ObjSchema) memory = List(Raw(), validate=Length(min=1)) statevector = List(Complex(), validate=Length(min=1)) unitary = List(List(Complex(), validate=Length(min=1)), validate=Length(min=1))
class SecretSchemaConf(Schema): database_connection = fields.String( required=True, validate=Regexp( "^postgresql:\/\/.*:.*@[^:]+:\w+\/\w+$", 0, """Database uri is invalid ex: postgresql://monuser:monpass@server:port/db_name""", ), ) GUNICORN_PORT = fields.Integer(missing=8080)
class CategorySchema(Schema): id = fields.Integer() name = fields.String(required=True, validate=[Length(min=1, max=32), FirstCharNotNum(), Regexp(r'[a-zA-Z0-9_]*$', error='Category name must not contain ' 'special characters (except _).') ] ) created = fields.Str() updated = fields.Str()
class UserInviteSchema(ma.SQLAlchemySchema): class Meta: model = UserModel load_instance = True id = ma.auto_field() first_name = fields.String(validate=Length(min=3)) last_name = fields.String(validate=Length(min=3)) email = fields.String(validate=Regexp( "(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]{2,}$)", error="Invalid email")) is_active = fields.Boolean(dump_only=True)
class ForwardDestinationSchema(BaseDestinationSchema): forward = fields.String(validate=OneOf( ['busy', 'noanswer', 'unconditional']), required=True) exten = fields.String(validate=Regexp(EXTEN_REGEX), allow_none=True) @pre_load def remove_invalid_white_spaces(self, data, **kwargs): exten = data.get('exten') if exten and isinstance(exten, str): data['exten'] = exten.strip() return data
class ContextSchema(BaseSchema): id = fields.Integer(dump_only=True) name = fields.String( validate=( Regexp(CONTEXT_REGEX), Length(min=1, max=39), NoneOf( [ 'authentication', 'general', 'global', 'globals', 'parkedcalls', 'xivo-features', 'zonemessages', ] ), ), required=True, ) label = fields.String(validate=Length(max=128), allow_none=True) type = fields.String( validate=OneOf(['internal', 'incall', 'outcall', 'services', 'others']) ) user_ranges = Nested(RangeSchema, many=True) group_ranges = Nested(RangeSchema, many=True) queue_ranges = Nested(RangeSchema, many=True) conference_room_ranges = Nested(RangeSchema, many=True) incall_ranges = Nested(IncallRangeSchema, many=True) description = fields.String(allow_none=True) tenant_uuid = fields.String(dump_only=True) enabled = StrictBoolean() links = ListLink(Link('contexts')) contexts = Nested( 'ContextSchema', only=['id', 'name', 'label', 'links'], many=True, dump_only=True, ) @post_load def create_objects(self, data, **kwargs): for key in [ 'user_ranges', 'group_ranges', 'queue_ranges', 'conference_room_ranges', 'incall_ranges', ]: if data.get(key): data[key] = [ContextNumbers(**d) for d in data[key]] return data
class IAXSchema(BaseSchema): id = fields.Integer(dump_only=True) tenant_uuid = fields.String(dump_only=True) name = fields.String(validate=Regexp(NAME_REGEX)) type = fields.String(validate=OneOf(['friend', 'peer', 'user'])) host = fields.String(validate=Length(max=255)) options = fields.List(fields.List(fields.String(), validate=Length(equal=2))) links = ListLink(Link('endpoint_iax')) trunk = fields.Nested( 'TrunkSchema', only=['id', 'links'], dump_only=True, attribute='trunk_rel' )
class UserSchema(Schema): username = fields.Str(required=True, validate=[ Length(min=4, max=32), Regexp(r'[a-zA-Z0-9_]*$', error='Username must not contain ' 'special characters (except _).'), FirstCharNotNum() ]) password = fields.Str(required=True, validate=Length(min=4, max=32)) created = fields.Str() updated = fields.Str()
class AccountTypeSchema(ma.Schema): """Adding the Schema validations to the AccountType """ account_type = fields.String(required=True, validate=(Length(max=20), Regexp(name_string))) class Meta: """ Exposed fields """ fields = ('id', 'account_type') load_instance = True
class AccountSchema(BaseSchema): username = fields.Str(required=True, validate=[ Range( min=USERNAME_MIN, max=USERNAME_MAX, error='Got: {input} as input, should be between {min} - {max}.' ), Regexp(regex=USERNAME_REGEX, error="'{input}' not matching to '{regex}'") ]) password = fields.Str(required=True, validate=[ Range( min=USERNAME_MIN, max=USERNAME_MAX, error='Got: {input} as input, should be between {min} - {max}.' ), Regexp(regex=PASSWORD_REGEX, error="'{input}' not matching to '{regex}'") ]) firstName = fields.Str(required=True, validate=[ Range( min=FIRSTNAME_MIN, max=FIRSTNAME_MAX, error='Got: {input} as input, should be between {min} - {max}.' ), Regexp(regex=FIRSTNAME_REGEX, error="'{input}' not matching to '{regex}'") ]) lastName = fields.Str(required=True, validate=[ Range( min=LASTNAME_MIN, max=LASTNAME_MAX, error='Got: {input} as input, should be between {min} - {max}.' ), Regexp(regex=LASTNAME_REGEX, error="'{input}' not matching to '{regex}'") ]) email = fields.Email(required=True, error='Email not valid') dateOfBirth = fields.Date(required=True, error='Not valid date. Provide ISO8601-formatted date string.') acceptTermsOfService = fields.Bool(required=True, validate=[ContainsOnly(choices='True')])
class BackendPropertiesSchema(BaseSchema): """Schema for BackendProperties.""" # Required properties. backend_name = String(required=True) backend_version = String(required=True, validate=Regexp("[0-9]+.[0-9]+.[0-9]+$")) last_update_date = DateTime(required=True) qubits = List(Nested(NduvSchema, many=True), required=True, validate=Length(min=1)) gates = Nested(GateSchema, required=True, many=True) general = Nested(NduvSchema, required=True, many=True)
class PatientSchema(Schema): id = fields.Integer(dump_only=True) ssn = fields.Integer(required=True, validate=ssn, load_only=True) name = fields.String(required=True, validate=Regexp( regex=r'^[a-zA-Z ]+$', error="Name must conatin only alphabets")) age = fields.Integer(required=True, validate=age) admited_on = fields.DateTime() type_of_bed = fields.String(required=True) address = fields.String(required=True) state = fields.String(required=True, validate=Regexp( regex=r'^[a-zA-Z ]+$', error="State must conatin only alphabets")) city = fields.String(required=True, validate=Regexp( regex=r'^[a-zA-Z ]+$', error="City must conatin only alphabets")) discharged = fields.Boolean() medicines = fields.Nested(MedicineSchema, many=True) diagnostics = fields.Nested(DiagnosticsSchema, many=True)
class NoticeSchema(Schema): id = String(required=True, validate=Regexp(r"(USN|LSN)-\d{1,5}-\d{1,2}")) title = String(required=True) summary = String(required=True) instructions = String(required=True) references = List(String()) published = ParsedDateTime(required=True) details = String(allow_none=True, data_key="description") is_hidden = Boolean(required=False) release_packages = Dict( keys=ReleaseCodename(), values=List(Nested(NoticePackage), required=True), )