class ReportSchemaBase(colander.MappingSchema):
"""
Validates format of report group
"""
client = colander.SchemaNode(colander.String(),
preparer=lambda x: x or 'unknown')
server = colander.SchemaNode(colander.String(),
preparer=[
lambda x: x.lower() if x else 'unknown',
shortener_factory(128)
],
missing='unknown')
priority = colander.SchemaNode(colander.Int(),
preparer=[lambda x: x or 5],
validator=colander.Range(1, 10),
missing=5)
language = colander.SchemaNode(colander.String(), missing='unknown')
error = colander.SchemaNode(colander.String(),
preparer=shortener_factory(512),
missing='')
view_name = colander.SchemaNode(
colander.String(),
preparer=[shortener_factory(128), lambda x: x or ''],
missing='')
http_status = colander.SchemaNode(colander.Int(),
preparer=[lambda x: x or 200],
validator=colander.Range(1))
occurences = colander.SchemaNode(colander.Int(),
validator=colander.Range(1, 99999999999),
missing=1)
tags = TagSchemaList()
class querystring(colander.MappingSchema):
query = colander.SchemaNode(colander.String(),
missing=colander.drop)
filter_type = colander.SchemaNode(colander.String(),
missing=colander.drop)
start_date = colander.SchemaNode(colander.Date(), missing=None)
end_date = colander.SchemaNode(colander.Date(), missing=None)
contributor_person_id = colander.SchemaNode(colander.Integer(),
missing=colander.drop)
contributor_group_id = colander.SchemaNode(colander.Integer(),
missing=colander.drop)
affiliation_group_id = colander.SchemaNode(colander.Integer(),
missing=colander.drop)
related_work_id = colander.SchemaNode(colander.Integer(),
missing=colander.drop)
offset = colander.SchemaNode(colander.Int(),
default=0,
validator=colander.Range(min=0),
missing=0)
limit = colander.SchemaNode(colander.Int(),
default=20,
validator=colander.Range(0, 100),
missing=20)
format = colander.SchemaNode(
colander.String(),
validator=colander.OneOf(['snippet', 'csl']),
missing=colander.drop)
class Geolocation(colander.MappingSchema):
lon = colander.SchemaNode(colander.Float(),
validator=colander.Range(-180, 180),
missing=TOKYO_GEOLOCATION['lon'])
lat = colander.SchemaNode(colander.Float(),
validator=colander.Range(-90, 90),
missing=TOKYO_GEOLOCATION['lat'])
class TriangleSchema(colander.Schema):
a = colander.SchemaNode(colander.Float(),
validator=colander.Range(
min=0, min_err='Side length must be positive'),
default=5)
b = colander.SchemaNode(colander.Float(),
validator=colander.Range(
min=0, min_err='Side length must be positive'),
default=5)
theta = colander.SchemaNode(
colander.Float(),
validator=colander.Range(
min=0,
max=180,
min_err='Angle must be positive',
max_err='Angle must be less than 180 degrees'),
default=45)
label_a = colander.SchemaNode(colander.String(), missing='')
label_b = colander.SchemaNode(colander.String(), missing='')
label_c = colander.SchemaNode(colander.String(), missing='')
label_angle_A = colander.SchemaNode(colander.String(), missing='')
label_angle_B = colander.SchemaNode(colander.String(), missing='')
label_angle_C = colander.SchemaNode(colander.String(), missing='')
show_angle_A = colander.SchemaNode(
colander.Bool(),
widget=FancyCheckboxInput(label='Render Angle (A)'),
default=True)
show_angle_B = colander.SchemaNode(
colander.Bool(),
widget=FancyCheckboxInput(label='Render Angle (B)'),
default=True)
show_angle_C = colander.SchemaNode(
colander.Bool(),
widget=FancyCheckboxInput(label='Render Angle (C)'),
default=True)
def _addAnnotateSchema(self, schema):
schema.add(colander.SchemaNode(colander.Float(),
missing=0.0,
name='ms_intensity_cutoff'))
schema.add(colander.SchemaNode(colander.Float(),
missing=0.0,
name='msms_intensity_cutoff'))
schema.add(colander.SchemaNode(colander.Integer(),
validator=colander.Range(0, 4),
name='max_broken_bonds'))
schema.add(colander.SchemaNode(colander.Integer(),
validator=colander.Range(0, 4),
name='max_water_losses'))
schema.add(colander.SchemaNode(colander.String(),
missing=colander.null,
validator=colander.OneOf(['pubchem',
'kegg',
'hmdb',
]),
name='structure_database'
))
schema.add(colander.SchemaNode(colander.Integer(),
missing=colander.null,
validator=colander.Range(min=1),
name='min_refscore'))
schema.add(colander.SchemaNode(colander.Integer(),
missing=colander.null,
validator=colander.Range(min=1),
name='max_mz'))
schema.add(colander.SchemaNode(colander.Boolean(),
missing=False,
name='excl_halo'))
schema.add(colander.SchemaNode(self.File(),
missing=colander.null,
name='ids_file'))
class SaveCommentSchema(CSRFProtectedSchema, colander.MappingSchema):
"""An API schema for bodhi.server.services.comments.new_comment()."""
def deserialize(self, cstruct):
"""Unflatten comment before parsing into Schema."""
appstruct = SaveCommentSchema().unflatten(cstruct)
return super(SaveCommentSchema, self).deserialize(appstruct)
update = colander.SchemaNode(colander.String())
text = colander.SchemaNode(
colander.String(),
missing='',
)
karma = colander.SchemaNode(
colander.Integer(),
validator=colander.Range(min=-1, max=1),
missing=0,
)
karma_critpath = colander.SchemaNode(
colander.Integer(),
validator=colander.Range(min=-1, max=1),
missing=0,
)
bug_feedback = BugFeedbacks(missing=[])
testcase_feedback = TestcaseFeedbacks(missing=[])
class querystring(colander.MappingSchema):
offset = colander.SchemaNode(colander.Int(),
default=0,
validator=colander.Range(min=0),
missing=0)
limit = colander.SchemaNode(colander.Int(),
default=20,
validator=colander.Range(0, 100),
missing=20)
query = colander.SchemaNode(colander.String(),
missing=colander.drop)
person_id = colander.SchemaNode(colander.Int(),
missing=colander.drop)
group_id = colander.SchemaNode(colander.Int(),
missing=colander.drop)
transitive = colander.SchemaNode(colander.Boolean(),
missing=False)
start_date = colander.SchemaNode(colander.Date(),
missing=colander.drop)
end_date = colander.SchemaNode(colander.Date(),
missing=colander.drop)
format = colander.SchemaNode(
colander.String(),
validator=colander.OneOf(['record', 'snippet']),
missing=colander.drop)
class UpdateRecurringSchema(colander.MappingSchema):
name = colander.SchemaNode(colander.String(),
validator=colander.Length(max=60),
missing=colander.drop)
amount = colander.SchemaNode(colander.Decimal('0.01'),
validator=colander.Range(0, 20000),
required=True)
start_date = colander.SchemaNode(colander.Date(),
missing=today)
trial_amount = colander.SchemaNode(colander.Decimal('0.01'),
validator=colander.Range(0, 20000),
missing=colander.drop)
total_occurrences = colander.SchemaNode(colander.Integer(),
validator=colander.Range(1, 9999),
missing=9999)
trial_occurrences = colander.SchemaNode(colander.Integer(),
validator=colander.Range(1, 99),
missing=colander.drop)
credit_card = CreditCardSchema(validator=CreditCardSchema.validator,
missing=colander.drop)
bank_account = BankAccountSchema(validator=BankAccountSchema.validator,
missing=colander.drop)
customer = CustomerBaseSchema(missing=colander.drop)
order = OrderSchema(missing=colander.drop)
billing = AddressSchema(missing=colander.drop)
shipping = AddressSchema(missing=colander.drop)
class PagingSchema(colander.MappingSchema):
limit = colander.SchemaNode(colander.Integer(),
validator=colander.Range(1, 1000),
missing=100)
offset = colander.SchemaNode(colander.Integer(),
validator=colander.Range(1, 100000),
missing=1)
class NewtonParametersSchema(StrictMappingSchema):
"""Parameters for the newton optimizer.
See :class:`moe.optimal_learning.python.cpp_wrappers.optimization.NewtonParameters`
"""
max_num_steps = colander.SchemaNode(
colander.Int(),
validator=colander.Range(min=1),
)
gamma = colander.SchemaNode(
colander.Float(),
validator=colander.Range(min=1.0),
)
time_factor = colander.SchemaNode(
colander.Float(),
validator=colander.Range(min=1.0e-16),
)
max_relative_change = colander.SchemaNode(
colander.Float(),
validator=colander.Range(min=0.0, max=1.0),
)
tolerance = colander.SchemaNode(
colander.Float(),
validator=colander.Range(min=0.0),
)
class LBFGSBParametersSchema(StrictMappingSchema):
"""Parameters for the L-BFGS-B optimizer.
See :class:`moe.optimal_learning.python.python_version.optimization.LBFGSBParameters`
"""
approx_grad = colander.SchemaNode(
colander.Boolean(),
)
max_func_evals = colander.SchemaNode(
colander.Int(),
validator=colander.Range(min=1),
)
max_metric_correc = colander.SchemaNode(
colander.Int(),
validator=colander.Range(min=1),
)
factr = colander.SchemaNode(
colander.Float(),
validator=colander.Range(min=1.0),
)
pgtol = colander.SchemaNode(
colander.Float(),
validator=colander.Range(min=0.0),
)
epsilon = colander.SchemaNode(
colander.Float(),
validator=colander.Range(min=0.0),
)
class SaveCommentSchema(CSRFProtectedSchema, colander.MappingSchema):
"""An API schema for bodhi.server.services.comments.new_comment()."""
update = colander.SchemaNode(colander.String())
text = colander.SchemaNode(
colander.String(),
missing='',
)
karma = colander.SchemaNode(
colander.Integer(),
validator=colander.Range(min=-1, max=1),
missing=0,
)
karma_critpath = colander.SchemaNode(
colander.Integer(),
validator=colander.Range(min=-1, max=1),
missing=0,
)
bug_feedback = BugFeedbacks(missing=[])
testcase_feedback = TestcaseFeedbacks(missing=[])
# Optional
captcha_key = colander.SchemaNode(colander.String(), missing=None)
captcha_value = colander.SchemaNode(colander.String(), missing=None)
email = colander.SchemaNode(
colander.String(),
validator=colander.Email(),
missing=None,
)
class querystring(colander.MappingSchema):
offset = colander.SchemaNode(colander.Int(),
default=0,
validator=colander.Range(min=0),
missing=0)
limit = colander.SchemaNode(colander.Int(),
default=20,
validator=colander.Range(0, 100),
missing=20)
class Passport(c.MappingSchema):
byr = c.SchemaNode(c.Int(), validator=c.Range(min=1920, max=2002))
iyr = c.SchemaNode(c.Int(), validator=c.Range(min=2010, max=2020))
eyr = c.SchemaNode(c.Int(), validator=c.Range(min=2020, max=2030))
hgt = c.SchemaNode(c.String(), validator=height_validator)
hcl = c.SchemaNode(c.String(), validator=c.Regex(r"^#[0-9a-f]{6}$"))
ecl = c.SchemaNode(c.String(),
validator=c.OneOf(
["amb", "blu", "brn", "gry", "grn", "hzl", "oth"]))
pid = c.SchemaNode(c.String(), validator=c.Regex(r"^\d{9}$"))
class ValidWifiLookupSchema(colander.MappingSchema, ValidatorNode):
"""A schema which validates the fields in a WiFi lookup."""
macAddress = MacNode(colander.String())
ssid = DefaultNode(colander.String(), missing=None)
age = DefaultNode(
colander.Integer(),
missing=None,
validator=colander.Range(constants.MIN_AGE, constants.MAX_AGE),
)
channel = DefaultNode(
colander.Integer(),
missing=None,
validator=colander.Range(constants.MIN_WIFI_CHANNEL,
constants.MAX_WIFI_CHANNEL),
)
frequency = DefaultNode(
colander.Integer(),
missing=None,
validator=colander.Range(constants.MIN_WIFI_FREQUENCY,
constants.MAX_WIFI_FREQUENCY),
)
signalStrength = DefaultNode(
colander.Integer(),
missing=None,
validator=colander.Range(constants.MIN_WIFI_SIGNAL,
constants.MAX_WIFI_SIGNAL),
)
signalToNoiseRatio = DefaultNode(
colander.Integer(),
missing=None,
validator=colander.Range(constants.MIN_WIFI_SNR,
constants.MAX_WIFI_SNR),
)
def deserialize(self, data):
data = super(ValidWifiLookupSchema, self).deserialize(data)
if data and data is not colander.drop and data is not colander.null:
channel = data.get("channel")
frequency = data.get("frequency")
if (frequency is None
and channel is not None) or (frequency is not None
and channel is None):
# shallow copy
data = dict(data)
data["channel"], data["frequency"] = channel_frequency(
channel, frequency)
return data
class ValidPositionSchema(colander.MappingSchema, ValidatorNode):
"""A schema which validates the fields present in a position."""
lat = colander.SchemaNode(colander.Float(),
missing=None,
validator=colander.Range(constants.MIN_LAT,
constants.MAX_LAT))
lon = colander.SchemaNode(colander.Float(),
missing=None,
validator=colander.Range(constants.MIN_LON,
constants.MAX_LON))
class ValidCellAreaKeySchema(FieldSchema, CopyingSchema):
"""A schema which validates the fields present in a cell area key."""
radio = RadioNode(RadioType())
mcc = colander.SchemaNode(colander.Integer(),
validator=colander.Range(1, 999))
mnc = colander.SchemaNode(colander.Integer(),
validator=colander.Range(0, 32767))
lac = DefaultNode(colander.Integer(),
missing=0,
validator=colander.Range(constants.MIN_LAC,
constants.MAX_LAC_ALL))
class RouteView(colander.MappingSchema):
name = colander.SchemaNode(colander.String(),
title="Название:",
validator=colander.Length(max=50))
distance = colander.SchemaNode(colander.Float(),
title="Расстояние (км):",
validator=colander.Range(0, 10000))
base_price = colander.SchemaNode(colander.Float(),
title="Стоимость (грн):",
validator=colander.Range(0, 1000000))
class RetailSchema(colander.MappingSchema):
market_type = colander.SchemaNode(colander.Integer(),
validator=colander.Range(1, 9),
required=True)
device_type = colander.SchemaNode(colander.Integer(),
validator=colander.Range(1, 9),
required=True)
@staticmethod
def validator(node, kw):
kw['market_type'] = kw.get('market_type', 2)
kw['device_type'] = kw.get('device_type', 7)
class ValidWifiSignalSchema(colander.MappingSchema, ValidatorNode):
"""
A schema which validates the fields related to wifi signal
strength and quality.
"""
age = DefaultNode(colander.Integer(),
missing=None,
validator=colander.Range(constants.MIN_AGE,
constants.MAX_AGE))
channel = DefaultNode(colander.Integer(),
missing=None,
validator=colander.Range(constants.MIN_WIFI_CHANNEL,
constants.MAX_WIFI_CHANNEL))
signal = DefaultNode(colander.Integer(),
missing=None,
validator=colander.Range(constants.MIN_WIFI_SIGNAL,
constants.MAX_WIFI_SIGNAL))
snr = DefaultNode(colander.Integer(),
missing=None,
validator=colander.Range(0, 100))
def deserialize(self, data):
if data:
channel = data.get('channel')
channel = channel is not None and int(channel) or None
if (channel is None or not (constants.MIN_WIFI_CHANNEL < channel <
constants.MAX_WIFI_CHANNEL)):
# shallow copy
data = dict(data)
# if no explicit channel was given, calculate
freq = data.get('frequency', None)
if freq is None:
freq = 0
if 2411 < freq < 2473:
# 2.4 GHz band
data['channel'] = (freq - 2407) // 5
elif freq == 2484:
data['channel'] = 14
elif 5169 < freq < 5826:
# 5 GHz band
data['channel'] = (freq - 5000) // 5
else:
data['channel'] = None
return super(ValidWifiSignalSchema, self).deserialize(data)
class AdminUserVariables(colander.MappingSchema):
nav_tree_pagesize = colander.SchemaNode(colander.Integer(),
default=10,
missing=10,
title=_('Navigation tree page size:'),
validator=colander.Range(1, 200))
policies_pagesize = colander.SchemaNode(colander.Integer(),
default=8,
missing=8,
title=_('Policies list page size:'),
validator=colander.Range(1, 200))
jobs_pagesize = colander.SchemaNode(colander.Integer(),
default=30,
missing=30,
title=_('Actions list page size:'),
validator=colander.Range(1, 200))
group_nodes_pagesize = colander.SchemaNode(colander.Integer(),
default=10,
missing=10,
title=_('Group nodes list page size:'),
validator=colander.Range(1, 200))
uri_ntp = colander.SchemaNode(colander.String(),
default='URI_NTP_SERVER.EX',
title=_('URI ntp'))
auth_type = colander.SchemaNode(colander.String(),
title=_('Auth type'),
default='LDAP',
widget=deform.widget.SelectWidget(values=AUTH_TYPE_CHOICES))
specific_conf = colander.SchemaNode(colander.Boolean(),
title=_('Specific conf'),
default=False)
auth_ldap = AuthLDAPVariable(title=_('Auth LDAP'))
auth_ad = ActiveDirectoryVariableNoSpecific(title=_('Auth Active directory'))
auth_ad_spec = ActiveDirectoryVariableSpecific(title=_('Auth Active directory'))
gem_repos = GemRepositories(title=_('Gem Repositories'),
missing=[],
default=[],
validator=UniqueDomainValidator())
def get_config_files(self, mode, username):
return self.get_files(mode, username, ['sssd.conf', 'krb5.conf', 'smb.conf', 'pam.conf'])
def get_files(self, mode, username, file_name):
settings = get_current_registry().settings
first_boot_media = settings.get('firstboot_api.media')
user_media = os.path.join(first_boot_media, username)
if mode == 'w' and not os.path.exists(user_media):
os.makedirs(user_media)
if isinstance(file_name, list):
files = [open(os.path.join(user_media, name), mode) for name in file_name]
return files
return open(os.path.join(user_media, file_name), mode)
class ValidBlueReportSchema(colander.MappingSchema, ValidatorNode):
"""A schema which validates the Bluetooth specific fields in a report."""
mac = MacNode(colander.String())
age = DefaultNode(colander.Integer(),
missing=None,
validator=colander.Range(constants.MIN_AGE,
constants.MAX_AGE))
signal = DefaultNode(colander.Integer(),
missing=None,
validator=colander.Range(constants.MIN_BLUE_SIGNAL,
constants.MAX_BLUE_SIGNAL))
class querystring(colander.MappingSchema):
query = colander.SchemaNode(colander.String(), missing=colander.drop)
offset = colander.SchemaNode(colander.Int(),
default=0,
validator=colander.Range(min=0),
missing=0)
limit = colander.SchemaNode(colander.Int(),
default=20,
validator=colander.Range(0, 100),
missing=20)
format = colander.SchemaNode(colander.String(),
validator=colander.OneOf(
['record', 'snippet']),
missing=colander.drop)
class SearchRequestSchema(colander.MappingSchema):
"""Validates search query parameters."""
lat = colander.SchemaNode(colander.Float(),
missing=37.7860099,
validator=colander.Range(-90, 90))
lng = colander.SchemaNode(colander.Float(),
missing=-122.4025387,
validator=colander.Range(-180, 180))
type = colander.SchemaNode(colander.String(),
missing="bike",
validator=colander.OneOf(
['bike', 'film', 'food']))
class LightSchema(colander.MappingSchema):
id = colander.SchemaNode(colander.String())
name = colander.SchemaNode(colander.String())
hue = colander.SchemaNode(
colander.Integer(),
validator=colander.Range(0, 360)
)
brightness = colander.SchemaNode(
colander.Integer(),
validator=colander.Range(1, 100)
)
state = colander.SchemaNode(
colander.Boolean()
)
class ValidCellKeySchema(ValidCellAreaKeySchema):
cid = DefaultNode(
colander.Integer(),
missing=None,
validator=colander.Range(constants.MIN_CID, constants.MAX_CID),
)
psc = DefaultNode(
colander.Integer(),
missing=None,
validator=colander.Range(constants.MIN_PSC, constants.MAX_PSC),
)
def __init__(self, *args, **kw):
super(ValidCellKeySchema, self).__init__(*args, **kw)
self.radio_node = self.get("radio")
def deserialize(self, data):
if data:
# shallow copy
data = dict(data)
# deserialize and validate radio field early
data["radio"] = self.radio_node.deserialize(
data.get("radio", colander.null)
)
# If the cell id > 65535 then it must be a WCDMA tower
if (
data["radio"] is Radio["gsm"]
and data.get("cid") is not None
and data.get("cid", 0) > constants.MAX_CID_GSM
):
data["radio"] = Radio["wcdma"]
if (
data["radio"] is Radio["lte"]
and data.get("psc") is not None
and data.get("psc", 0) > constants.MAX_PSC_LTE
):
data["psc"] = None
return super(ValidCellKeySchema, self).deserialize(data)
def validator(self, node, cstruct):
super(ValidCellKeySchema, self).validator(node, cstruct)
if (cstruct.get("lac") is None or cstruct.get("cid") is None) and cstruct.get(
"psc"
) is None:
raise colander.Invalid(node, ("Must have (LAC and CID) or PSC."))
class CreditCardSchema(colander.MappingSchema):
card_number = colander.SchemaNode(colander.String(),
validator=colander.luhnok,
requird=True)
expiration_month = colander.SchemaNode(colander.Integer(),
validator=colander.Range(1, 12),
missing=None)
expiration_year = colander.SchemaNode(colander.Integer(),
validator=colander.Range(
date.today().year,
date.today().year + 7),
missing=None)
expiration_date = colander.SchemaNode(
colander.String(),
validator=colander.Regex(r'^\d{2}.?(?:\d{4}|\d{2})?$',
'The expiration date is invalid'),
missing=None)
card_code = colander.SchemaNode(colander.String(),
validator=colander.Regex(
r'^[0-9]{3,4}$',
'The card code is invalid'),
missing=colander.drop)
@staticmethod
def validator(node, kw):
exp_year = kw['expiration_year']
exp_month = kw['expiration_month']
exp_date = kw['expiration_date']
# We only need exp_date or exp_year and exp_month
if exp_date is None and (exp_year is None and exp_month is None):
raise colander.Invalid(node,
'You must provide a card expiration date')
if exp_date is not None:
exp_month = exp_date[:2]
exp_year = '20' + exp_date[-2:]
elif exp_month is None:
raise colander.Invalid(node,
'You must provide a card expiration month')
elif exp_year is None:
raise colander.Invalid(node,
'You must provide a card expiration year')
today = date.today()
if exp_year == today.year and exp_month < today.month:
raise colander.Invalid(node, 'The credit card has expired')
kw['expiration_year'] = str(exp_year)
kw['expiration_month'] = str(exp_month).zfill(2)
class GetEmbeddedSchema(GetResourceSchema):
"""This schema can be used to get pagination parameters based on offset of page start."""
embedded = BooleanNode(title='Include an embedded resources', missing=True)
offset = IntegerNode(
title='Offset',
description='Offset from the start of children resources.',
default=0, missing=0,
validator=colander.Range(min=0),
)
limit = IntegerNode(
title='Limit',
preparer=prepare_limit, missing=missing_limit,
validator=colander.Range(min=0),
)
total_count = BooleanNode(title='Calculate total count', missing=False)
class CreateRecurringSchema(UpdateRecurringSchema):
interval_length = colander.SchemaNode(colander.Integer(),
validator=colander.Range(1, 999),
required=True)
interval_unit = colander.SchemaNode(colander.String(),
validator=colander.OneOf(['days', 'months']),
required=True)
start_date = colander.SchemaNode(colander.Date(),
missing=today)
total_occurrences = colander.SchemaNode(colander.Integer(),
validator=colander.Range(1, 9999),
missing=9999)
amount = colander.SchemaNode(colander.Decimal('0.01'),
validator=colander.Range(0, 20000),
required=True)
class ValidBlueSignalSchema(colander.MappingSchema, ValidatorNode):
"""
A schema which validates the fields related to Bluetooth signal
strength and quality.
"""
age = DefaultNode(colander.Integer(),
missing=None,
validator=colander.Range(constants.MIN_AGE,
constants.MAX_AGE))
signal = DefaultNode(colander.Integer(),
missing=None,
validator=colander.Range(constants.MIN_BLUE_SIGNAL,
constants.MAX_BLUE_SIGNAL))
