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)