class BaseDetection(Validator):
"""
General validator for a single detection (Ship/Plane)
"""
url_regex = r'https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_\+.~#?&//=]*)'
storage_regex = r'(gs|s3)?://[-a-zA-Z0-9@:%._\+~#=]{2,256}/([\w\+~#=-]*/)*'
unique_parameters = {
'_id': Or(str, Use(int)),
'collection': Or("ships", "buildings", "roads", "vegetation", "planes", "changes", error="analyticsInfo: unknowen collection name"),
'company': Or("Planet", "OrbitalInsight", "SpaceKnow", "RadiantSolutions", error="analyticsInfo: unknown company name"),
'observed_start': datetime,
'observed_end': datetime,
'creation_time': datetime,
'update_time': datetime,
Optional('tile_id'): {
"row": Or(str, Use(int)),
"col": Or(str, Use(int)),
Optional("utm_zone"): Or(str, Use(int)),
"full_id": str
},
Optional('score'): And(Use(float), lambda s: 0 <= s <= 1,error="score: should be between 0-1"),
Optional('linkToSourceObject'): {
"url": Or(Regex(url_regex), Regex(storage_regex), error="analyticsInfo: invalid url"),
"storage": Or("Azure", "AWS", "GoogleCloud", "Planet", error="analyticsInfo: unknown storage type")
}
}
@staticmethod
def compose_schema(schema):
schema.update(BaseDetection.unique_parameters)
return schema
def __init__(self, item, schema = {}):
super().__init__(item, BaseDetection.compose_schema(schema))
def validate_layout_schema(layout):
schema = Schema(
{
# leave `kubernetes` for legacy reasons
Optional('kubernetes'): {
'api-servers-url': str,
'dashboard-url': str,
},
'machine-sku': {
str: {
'mem': str,
'cpu': {
'vcore': int,
},
Optional('computing-device'): {
'type': str,
'model': str,
'count': int,
}
}
},
'machine-list': [
{
# https://github.com/kubernetes-sigs/kubespray/blob/release-2.11/roles/kubernetes/preinstall/tasks/0020-verify-settings.yml#L124
'hostname': Regex(r"^[a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*$"),
'hostip': Regex(r"^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$"),
'machine-type': str,
Optional('prophet-master'): Or('true', 'false'),
Optional('prophet-worker'): Or('true', 'false'),
Optional('prophet-storage'): Or('true', 'false'),
}
]
}
)
return schema.validate(layout)
def test_dict_complexity():
count = 0
class MySchema(Schema):
def validate (self, *k, **w):
nonlocal count
count += 1
return super(MySchema, self).validate(*k, **w)
s = {MySchema(i): i+1 for i in range(10)}
s[int] = MySchema(str)
s = Schema(s)
d = {i: i+1 for i in range(10)}
d[11] = 'end'
assert s.validate(d) == d
assert count == 11
count = 0
s = Dict({
MySchema(Regex(r'^[a-z]+$')): 1,
MySchema(Regex(r'^[0-9]+$')): 2,
MySchema(int): 3,
MySchema(float): 4,
MySchema(Any()): 5,
})
d = {'a': 1, '2': 2, 3: 3, 4.0: 4, None: 5}
assert s.validate(d) == d
assert count == 6
def validate_schema(advisory_dict):
deb_versions = [
"bullseye",
"buster",
"buster-security",
"sid",
"stretch",
"stretch-security",
"jessie",
"jessie-security",
]
scheme = {
str: {
Or(Regex(r"CVE-\d+-\d+"), Regex(r"TEMP-.+-.+")): {
"releases": {
Or(*deb_versions): {
"repositories": {Or(*deb_versions): str},
"status": str,
"urgency": str,
Optional("fixed_version"): str,
Optional(str): object,
}
},
Optional("description"): str,
Optional("debianbug"): int,
Optional(str): object,
}
}
}
Schema(scheme).validate(advisory_dict)
class BaseMap(BaseDetection):
"""
General validator for a raster item (Buildings, Roads, Vegetation)
"""
unique_parameters = {
'geometry': {
'coordinates': list,
'type': Or("Point", "Polygon", "MultiPolygon", "MultiPoint", error="geometry type error")
},
Optional('sourceImagesInfo'): {
"url": Or(Regex(BaseDetection.url_regex), Regex(BaseDetection.storage_regex), error="sourceImagesInfo: invalid url"),
"storage": Or("Azure", "AWS", "GoogleCloud", error="sourceImagesInfo: unknown storage type")
},
Optional('sourceImagesIds'): And(list, lambda ids: is_list_of_strings(ids), error="sourceImagesIds: should be a list")
}
def __init__(self, item, schema = {}):
super().__init__(item, BaseMap.compose_schema(schema))
@staticmethod
def compose_schema(schema):
schema.update(BaseMap.unique_parameters)
return schema
def validate_schema(advisory_dict):
scheme = {
"distroversion":
Regex(r"v\d.\d*"),
"reponame":
str,
"archs":
list,
"packages": [{
"pkg": {
"name": str,
"secfixes": {
str:
Or(
[
Or(
Regex(r"CVE.\d+-\d+"),
Regex(r"XSA-\d{3}"),
Regex(r"ZBX-\d{4}"),
Regex(r"wnpa-sec-\d{4}-\d{2}"),
)
],
"",
# FIXME: Remove the None when below issue gets fixed
# https://gitlab.alpinelinux.org/alpine/infra/alpine-secdb/-/issues/1
None,
),
},
}
}],
object:
object,
}
Schema(scheme).validate(advisory_dict)
def validate_args(args):
"""Validate the input parameters."""
schema = Schema({
'--ip': And(str, Regex(r'^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$'), error="Invalid input for `--ip`. Please enter a valid IP address. Example: `127.0.0.1`."),
'--port': And(Use(int), lambda x: 1024 <= x <= 65535, error="Invalid input for `--port`. Please enter a number between 1024 and 65535."),
'--date': Or(None, And(str, Regex(r'^\s*(3[01]|[12][0-9]|0?[1-9])\.(1[012]|0?[1-9])\.((?:19|20)\d{2})\s*$')), error="Invalid input for `--date`. Please enter a valid date. Example: `01.01.2020`."),
'--order-date': Or(None, And(str, Regex(r'^\s*(3[01]|[12][0-9]|0?[1-9])\.(1[012]|0?[1-9])\.((?:19|20)\d{2})\s*$')), error="Invalid input for `--order-date`. Please enter a valid date. Example: `01.01.2020`."),
'--event-date': Or(None, And(str, Regex(r'^\s*(3[01]|[12][0-9]|0?[1-9])\.(1[012]|0?[1-9])\.((?:19|20)\d{2})\s*$')), error="Invalid input for `--event-date`. Please enter a valid date. Example: `01.01.2020`."),
'--quantity': Or(None, And(Use(int)), error="Invalid input for `--quantity`. Please enter an integer number. Example: `3`."),
'--name': Or(None, And(Use(str))),
'--location': Or(None, And(str, Regex(r'^([^0-9]+) ([0-9]+.*?), ([0-9]{5}) (.*)$')), error="Invalid input for `--location`. Please enter a valid address. Example: `Friedrich Ebert Straße 30, 78054 Villingen-Schwenningen`."),
'--address': Or(None, And(str, Regex(r'^([^0-9]+) ([0-9]+.*?), ([0-9]{5}) (.*)$')), error="Invalid input for `--address`. Please enter a valid address. Example: `Friedrich Ebert Straße 30, 78054 Villingen-Schwenningen`."),
'--ticket-price': Or(None, And(Use(str), Regex(r'^\s*(?=.*[1-9])\d*(?:\.\d{1,2})?\s*$')), error="Invalid input for `--ticket-price`. Please enter a valid amount of money. Example: `5.60`."),
'--max-tickets': Or(None, And(Use(int)), error="Invalid input for `--max-tickets`. Please enter an integer number. Example: `3`."),
'--max-tickets-per-customer': Or(None, And(Use(int)), error="Invalid input for `--max-tickets-per-customer`. Please enter an integer number. Example: `3`."),
'--sale-start-date': Or(None, And(str, Regex(r'^\s*(3[01]|[12][0-9]|0?[1-9])\.(1[012]|0?[1-9])\.((?:19|20)\d{2})\s*$')), error="Invalid input for `--sale-start-date`. Please enter a valid date. Example: `01.01.2020`."),
'--sale-period': Or(None, And(Use(int)), error="Invalid input for `--sale-period`. Please enter the number of days as an integer number. Example: `3`."),
'--budget': Or(None, And(Use(str), Regex(r'^\s*(?=.*[1-9])\d*(?:\.\d{1,2})?\s*$')), error="Invalid input for `--budget`. Please enter a valid amount of money. Example: `5.60`."),
'<event-id>': Or(None, And(Use(int)), error="Invalid input for `<event-id>`. The event ID can only be an integer number. Example: `3`."),
'<customer-id>': Or(None, And(Use(int)), error="Invalid input for `<customer-id>`. The customer ID can only be an integer number. Example: `3`."),
'--year': Or(None, And(Use(int)), error="Invalid input for `--year`. Please enter an integer number. Example: `2020`.")
})
if args.get('--date') is not None and args.get('--sale-start-date') is not None:
event_date = DateHelper.date_to_timestamp(args.get('--date'))
sale_start_date = DateHelper.date_to_timestamp(
args.get('--sale-start-date'))
if sale_start_date > event_date:
raise SchemaError(
None, errors="Invalid input for `--date` or `--sale-start-date`. The event date cannot be earlier than the start date of the sale. Please check your input.")
try:
schema.validate(args)
except SchemaWrongKeyError as ex:
pass
except SchemaError as ex:
sys.exit(ex)
def get_event_schema() -> dict:
"""
Returns the schema for a DHIS2 Event.
>>> event = {
... "program": "eBAyeGv0exc",
... "orgUnit": "DiszpKrYNg8",
... "eventDate": "2013-05-17",
... "status": "COMPLETED",
... "completedDate": "2013-05-18",
... "storedBy": "admin",
... "coordinate": {
... "latitude": 59.8,
... "longitude": 10.9
... },
... "dataValues": [
... { "dataElement": "qrur9Dvnyt5", "value": "22" },
... { "dataElement": "oZg33kd9taw", "value": "Male" },
... { "dataElement": "msodh3rEMJa", "value": "2013-05-18" }
... ]
... }
>>> Schema(get_event_schema()).is_valid(event)
True
"""
date_str = Regex(r"^\d{4}-\d{2}-\d{2}$")
dhis2_id_str = Regex(r"^[A-Za-z0-9]+$") # (ASCII \w without underscore)
return {
"program":
dhis2_id_str,
"orgUnit":
dhis2_id_str,
"eventDate":
date_str,
SchemaOptional("completedDate"):
date_str,
SchemaOptional("status"):
Regex("^(ACTIVE|COMPLETED|VISITED|SCHEDULE|OVERDUE|SKIPPED)$"),
SchemaOptional("storedBy"):
str,
SchemaOptional("coordinate"): {
"latitude": float,
"longitude": float,
},
SchemaOptional("geometry"): {
"type": str,
"coordinates": [float],
},
SchemaOptional("assignedUser"):
dhis2_id_str,
"dataValues": [{
"dataElement": dhis2_id_str,
"value": object,
}],
}
def get_instance_parameters_schema(instance_parameters: dict,
default_volume_type: str,
instance_checks: list = None,
volumes_checks: list = None):
if not instance_checks:
instance_checks = []
if not volumes_checks:
volumes_checks = []
schema = Schema(
And(
{
**instance_parameters,
Optional('containerName', default=None):
And(str, Regex(r'^[\w-]+$')),
Optional('dockerDataRoot', default=''):
And(
str,
And(os.path.isabs,
error=
'Use an absolute path when specifying a Docker data root directory'
),
Use(lambda x: x.rstrip('/')),
),
Optional('volumes', default=[]):
And(
[{
'name': And(Or(int, str), Use(str),
Regex(r'^[\w-]+$')),
Optional('type', default=default_volume_type): str,
Optional('parameters', default={}): {
And(str, Regex(r'^[\w]+$')): object,
},
}],
And(lambda x: is_unique_value(x, 'name'),
error='Each instance volume must have a unique name.'),
*volumes_checks,
),
Optional('localSshPort', default=None):
Or(None, And(int, lambda x: 0 < x < 65536)),
Optional('commands', default=''):
str,
},
And(lambda x: not x['dockerDataRoot'] or any([
True for v in x['volumes']
if v['parameters'].get('mountDir') and is_subdir(
x['dockerDataRoot'], v['parameters']['mountDir'])
]),
error=
'The "mountDir" of one of the volumes must be a prefix for the "dockerDataRoot" path.'
), *instance_checks))
return schema
def validate_schema(advisory_dict):
scheme = {
str: [{
"advisory": str,
"cve": Or(None, Regex(r"CVE-\d+-\d+")),
"id": Regex(r"^pyup.io-\d"),
"specs": list,
"v": str,
}]
}
Schema(scheme).validate(advisory_dict)
def test_json_schema_and_merge_type():
s = And(str, Regex(r'^\w+$'))
assert s.json_schema() == {'type': 'string', 'regex': r'^\w+$'}
s = And(int, Regex(r'^\w+$'))
assert s.json_schema() == {'allOf': [
{'type': 'string', 'regex': r'^\w+$'},
{'type': 'integer'},
]}
s = And(Regex(r'^.{5,10}$'), Regex(r'^\w+$'))
assert s.json_schema() == {'allOf': [
{'type': 'string', 'regex': r'^.{5,10}$'},
{'type': 'string', 'regex': r'^\w+$'},
]}
def test_json_schema_dict_pattern():
s = Schema({
Clean(Regex(r'^\w+$')): 1,
Optional(Regex(r'^\w+$')): 2,
Regex(r'^\d+$'): 3,
})
assert s.json_schema() == {
'type': 'object',
'patternProperties': {
r'^\w+$': {'enum': [1, 2]},
r'^\d+$': {'enum': [3]},
},
'additionalProperties': False,
}
def part_two(passports):
schema = Schema(
{
"byr": And(Use(int), lambda n: 1920 <= n <= 2002),
"iyr": And(Use(int), lambda n: 2010 <= n <= 2020),
"eyr": And(Use(int), lambda n: 2020 <= n <= 2030),
"hgt": valid_height,
"hcl": Regex(r"^#[0-9a-f]{6}$"),
"ecl": Or("amb", "blu", "brn", "gry", "grn", "hzl", "oth"),
"pid": Regex(r"^\d{9}$"),
},
ignore_extra_keys=True,
)
return sum(schema.is_valid(p) for p in passports)
def register():
try:
if credential.check_apikey(request) == False:
return response_with(resp.UNAUTHORIZED_403,
value={"data": "invalid x-api-key"})
# validation
try:
Regex(r"(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)"
).validate(request.get_json().get("email"))
Schema({
'name': And(str),
'email': And(str),
'password': And(str)
}).validate(request.get_json())
except SchemaError:
return response_with(resp.INVALID_INPUT_422)
data = auth_service.store_user(request.get_json())
if data == "Email Already Exist":
return response_with(resp.BAD_REQUEST_400,
value={"data": "Email Already Exist"})
token = credential.create_token(request.get_json().get("email"))
return response_with(resp.SUCCESS_200,
value={
"data": data,
"token": token
})
except Exception:
return response_with(resp.INVALID_INPUT_422)
def __init__(self):
self.schema = Schema({
'gmail': {
'username': Use(str),
'password': Use(str),
'attachmentsPath': Regex(r'^/.*$'),
'allowedSubjects': [Use(str)],
'allowedImageFormats': [Use(str)],
'allowedVideoFormats': [Use(str)],
'blacklist': Use(dict)
},
'instagram': {
'username': Use(str),
'password': Use(str),
'access_token': Optional(Use(str)),
'client_secret': Optional(Use(str)),
'user_id': Optional(Use(str))
}
})
#Total configurations
self.confs = None
#Sub configurations
self.gmail = None
self.instagram = None
def schema():
"""Provide schema for shell configuration."""
return Schema({
'script':
And(Or(type(' '), type(u' ')), len),
Optional('title', default=''):
str,
Optional('model', default={}): {
Optional(And(str, len)): object
},
Optional('env', default={}): {
Optional(And(str, len)): And(str, len)
},
Optional('item', default=None):
object,
Optional('dry_run', default=False):
bool,
Optional('debug', default=False):
bool,
Optional('strict', default=False):
bool,
Optional('variables', default={}): {
Optional(
And(Or(type(' '), type(u' ')), len,
Regex(r'([a-zA-Z][_a-zA-Z]*)'))):
Or(type(' '), type(u' '))
},
Optional('temporary_scripts_path', default=''):
Or(type(''), type(u'')),
Optional('internal', default=False):
bool
})
def schema_event_items():
"""Schema for event items."""
return {
'timestamp': And(int, lambda n: n > 0),
Optional('information', default={}): {
Optional(Regex(r'([a-z][_a-z]*)')): object
}
}
def validate_instance_parameters(params: dict):
from spotty.providers.aws.config.instance_config import VOLUME_TYPE_EBS
instance_parameters = {
'region':
And(str, Regex(r'^[a-z0-9-]+$')),
Optional('availabilityZone', default=''):
And(str, Regex(r'^[a-z0-9-]+$')),
Optional('subnetId', default=''):
And(str, Regex(r'^subnet-[a-z0-9]+$')),
'instanceType':
str,
Optional('onDemandInstance', default=False):
bool,
Optional('amiName', default=None):
And(str, len, Regex(r'^[\w\(\)\[\]\s\.\/\'@-]{3,128}$')),
Optional('amiId', default=None):
And(str, len, Regex(r'^ami-[a-z0-9]+$')),
Optional('rootVolumeSize', default=0):
And(
Or(int, str),
Use(str),
Regex(r'^\d+$', error='Incorrect value for "rootVolumeSize".'),
Use(int),
And(lambda x: x > 0,
error='"rootVolumeSize" should be greater than 0 or should '
'not be specified.'),
),
Optional('maxPrice', default=0):
And(
Or(float, int, str),
Use(str),
Regex(r'^\d+(\.\d{1,6})?$',
error='Incorrect value for "maxPrice".'),
Use(float),
And(lambda x: x > 0,
error='"maxPrice" should be greater than 0 or '
'should not be specified.'),
),
Optional('managedPolicyArns', default=[]): [str],
Optional('ingressCidr', default=[]): [str],
}
volumes_checks = [
And(lambda x: len(x) < 12,
error='Maximum 11 volumes are supported at the moment.'),
]
instance_checks = [
And(lambda x: not (x['onDemandInstance'] and x['maxPrice']),
error='"maxPrice" cannot be specified for on-demand instances.'),
And(lambda x: not (x['amiName'] and x['amiId']),
error='"amiName" and "amiId" parameters cannot be used together.'),
]
schema = get_instance_parameters_schema(instance_parameters,
VOLUME_TYPE_EBS, instance_checks,
volumes_checks)
return validate_config(schema, params)
def validate_instance_parameters(params: dict):
from spotty.providers.gcp.config.instance_config import VOLUME_TYPE_DISK
instance_parameters = {
'zone':
And(str, Regex(r'^[a-z0-9-]+$')),
'machineType':
And(str, And(is_valid_machine_type, error='Invalid instance type.')),
Optional('gpu', default=None): {
'type': str,
Optional('count', default=1): int,
},
Optional('onDemandInstance', default=False):
bool,
Optional('imageName', default=None):
And(str, len, Regex(r'^[\w-]+$')),
Optional('imageUrl', default=None):
And(str, len, Regex(IMAGE_URL_REGEX)),
Optional('bootDiskSize', default=0):
And(
Or(int, str),
Use(str),
Regex(r'^\d+$', error='Incorrect value for "bootDiskSize".'),
Use(int),
And(lambda x: x > 0,
error='"rootVolumeSize" should be greater than 0 or should '
'not be specified.'),
),
}
instance_checks = [
And(lambda x: not x['gpu'] or is_gpu_machine_type(x['machineType']),
error=
'GPU cannot be attached to shared-core or memory-optimized machine types.'
),
And(lambda x: not (x['imageName'] and x['imageUrl']),
error=
'"imageName" and "imageUrl" parameters cannot be used together.'),
]
schema = get_instance_parameters_schema(instance_parameters,
VOLUME_TYPE_DISK, instance_checks,
[])
return validate_config(schema, params)
def user_model(input_request):
user_schema= Schema({
"name": And(Regex("^[a-zA-Z0-9 '-]{0,30}$"), error="Invalid name"),
"role": And(Or('Dev', 'Test', 'Support'), error = "Invalid role"),
"referenceId": And(Regex("^[a-zA-Z0-9 '-]{0,30}$"), error="Invalid referenceId"),
"postalcode":And(Regex("^\d{5}\-\d{4}$|^\d{5}$"), error = "Invalid postalcode"),
Optional("payload"):Use(json.loads, error = "Invalid payload"),
"fileName": And(Regex("^[a-zA-Z0-9 '-_.]{0,100}$"), Use(str), lambda f: True if f[-3:]=="csv" else False, error="Invalid fileName"),
},
ignore_extra_keys = True
)
try:
user_schema.validate(input_request)
return True, None
except Exception as e:
return False, e.code
def query_top_spreaders():
"""Handle API request '/top-user'.
API Request Parameters
----------------------
upper_day : string formatted datetime
most_recent : bool
API Response Keys
-----------------
status : string
num_of_entries : int
spreaders : dict
bot_score : float
number_of_tweets : int
site_type : {'claim', 'fact_checking'}
spreading_type : {'active', 'influencial'}
upper_day : string formatted datetime
user_id : int
user_raw_id : string
user_screen_name : string
"""
lucene.getVMEnv().attachCurrentThread()
yesterday = datetime.utcnow().date() - timedelta(days=1)
yesterday = yesterday.strftime('%Y-%m-%d')
q_top_spreaders_schema = Schema({
Optional('upper_day', default=yesterday):
And(Regex('^\d{4}-\d{2}-\d{2}$'),
Use(dateutil.parser.parse),
error='Invalid date, should be yyyy-mm-dd format'),
Optional('most_recent', default=True):
And(unicode,
Use(lambda s: s.lower()), lambda s: s in ('true', 'false'),
Use(lambda s: True if s == 'true' else False)),
})
q_kwargs = copy_req_args(request.args)
try:
q_kwargs = q_top_spreaders_schema.validate(q_kwargs)
df = db_query_top_spreaders(engine, **q_kwargs)
if len(df) == 0:
raise APINoResultError('No top spreader found!')
response = dict(
status='OK',
num_of_entries=len(df),
spreaders=flask.json.loads(df.to_json(**TO_JSON_KWARGS)))
except SchemaError as e:
response = dict(status='ERROR', error=str(e))
except APINoResultError as e:
response = dict(status='No result error', error=str(e))
except Exception as e:
logger.exception(e)
response = dict(status='ERROR', error='Server error, query failed')
return flask.jsonify(response)
class RangeDateFilter(filters.BaseFilterBackend):
"""Filtering fields."""
schema = Schema(And(Use(str), Regex(r'^\d{4}-\d{2}-\d{2}$')))
INVALID_DATE = _('The date is not valid')
def get_schema_fields(self, view):
"""."""
schema_cls = coreschema.String
return [
coreapi.Field(
name='r_d_date',
required=False,
location='query',
schema=schema_cls(
title=_("Date range"),
description=_(
"Filter events between dates in range. Format: "
"YYYY-MM-DD"))),
]
def filter_queryset(self, request, queryset, view):
"""We override to validate the dates and complement the query..
Args:
request(Request): Request of view.
queryset(QuerySet): Queryset
view(View): View from where the function is called
Return:
Queryset: queryset
"""
date_range = request.GET.get('r_d_date')
date_range_filters = {}
if date_range is not None:
from_date, _, to_date = date_range.partition(',')
if from_date:
if not self.is_valid_format(from_date):
raise ParseError({'r_d_date': self.INVALID_DATE})
date_range_filters.update({'date__gte': from_date})
if to_date:
if not self.is_valid_format(to_date):
raise ParseError({'r_d_date': self.INVALID_DATE})
date_range_filters.update({'date__lte': to_date})
queryset = queryset.filter(**date_range_filters)
return queryset
@classmethod
def is_valid_format(cls, date):
"""Validate the format of the dates.
Args:
date(Str): Date to validate.
Return:
Boolean: True if it is a valid date.
"""
return cls.schema.is_valid(date)
def validate_schema(advisory_dict):
scheme = [{
"advisory": str,
"cve": Or(None, str),
"id": Regex(r"^pyup.io-\d"),
"specs": list,
"v": str,
}]
Schema(scheme).validate(advisory_dict)
def test_zencode_call_random_array():
contract = """Given nothing
When I create the array of '64' random numbers modulo '100'
and I create the aggregation of array 'array'
Then print the 'array' as 'number'
and print the 'aggregation' as 'number'
"""
res = zencode_exec(contract)
out_regex = r'{\"aggregation\":\d{4},\"array\":\[(?:\d{1,3}\,)+\d{1,3}\]}'
assert Regex(out_regex).validate(res.output)
assert Schema({'aggregation': int, 'array': [int]}).validate(res.result)
def check_variant_schema(variant: dict):
"""Test if get_variant returns well formated nested data.
This method is for testing purpose. It raises an exception if data is corrupted
:param variant dict returned by AbstractReader.get_variant()
"""
try:
from schema import Schema, And, Or, Use, Optional, Regex
except ImportError as e:
LOGGER.warning("You should install optional package 'schema' via:")
LOGGER.warning("\t - pypi: pip install cutevariant[dev]")
LOGGER.warning("\t - git repo in editable mode: pip -e . [dev]")
raise e
checker = Schema(
{
"chr": And(Use(str.lower), str),
"pos": int,
"ref": And(Use(str.upper), Regex(r"^[ACGTN]+")),
"alt": And(Use(str.upper), Regex(r"^[ACGTN]+")),
Optional(str): Or(int, str, bool, float, None),
Optional("annotations"): [
{
"gene": str,
"transcript": str,
Optional(str): Or(int, str, bool, float),
}
],
Optional("samples"): [
{
"name": str,
"gt": And(int, lambda x: x in [-1, 0, 1, 2]),
Optional(str): Or(int, str, bool, float),
}
],
}
)
checker.validate(variant)
def sign_up():
schema = Schema({
"firstname": str,
"lastname": str,
"username": str,
"password": str,
"email": Regex(MAIL_REGEX, error="Mail address is invalid"),
"usertype": str,
"userschool": str
})
validated = schema.validate(request.json)
if User.objects(username=validated["username"]):
return jsonify({"error": "Username not available"}), 409
if User.objects(email=validated["email"]):
return jsonify(
{"error":
"There is already an account with your email address"}), 409
# Hash password with sha256
hashed_password = generate_password_hash(validated["password"])
user = User(firstname=validated["firstname"],
lastname=validated["lastname"],
username=validated["username"],
password=hashed_password,
email=validated["email"],
usertype=validated["usertype"],
userschool=validated["userschool"])
user.save()
token = jwt.encode(
{
"username": user.username,
"email": user.email,
"password": user.password,
"created": str(user.created)
}, app.config["SECRET_KEY"])
return jsonify({
"success": True,
"user": {
"username": user.username,
"email": user.email,
"password": user.password,
"created": str(user.created),
"firstname": user.firstname,
"lastname": user.lastname,
"usertype": user.usertype,
"userschool": user.userschool
},
"token": token.decode("UTF-8")
})
def query_top_articles():
"""Handle API request 'top-articles'
API Request Parameters
----------------------
upper_day : string formatted datetime
most_recent : bool
API Response Keys
-----------------
status : string
num_of_entries : int
articles : dict
canonical_url : string
date_captured : string formatted datetime
number_of_tweets : int
site_type : {'claim', 'fact_checking'}
title : string
upper_day : string formatted datetime
"""
lucene.getVMEnv().attachCurrentThread()
yesterday = datetime.utcnow().date() - timedelta(days=1)
yesterday = yesterday.strftime('%Y-%m-%d')
q_top_article_schema = Schema({
Optional('upper_day', default=yesterday):
And(Regex('^\d{4}-\d{2}-\d{2}$'),
Use(dateutil.parser.parse),
error='Invalid date, shoul be yyyy-mm-dd format'),
Optional('most_recent', default=True):
And(unicode,
Use(lambda s: s.lower()), lambda s: s in ('true', 'false'),
Use(lambda s: True if s == 'true' else False)),
Optional('exclude_tags', default=[]):
And(Use(eval), error='Invalid exclude_tags input format'),
})
q_kwargs = copy_req_args(request.args)
try:
q_kwargs = q_top_article_schema.validate(q_kwargs)
df = db_query_top_articles(engine, **q_kwargs)
if len(df) == 0:
raise APINoResultError('No top article found!')
response = dict(
status='OK',
num_of_entries=len(df),
articles=flask.json.loads(df.to_json(**TO_JSON_KWARGS)))
except SchemaError as e:
response = dict(status='ERROR', error=str(e))
except APINoResultError as e:
response = dict(status='No result error', error=str(e))
except Exception as e:
logger.exception(e)
response = dict(status='ERROR', error='Server error, query failed')
return flask.jsonify(response)
def main():
raw_args = docopt(__doc__, version='skjul 0.1')
schema = Schema({
'process':
bool,
'encode':
bool,
'decode':
bool,
'<in>':
Or(None, Use(open)),
'<pairs>':
Use(lambda x: x or 'skjul.csv'),
'<secret>':
Or(None, And(Regex(r'^[01]*$'), Use(lambda s: [c == '1' for c in s]))),
'--version':
bool,
'--lines':
Or(And('all', Use(lambda x: None)), Use(int)),
'--neighbors':
Use(int),
'--key':
Use(int),
'--noise':
Use(float),
})
args = schema.validate(raw_args)
if args['process']:
words, embeddings = _read_fast(args['<in>'] or sys.stdin,
nrows=args['--lines'])
st = Steganographer.from_embeddings(words,
embeddings,
k=args['--neighbors'])
with open(args['<pairs>'], 'w') as pairs:
st.save(pairs)
elif args['encode']:
with open(args['<pairs>']) as pairs:
st = Steganographer.load(pairs)
sys.stdout.write(
st.encode(sys.stdin.read(), args['<secret>'], args['--key'],
args['--noise']))
elif args['decode']:
with open(args['<pairs>']) as pairs:
st = Steganographer.load(pairs)
decoded = st.decode(sys.stdin.read(), args['--key'], args['--noise'])
sys.stdout.write(''.join('1' if bit else '0' for bit in decoded))
def validate_ami_config(data):
schema = Schema({
'instance': {
'region': And(str, len),
Optional('availabilityZone', default=''): str,
Optional('subnetId', default=''): str,
'instanceType': And(str, len),
Optional('amiName', default=DEFAULT_AMI_NAME): And(str, len, Regex(AMI_NAME_REGEX)),
Optional('keyName', default=''): str,
},
}, ignore_extra_keys=True)
return _validate(schema, data)
def validate_path(path):
"""Validate path
path : str; file path
"""
if not os.path.exists(path):
msg = 'ERROR: cannot find file: {}'
print(msg.format(path))
sys.exit(1)
s = Regex(r'SampleSheet_.+_R.+_L[0-9]+_*.*.csv')
msg = 'ERROR: Samples Sheet file not named correctly.'
msg += ' REQUIRED FORMAT: SampleSheet_{SEQUENCER}_R{RUN}_L{LANES}.csv'
Schema(s, error=msg).validate(path)
