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),
)
