def validate_mandatory_ruleset(input):
"""
Validate input
Parameters
----------
input : dict
Structure holding input
Return
----------
retval : bool
True for success, False for failure
"""
schema_general = {
'initial': {
'required' : True,
'type': 'dict',
'allow_unknown': False,
'schema': {
'temperature':{'required' : True,'type':'number'},
'pressure':{'required' : True,'type': 'number'},
'fluid': {'required' : True,'type': 'string'},
},
},
'calculation': {
'required' : True,
'type': 'dict',
'allow_unknown': False,
'schema': {
'type': {
'required' : True,
'type': 'string',
'allowed': ['energybalance',
'isenthalpic',
'isentropic',
'isothermal',
'constant_U'],
},
'time_step': {'required' : True,'type': 'number', 'min': 0.000001},
'end_time': {'required' : True,'type': 'number', 'min': 0},
}
},
'vessel': {
'required' : True,
'type': 'dict',
'allow_unknown': False,
'schema': {
'length': {'required' : True,'type': 'number'},
'diameter': {'required' : True,'type': 'number'},
'thickness': {'required': False,'type': 'number', 'min': 0.0},
'heat_capacity': {'required': False, 'type': 'number', 'min': 1},
'density': {'required': False, 'type': 'number', 'min': 1},
'orientation': {
'required': False,
'type': 'string',
'allowed': ['vertical', 'horizontal']
}
}
},
'valve':{
'required' : True,
'type': 'dict',
'allow_unknown': False,
'schema':{
'type': {'required' : True,'type': 'string', 'allowed': ['orifice', 'psv', 'controlvalve', 'mdot']},
'flow': {'required' : True,'type': 'string', 'allowed': ['discharge', 'filling']},
'diameter': {'type': 'number', 'min': 0},
'discharge_coef': {'type': 'number', 'min': 0},
'set_pressure': {'type': 'number', 'min': 0},
'end_pressure': {'type': 'number', 'min': 0},
'blowdown': {'type': 'number', 'min': 0, 'max': 1},
'back_pressure': {'type': 'number', 'min': 0},
'Cv': {'type': 'number', 'min': 0},
'mdot': {'type': ['number','list']},
'time' : {'type': 'list'},
'time_constant': {'type': 'number', 'min': 0},
'characteristic': {'type': 'string', 'allowed': ['linear', 'eq', 'fast']},
}
},
'heat_transfer':{
'required': False,
'type': 'dict',
'allow_unknown': False,
'allowed': ['Q_fix','h_inner','h_outer','temp_ambient','type','fire','s-b','D_throat'],
'schema':{
'type': {'type': 'string','allowed': ['specified_Q','specified_h','specified_U','s-b']},
'Q_fix': {'required': False, 'type': 'number'},
'U_fix': {'required': False, 'type': 'number', 'min': 0},
'temp_ambient': {'required': False, 'type': 'number', 'min': 0},
'h_outer': {'required': False, 'type': 'number', 'min': 0},
'h_inner': {'required': False, 'type': ['number','string']},
'fire': {'required': False, 'type': 'string','allowed': ['api_pool','api_jet','scandpower_pool','scandpower_jet']},
'D_throat' : {'required': False, 'type': 'number', 'min': 0},
}
},
'validation':{
'required': False,
'type': 'dict',
'allow_unknown': False,
'allowed': ['pressure','temperature'],
'schema':{
'pressure': {'type': 'dict',
'required': False,
'contains': ['time','pres'],
'schema': {
'pres': {'required': False, 'type': 'list', 'schema': {'type': 'number'}},
'time': {'required': False, 'type': 'list', 'schema': {'type': 'number'}}
}
},
'temperature': {'type': 'dict',
'required': False,
'allowed': ['wall_high','wall_low','wall_mean','gas_high','gas_low','gas_mean'],
'schema': {'gas_high':{'required': False, 'type': 'dict', 'contains': ['time','temp'],
'schema': {
'temp': {'required': False, 'type': 'list', 'schema': {'type': 'number'}},
'time': {'required': False, 'type': 'list', 'schema': {'type': 'number'}}
}
},
'gas_low': {'required': False, 'type':'dict', 'contains': ['time','temp'],
'schema': {
'temp': {'required': False, 'type': 'list', 'schema': {'type': 'number'}},
'time': {'required': False, 'type': 'list', 'schema': {'type': 'number'}}
}
},
'gas_mean':{'required': False, 'type': 'dict', 'contains': ['time','temp'],
'schema': {
'temp': {'required': False, 'type': 'list', 'schema': {'type': 'number'}},
'time': {'required': False, 'type': 'list', 'schema': {'type': 'number'}}
}
},
'wall_high':{'required': False, 'type': 'dict', 'contains': ['time','temp'],
'schema': {
'temp': {'required': False, 'type': 'list', 'schema': {'type': 'number'}},
'time': {'required': False, 'type': 'list', 'schema': {'type': 'number'}}
}
},
'wall_mean':{'required': False, 'type': 'dict', 'contains': ['time','temp'],
'schema': {
'temp': {'required': False, 'type': 'list', 'schema': {'type': 'number'}},
'time': {'required': False, 'type': 'list', 'schema': {'type': 'number'}}
}
},
'wall_low':{'required': False, 'type': 'dict', 'contains': ['time','temp'],
'schema': {
'temp': {'required': False, 'type': 'list', 'schema': {'type': 'number'}},
'time': {'required': False, 'type': 'list', 'schema': {'type': 'number'}}
}
}
}
}
}
}
}
v = Validator(schema_general)
retval = v.validate(input)
if v.errors:
print(v.errors)
return retval
def validate_doc_eukaryotic(d):
v = Validator(mygene_schema, allow_unknown=True)
v.validate(d)
if v.errors:
raise ValueError(v.errors)
return v.document
def create(self):
schema = {
'name': {
'type': 'string',
'empty': False,
'required': True
},
'ep1_switch_id': {
'type': 'string',
'empty': False,
'required': True
},
'ep1_switch_port': {
'type': 'string',
'empty': False,
'required': True
},
'ep1_network_type': {
'type': 'string',
'empty': False,
'required': True
},
'ep1_segmentation_id': {
'type': ['string', 'integer'],
'empty': False,
'required': True
},
'ep2_switch_id': {
'type': 'string',
'empty': False,
'required': True
},
'ep2_switch_port': {
'type': 'string',
'empty': False,
'required': True
},
'ep2_network_type': {
'type': 'string',
'empty': False,
'required': True
},
'ep2_segmentation_id': {
'type': ['string', 'integer'],
'empty': False,
'required': True
},
}
v = Validator(schema, allow_unknown=True)
if not v.validate(self.__dict__):
raise NonRecoverableError(
"Object schema not valid. Errors: {}".format(v.errors))
data = self.fm_payload()
ctx.logger.debug("data object: {}".format(data))
# ethernet create twice arp + ip
# vlan create once
response = self.fm_client.add_eline(eline=data)
ctx.logger.info("Eline {} {} response: {} {}".format(
'PUT', self.name, response['status_code'], response['content']))
if response['status_code'] not in [200, 201]:
raise NonRecoverableError(
"Create ELine {0} failed with response {1} {2}".format(
self.name, response['status_code'], response['content']))
else:
ctx.logger.info("Create ELine {0} successful: {1} {2}".format(
self.name, response['status_code'], response['content']))
def loads_put_patch_delete(load_id):
if request.method == 'GET':
if request.headers[
'Accept'] == '*/*' or 'application/json' in request.headers[
'Accept']:
load_key = client.key(constants.loads, int(load_id))
load = client.get(load_key)
error_obj = {"Error": "No load with this load_id exists"}
if load is None:
return (json.dumps(error_obj), 404)
else:
load["id"] = load.key.id
load["self"] = str(request.base_url)
return response_status_json(load, 'application/json', 200,
None, None)
else:
error_obj = {"Error": "Accept header must be application/json"}
return (json.dumps(error_obj), 406)
elif request.method == 'PATCH':
if request.mimetype == 'application/json':
if request.headers[
'Accept'] != '*/*' and 'application/json' not in request.headers[
'Accept']:
error_obj = {"Error": "Accept header must be application/json"}
return (json.dumps(error_obj), 406)
else:
owner_results = verify()
if (owner_results and owner_results != -1):
if not check_for_user(owner_results):
errObj = {"Error": "Not a valid user, please register"}
return (json.dumps(errObj), 401)
content = request.get_json()
schema = get_loads_schema()
v = Validator(schema)
if v.validate(content, schema) is False or not content:
error_obj = {
"Error":
"The request object contains inappropriate attributes or attribute input"
}
return (json.dumps(error_obj), 400)
error_obj = {
"Error":
"The request object is missing at least one of the required attributes"
}
if "contents" not in content and "delivery_date" not in content and "weight" not in content:
return (json.dumps(error_obj), 400)
else:
load_key = client.key(constants.loads, int(load_id))
load = client.get(key=load_key)
if load is None:
error_obj = {
"Error": "No load with this load_id exists"
}
return (json.dumps(error_obj), 404)
else:
updated_content = ""
updated_delivery_date = ""
updated_weight = -1
if "contents" not in content:
updated_content = load["contents"]
else:
updated_content = content["contents"]
if "delivery_date" not in content:
updated_delivery_date = load["delivery_date"]
else:
updated_delivery_date = content[
"delivery_date"]
if "weight" not in content:
updated_weight = load["weight"]
else:
updated_weight = content["weight"]
load.update({
"contents": updated_content,
"delivery_date": updated_delivery_date,
"weight": updated_weight
})
client.put(load)
load["id"] = load.key.id
self_url = str(request.base_url)
load["self"] = self_url
if load['carrier'] is not None:
for e in load["carrier"]:
e["self"] = str(
request.base_url) + "/" + str(e["id"])
return response_status_json(
load, 'application/json', 200, None, None)
else:
errObj = {"Error": "Missing or Invalid JWTs"}
return (json.dumps(errObj), 401)
else:
error_obj = {
"Error": "The request mimetype should be application/json"
}
return (json.dumps(error_obj), 400)
elif request.method == 'PUT':
if request.mimetype == 'application/json':
if request.headers[
'Accept'] != '*/*' and 'application/json' not in request.headers[
'Accept']:
error_obj = {"Error": "Accept header must be application/json"}
return (json.dumps(error_obj), 406)
else:
owner_results = verify()
if (owner_results and owner_results != -1):
if not check_for_user(owner_results):
errObj = {"Error": "Not a valid user, please register"}
return (json.dumps(errObj), 401)
content = request.get_json()
schema = get_loads_schema()
v = Validator(schema)
if v.validate(content, schema) is False or not content:
error_obj = {
"Error":
"The request object contains inappropriate attributes or attribute input"
}
return (json.dumps(error_obj), 400)
error_obj = {
"Error":
"The request object is missing at least one of the required attributes"
}
if "contents" not in content:
return (json.dumps(error_obj), 400)
elif "delivery_date" not in content:
return (json.dumps(error_obj), 400)
elif "weight" not in content:
return (json.dumps(error_obj), 400)
else:
load_key = client.key(constants.loads, int(load_id))
load = client.get(key=load_key)
if load is None:
error_obj = {
"Error": "No load with this load_id exists"
}
return (json.dumps(error_obj), 404)
else:
load.update({
"contents":
content["contents"],
"delivery_date":
content["delivery_date"],
"weight":
content["weight"]
})
client.put(load)
load["id"] = load.key.id
self_url = str(request.base_url)
load["self"] = self_url
if load['carrier'] is not None:
for e in load['carrier']:
e["self"] = str(
request.base_url) + "/" + str(e["id"])
return response_status_json(
load, 'application/json', 200, None, None)
else:
errObj = {"Error": "Missing or Invalid JWTs"}
return (json.dumps(errObj), 401)
else:
error_obj = {
"Error": "The request mimetype should be application/json"
}
return (json.dumps(error_obj), 400)
elif request.method == 'DELETE':
owner_results = verify()
if (owner_results and owner_results != -1):
if not check_for_user(owner_results):
errObj = {"Error": "Not a valid user, please register"}
return (json.dumps(errObj), 401)
load_key = client.key(constants.loads, int(load_id))
load = client.get(key=load_key)
if load is None:
error_obj = {"Error": "No load with this load_id exists"}
return (json.dumps(error_obj), 404)
else:
if load["carrier"] is not None:
boat_id = load["carrier"]["id"]
boat_key = client.key(constants.boats, int(boat_id))
boat = client.get(key=boat_key)
owner = -1
if boat is not None:
if boat["loads"] is not None:
for e in boat["loads"]:
if int(e["id"]) == int(id):
if int(e["owner"]) != owner_results:
owner = 1
else:
boat["loads"].remove(e)
client.put(boat)
if owner:
errObj = {
"Error": "You are not the owner of this boat"
}
return (json.dumps(errObj), 403)
else:
client.delete(load_key)
return ('', 204)
else:
client.delete(load_key)
return ('', 204)
else:
errObj = {"Error": "Missing or Invalid JWTs"}
return (json.dumps(errObj), 401)
else:
error_obj = {"Error": "Method not recognized"}
return (json.dumps(error_obj), 405)
def validateOutput():
url = "http://localhost:7071/api/me"
header = {'Authorization': 'Bearer 997a139c203f4c2183cef6babc3ce469'}
r = requests.get(url, headers=header)
j = r.json()
schema = {
"id": {
"type": "string"
},
"emailAddress": {
"type": "string"
},
"token": {
"type": "string",
"regex": "\S*(\S*([a-zA-Z]\S*[0-9])|([0-9]\S*[a-zA-Z]))\S*"
},
"dateOfBirth": {
"type": "string"
},
"fare": {
"type": "number"
},
"home": {
"type": "dict",
"schema": {
"id": {
"type": "string"
},
"address": {
"type": "string"
},
"latitude": {
"type": "number"
},
"longitude": {
"type": "number"
},
"place": {
"type": "string"
},
"postalCode": {
"type": "string"
}
}
},
"phoneNumber": {
"type": "string"
},
"range": {
"type": "number"
},
"vehicle": {
"type": "integer"
},
"totalEarned": {
"nullable": True,
"type": "number"
}
}
v = Validator(schema)
assert v.validate(j)
assert r.status_code == 200, "De status code is geen 200!"
def add_layer(self, layer, thickness_mm, density_gcm3=None):
# Input Validation
_input = {
'layer': layer,
'thickness': thickness_mm,
'density': density_gcm3,
}
schema = {
'layer': {
'type': 'string',
'required': True,
},
'thickness': {
'type': 'number',
'required': True,
},
'density': {
'type': 'number',
'required': True,
'nullable': True,
},
}
v = Validator(schema)
if v.validate(_input) is False:
raise ValueError(v.errors)
_formula = re.findall(r'([A-Z][a-z]*)(\d*)', layer)
_elements = []
for _element in _formula:
_single_element = list(_element)[0]
_elements.append(_single_element)
# raise error if input is contains more than one element for single layer.
if len(_elements) > 1:
raise ValueError(
"Please enter single element as layer in string. Example: 'Gd' or 'U'"
)
if density_gcm3 is not None:
self.info[layer] = {
'layer': layer,
'thickness': {
'value': thickness_mm,
'units': 'mm',
},
'density': {
'value': density_gcm3,
'units': 'g/cm3',
},
'molar_mass': {
'value': None,
'units': None,
},
'molar_conc': {
'value': None,
'units': None,
},
}
else:
self.info[layer] = {
'layer': layer,
'thickness': {
'value': thickness_mm,
'units': 'mm',
},
'density': {
'value': np.NaN,
'units': 'g/cm3',
},
'molar_mass': {
'value': None,
'units': None,
},
'molar_conc': {
'value': None,
'units': None,
},
}
message_channel = message_broker.channel()
# Declare exchange
message_channel.exchange_declare(exchange=AMQP_Exchange,
exchange_type=AMQP_Exchange_Type)
# Declare Queues
message_channel.queue_declare(queue=AMQP_Auth_Queue, durable=True)
message_channel.queue_declare(queue=AMQP_Email_Queue, durable=True)
message_channel.queue_declare(queue=AMQP_Profile_Queue, durable=True)
# Bind exchange and queues
message_channel.queue_bind(exchange=AMQP_Exchange, queue=AMQP_Auth_Queue)
message_channel.queue_bind(exchange=AMQP_Exchange, queue=AMQP_Email_Queue)
message_channel.queue_bind(exchange=AMQP_Exchange, queue=AMQP_Profile_Queue)
print('Auth Service AMQP Connection Established...')
v = Validator()
print('Auth Service Initialization Finished...')
def toekn_gen():
return uuid.uuid4().hex
def add_user(username, email, password):
#t_bf = int(time.time() * 1000)
pw_salt = uuid.uuid4().hex
salted_pw = password + pw_salt
#t_af = int(time.time() * 1000)
#sys.stderr.write("Salting takes: %d\n" % (t_af - t_bf))
hashed_pw = hashlib.sha512(salted_pw.encode('utf-8')).hexdigest()
def test_coerce_not_destructive():
schema = {'amount': {'coerce': int}}
v = Validator(schema)
doc = {'amount': '1'}
v.validate(doc)
assert v.document is not doc
def test_allow_unknown_wo_schema():
# https://github.com/pyeve/cerberus/issues/302
v = Validator({'a': {'type': 'dict', 'allow_unknown': True}})
v({'a': {}})
def test_rename_handler():
validator = Validator(allow_unknown={'rename_handler': int})
schema = {}
document = {'0': 'foo'}
expected = {0: 'foo'}
assert_normalized(document, expected, schema, validator)
def test_purge_unknown():
validator = Validator(purge_unknown=True)
schema = {'foo': {'type': 'string'}}
document = {'bar': 'foo'}
expected = {}
assert_normalized(document, expected, schema, validator)
from flask import request
from app.admin import admin
from cerberus import Validator
from app.utils import Response
from app import helpers as hp
validator = Validator()
@admin.route('/add', methods=['POST'])
def add():
pass
@admin.route('/get/cycle/details', methods=['GET'])
def get_cycle_details():
data = {'client_id': request.args.get('client_id')}
response = Response()
schema = {'client_id': {'required': True, 'type': 'string'}}
res = validator.validate(data, schema)
if not res:
response.success = False
response.status = 400
response.message = "Required data not found"
return response.response_json()
cycle_details = hp.ClientCycleDetails()
cycle_response = cycle_details.select(data)
if not cycle_response.success:
cycle_response.success = False
cycle_response.status = 400
cycle_response.data = list()
'schema': {
'type': 'string',
'regex': '^[0-9]{2,4}-[0-9]{2,4}-[0-9]{3,4}$',
}
},
'address': {
'type': 'string',
'empty': True,
},
'birthday': {
'type': 'date',
}
}
# バリデータを作成
v = Validator(schema)
# 入力値1(バリデーションOK)
data_ok = {
'name': '田中一郎',
'email': '*****@*****.**',
'age': 30,
'phones': [
'012-3456-7890',
'0120-444-444',
],
'address': '',
'birthday': date(1990, 7, 7),
}
# 入力値2(バリデーションNG)
def __init__(self, data):
self.validator = Validator(self.get_schema())
self.data = data
loader = FileSystemLoader(self.templates_folder)
self.jinja_environment = Environment(loader=loader)
def create_store_request(self, **post):
env = request.env
user = env.user
schema = {
'store_name': {
'type': 'string',
'regex': '^[a-zA-Z0-9][a-zA-Z0-9-]{1,61}[a-zA-Z0-9]$',
'required': True,
'empty': False,
'maxlength': 61,
},
'store_email': {
'type': 'string',
'regex': '^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$',
'required': True,
'empty': False,
'maxlength': 100,
},
'store_phone': {
'type': 'string',
'required': True,
'empty': False,
'maxlength': 24,
},
'store_address': {
'type': 'string',
'required': True,
'empty': False,
'maxlength': 255,
},
'store_opening': {
'type': 'string',
'required': True,
'empty': False,
'maxlength': 255,
},
'oauth_access_token': {
'type': 'string',
'required': False,
'empty': True,
'maxlength': 2048,
},
'oauth_uuid': {
'type': 'string',
'required': False,
'empty': True,
'maxlength': 255,
},
'oauth_id': {
'type': 'string',
'required': False,
'empty': True,
'maxlength': 10,
},
}
v = Validator(schema, purge_unknown=True)
v.validate(post)
response = {
'redirect': False,
'domain_exists': False,
'store_name': True,
'store_email': True,
'store_phone': True,
'store_address': True,
'store_opening': True,
'oauth_access_token': True,
'oauth_uuid': True,
'oauth_id': True,
}
if v.errors:
for key in response:
if key in v.errors:
response[key] = False
else:
oauth_access_token = False
oauth_uuid = False
oauth_id = False
return_response = False
is_logged_in = True if user and user.login != 'public' else False
# Try to get oauth_access_token from post
if 'oauth_access_token' in post and post['oauth_access_token']:
oauth_access_token = post['oauth_access_token']
# Try to get oauth_access_token from logged user
elif is_logged_in:
oauth_access_token = user.oauth_access_token
else:
return_response = True
# Try to get oauth_uuid from post
if 'oauth_uuid' in post and post['oauth_uuid']:
oauth_uuid = post['oauth_uuid']
# Try to get oauth_uuid from logged user
elif is_logged_in:
oauth_uuid = user.oauth_uuid
else:
return_response = True
# Try to get oauth_id from post
if 'oauth_id' in post and post['oauth_id']:
oauth_id = post['oauth_id']
# Try to get oauth_id from logged user
elif is_logged_in:
oauth_id = user.oauth_uid
else:
return_response = True
# Return JSON response if oauth data doesn't exist in post and the user is not logged in
if return_response:
return json.dumps(response)
subdomain_name = self.get_subdomain_name(post['store_name'])
country_id = int(
env.ref('smart_shop_create_store.default_country_id').value)
# Create is store partner
partner_id, local_partner_id = self.create_store_partner(
post, subdomain_name, country_id)
if partner_id:
# Create and open store
self.create_and_open_store(partner_id, oauth_access_token,
oauth_uuid, subdomain_name,
country_id, post, oauth_id)
# Set Redirect URL
response[
'redirect'] = 'https://%s/open-store?accessToken=%s' % (
subdomain_name, oauth_access_token)
# Send store created email
template = env.ref(
'smart_shop_create_store.store_created_email')
template.sudo().with_context(store_url='https://%s' %
subdomain_name).send_mail(
local_partner_id,
force_send=True,
raise_exception=False)
else:
response['domain_exists'] = True
return json.dumps(response)
def test_allow_unknown_with_purge_unknown():
validator = Validator(purge_unknown=True)
schema = {'foo': {'type': 'dict', 'allow_unknown': True}}
document = {'foo': {'bar': True}, 'bar': 'foo'}
expected = {'foo': {'bar': True}}
assert_normalized(document, expected, schema, validator)
class Product(object):
logger = logging.getLogger(__name__)
redis = None
schema = {
'id': {
'type': 'integer'
},
'name': {
'type': 'string',
'required': True
},
'category': {
'type': 'string',
'required': True
},
'price': {
'type': 'integer',
'required': True
},
'description': {
'type': 'string',
'required': True
},
'color': {
'type': 'string',
'required': True
},
'count': {
'type': 'integer',
'required': True
}
}
__validator = Validator(schema)
def __init__(self,
id=0,
name='',
category='',
price='',
description='',
color='',
count=''):
self.id = int(id)
self.name = name
self.category = category
self.price = price
self.color = color
self.description = description
self.count = count
def save(self):
if self.id == 0:
self.id = Product.__next_index()
Product.redis.set(self.id, pickle.dumps(self.serialize()))
def delete(self):
Product.redis.delete(self.id)
def serialize(self):
return {
"id": self.id,
"name": self.name,
"category": self.category,
"price": self.price,
"description": self.description,
"color": self.color,
"count": self.count
}
def deserialize(self, data):
try:
self.name = data['name']
self.category = data['category']
self.price = data['price']
self.description = data['description']
self.color = data['color']
self.count = data['count']
except KeyError as err:
raise DataValidationError('Invalid product: missing ' +
err.args[0])
except TypeError:
raise DataValidationError(
'Invalid product: body of request contained bad or no data')
return self
@staticmethod
def __next_index():
return Product.redis.incr('index')
@staticmethod
def all():
results = []
for key in Product.redis.keys():
if key != 'index':
data = pickle.loads(Product.redis.get(key))
product = Product(data['id']).deserialize(data)
results.append(product)
return results
@staticmethod
def available():
results = []
for key in Product.redis.keys():
if key != 'index':
data = pickle.loads(Product.redis.get(key))
product = Product(data['id']).deserialize(data)
if product.count > 0:
results.append(product)
return results
@staticmethod
def remove_all():
Product.redis.flushall()
@staticmethod
def find(product_id):
if Product.redis.exists(product_id):
data = pickle.loads(Product.redis.get(product_id))
product = Product(data['id']).deserialize(data)
return product
return None
@staticmethod
def __find_by(attribute, value):
Product.logger.info('Processing %s query for %s', attribute, value)
search_criteria = value.lower()
results = []
for key in Product.redis.keys():
if key != 'index':
data = pickle.loads(Product.redis.get(key))
test_value = data[attribute].lower()
if test_value == search_criteria:
results.append(Product(data['id']).deserialize(data))
return results
@staticmethod
def find_by_category(category):
return Product.__find_by('category', category)
@staticmethod
def find_by_name(name):
return Product.__find_by('name', name)
@staticmethod
def connect_to_redis(hostname, port, password):
Product.logger.info("Testing Connection to: %s:%s", hostname, port)
Product.redis = Redis(host=hostname, port=port, password=password)
try:
Product.redis.ping()
Product.logger.info("Connection established")
except ConnectionError:
Product.logger.info("Connection Error from: %s:%s", hostname, port)
Product.redis = None
return Product.redis
@staticmethod
def init_db(redis=None):
if redis:
Product.logger.info("Using client connection...")
Product.redis = redis
try:
Product.redis.ping()
Product.logger.info("Connection established")
except ConnectionError:
Product.logger.error("Client Connection Error!")
Product.redis = None
raise ConnectionError('Could not connect to the Redis Service')
return
if 'VCAP_SERVICES' in os.environ:
Product.logger.info("Using VCAP_SERVICES...")
vcap_services = os.environ['VCAP_SERVICES']
services = json.loads(vcap_services)
creds = services['rediscloud'][0]['credentials']
Product.logger.info("Conecting to Redis on host %s port %s",
creds['hostname'], creds['port'])
Product.connect_to_redis(creds['hostname'], creds['port'],
creds['password'])
else:
Product.logger.info(
"VCAP_SERVICES not found, checking localhost for Redis")
Product.connect_to_redis('127.0.0.1', 6379, None)
if not Product.redis:
Product.logger.info(
"No Redis on localhost, looking for redis host")
Product.connect_to_redis('redis', 6379, None)
if not Product.redis:
Product.logger.fatal(
'*** FATAL ERROR: Could not connect to the Redis Service')
raise ConnectionError('Could not connect to the Redis Service')
class Order(object):
""" Order interface to database """
logger = logging.getLogger(__name__)
redis = None
schema = {
'id': {
'type': 'integer'
},
'name': {
'type': 'string',
'required': True
},
'time': {
'type': 'string',
'required': True
},
'status': {
'type': 'boolean',
'required': True
}
}
__validator = Validator(schema)
def __init__(self, id=0, name=None, time=None, status=True):
""" Constructor """
self.id = int(id)
self.name = name
self.time = time
self.status = status
def save(self):
""" Saves a Order in the database """
if self.name is None: # name is the only required field
raise DataValidationError('name attribute is not set')
if self.id == 0:
self.id = Order.__next_index()
Order.redis.set(self.id, pickle.dumps(self.serialize()))
def delete(self):
""" Deletes a Order from the database """
Order.redis.delete(self.id)
def serialize(self):
""" serializes a Order into a dictionary """
return {
"id": self.id,
"name": self.name,
"time": self.time,
"status": self.status
}
def deserialize(self, data):
""" deserializes a Order my marshalling the data """
if isinstance(data, dict) and Order.__validator.validate(data):
self.name = data['name']
self.time = data['time']
self.status = data['status']
else:
raise DataValidationError('Invalid order data: ' +
str(Order.__validator.errors))
return self
######################################################################
# S T A T I C D A T A B S E M E T H O D S
######################################################################
@staticmethod
def __next_index():
""" Increments the index and returns it """
return Order.redis.incr('index')
# @staticmethod
# def use_db(redis):
# Order.__redis = redis
@staticmethod
def remove_all():
""" Removes all Orders from the database """
Order.redis.flushall()
@staticmethod
def all():
""" Query that returns all Orders """
# results = [Order.from_dict(redis.hgetall(key)) for key in redis.keys() if key != 'index']
results = []
for key in Order.redis.keys():
if key != 'index': # filer out our id index
data = pickle.loads(Order.redis.get(key))
order = Order(data['id']).deserialize(data)
results.append(order)
return results
######################################################################
# F I N D E R M E T H O D S
######################################################################
@staticmethod
def find(order_id):
""" Query that finds Orders by their id """
if Order.redis.exists(order_id):
data = pickle.loads(Order.redis.get(order_id))
order = Order(data['id']).deserialize(data)
return order
return None
@staticmethod
def __find_by(attribute, value):
""" Generic Query that finds a key with a specific value """
# return [order for order in Order.__data if order.time == time]
Order.logger.info('Processing %s query for %s', attribute, value)
if isinstance(value, str):
search_criteria = value.lower() # make case insensitive
else:
search_criteria = value
results = []
for key in Order.redis.keys():
if key != 'index': # filer out our id index
data = pickle.loads(Order.redis.get(key))
# perform case insensitive search on strings
if isinstance(data[attribute], str):
test_value = data[attribute].lower()
else:
test_value = data[attribute]
if test_value == search_criteria:
results.append(Order(data['id']).deserialize(data))
return results
@staticmethod
def find_by_name(name):
""" Query that finds Orders by their name """
return Order.__find_by('name', name)
@staticmethod
def find_by_time(time):
""" Query that finds Orders by their time """
return Order.__find_by('time', time)
@staticmethod
def find_by_availability(status=True):
""" Query that finds Orders by their availability """
return Order.__find_by('status', status)
######################################################################
# R E D I S D A T A B A S E C O N N E C T I O N M E T H O D S
######################################################################
@staticmethod
def connect_to_redis(hostname, port, password):
""" Connects to Redis and tests the connection """
Order.logger.info("Testing Connection to: %s:%s", hostname, port)
Order.redis = Redis(host=hostname, port=port, password=password)
try:
Order.redis.ping()
Order.logger.info("Connection established")
except ConnectionError:
Order.logger.info("Connection Error from: %s:%s", hostname, port)
Order.redis = None
return Order.redis
@staticmethod
def init_db(redis=None):
"""
Initialized Redis database connection
This method will work in the following conditions:
1) In Bluemix with Redis bound through VCAP_SERVICES
2) With Redis running on the local server as with Travis CI
3) With Redis --link in a Docker container called 'redis'
4) Passing in your own Redis connection object
Exception:
----------
redis.ConnectionError - if ping() test fails
"""
if redis:
Order.logger.info("Using client connection...")
Order.redis = redis
try:
Order.redis.ping()
Order.logger.info("Connection established")
except ConnectionError:
Order.logger.error("Client Connection Error!")
Order.redis = None
raise ConnectionError('Could not connect to the Redis Service')
return
# Get the credentials from the Bluemix environment
if 'VCAP_SERVICES' in os.environ:
Order.logger.info("Using VCAP_SERVICES...")
vcap_services = os.environ['VCAP_SERVICES']
services = json.loads(vcap_services)
creds = services['rediscloud'][0]['credentials']
Order.logger.info("Conecting to Redis on host %s port %s",
creds['hostname'], creds['port'])
Order.connect_to_redis(creds['hostname'], creds['port'],
creds['password'])
else:
Order.logger.info(
"VCAP_SERVICES not found, checking localhost for Redis")
Order.connect_to_redis('127.0.0.1', 6379, None)
if not Order.redis:
Order.logger.info(
"No Redis on localhost, looking for redis host")
Order.connect_to_redis('redis', 6379, None)
if not Order.redis:
# if you end up here, redis instance is down.
Order.logger.fatal(
'*** FATAL ERROR: Could not connect to the Redis Service')
raise ConnectionError('Could not connect to the Redis Service')
def validate(self, data: Any) -> None:
v = Validator(self.schema)
if not v.validate(data):
raise ValueError(f"Invalid manifest schema: {v.errors}")
def _create_validator(self, state_schema):
self.state_schema = state_schema
self.state_validator = Validator(self.state_schema)
def msg_received(self, msg):
QAgentWS.msg_received(self, msg)
try:
data = json.loads(msg)
except ValueError:
self.log.write({
'exchange': self.exchange,
'message': 'JSON data malformed',
'error': traceback.format_exc(),
'value': repr(msg),
}, 'ERROR')
return 0
#skip intro message
if 'info' in data:
return 0
#skip success subscribe message
if 'subscribe' in data:
#print('subscribed response: {success} to {topic}'.format(success=data['success'], topic=data['subscribe']))
return 0
if 'data' not in data:
self.log.write({
'exchange': self.exchange,
'message': 'JSON datatypes missmatch',
'error': traceback.format_exc(),
'value': repr(data),
}, 'ERROR')
return 0
v_schema = {
'timestamp': {'type': 'string'},
'symbol': {'type': 'string'},
'size': {'type': 'float'},
'price': {'type': 'float'},
'trdMatchID': {'type': 'string'},
}
v = Validator()
v.allow_unknown = True
for item in data['data']:
if not v.validate(item, v_schema):
self.log.write({
'exchange': self.exchange,
'message': 'JSON datatypes missmatch',
'error': repr(v.errors),
}, 'ERROR')
else:
#skip size=0 ticks
if item['size'] > 0:
if item['side'] == "Buy":
quantity = item['size']
else:
quantity = -1 * item['size']
trade = {
"exchange": self.exchange,
"market": item['symbol'],
"agent_id": self.r.agent_key,
"message_id": uuid.uuid4().hex,
"external_timestamp": item['timestamp'],
"external_id": str(item['trdMatchID']),
"price": item['price'],
"quantity": quantity,
"original_response": json.dumps(item)
}
self.pubsub.write(trade)
#tracking data scraped
self.r.data_scraped(1)
self.metrics.gauge_inc(self.counter_scraped_granular, *[self.exchange, item['symbol']])
def assertResponseStructure(
self,
http_code,
method=None,
headers=None,
payload={},
content="application/json",
parameters_url={},
query_params={},
files=None,
):
contentValidator = Validator()
try:
contentValidator.schema = self.structure.getContentValidator(content)
except Exception as ex:
self.fail(
"Not defined content for %s - in file %s\nError: %s"
% (content, self.structure.name_file, ex)
)
http_verb = self.http_verb(method)
if files != None:
r = getattr(requests, http_verb)(
url=self.url(parameters_url),
headers=headers,
data=payload,
params=query_params,
files=files,
)
else:
r = getattr(requests, http_verb)(
url=self.url(parameters_url),
headers=headers,
json=payload,
params=query_params,
)
try:
self.assertEqual(http_code, r.status_code)
except Exception as ex:
self.fail("Error: %s\n Message: %s" % (ex, r.text))
responseValidator = Validator()
try:
responseValidator.schema = self.structure.getResponseValidator(
http_verb, http_code
)
except Exception as ex:
self.fail(
"Not defined the schema for %s - %d in file %s\nError: %s"
% (http_verb, http_code, self.structure.name_file, ex)
)
try:
j = r.json()
except:
return r
if (responseValidator.schema and not responseValidator.validate(j)) or (
contentValidator.schema and not contentValidator.validate(payload)
):
self.fail(
"content_errors:%s\nresponse_errors:%s"
% (contentValidator.errors, responseValidator.errors,)
)
return r
def loads_get_post():
if request.method == 'POST':
if request.mimetype == 'application/json':
if request.headers[
'Accept'] != '*/*' and 'application/json' not in request.headers[
'Accept']:
error_obj = {"Error": "Accept header must be application/json"}
return (json.dumps(error_obj), 406)
else:
content = request.get_json()
schema = get_loads_schema()
v = Validator(schema)
if v.validate(content, schema) is False:
error_obj = {
"Error":
"The request object contains inappropriate attributes or attribute input"
}
return (json.dumps(error_obj), 400)
error_obj = {
"Error":
"The request object is missing at least one of the required attributes"
}
if "contents" not in content:
return (json.dumps(error_obj), 400)
elif "delivery_date" not in content:
return (json.dumps(error_obj), 400)
elif "weight" not in content:
return (json.dumps(error_obj), 400)
else:
owner_results = verify()
if (owner_results and owner_results != -1):
if not check_for_user(owner_results):
errObj = {
"Error": "Not a valid user, please register"
}
return (json.dumps(errObj), 401)
new_load = datastore.entity.Entity(
key=client.key(constants.loads))
new_load.update({
"contents":
content["contents"],
"delivery_date":
content["delivery_date"],
"weight":
content["weight"],
"carrier":
None
})
client.put(new_load)
new_load["id"] = new_load.key.id
self_url = str(request.base_url) + "/" + str(
new_load.key.id)
new_load["self"] = self_url
return response_status_json(new_load,
'application/json', 201,
self_url, None)
else:
errObj = {"Error": "Missing or Invalid JWTs"}
return (json.dumps(errObj), 401)
else:
error_obj = {
"Error": "The request mimetype should be application/json"
}
return (json.dumps(error_obj), 400)
elif request.method == 'GET':
if request.headers[
'Accept'] != '*/*' and 'application/json' not in request.headers[
'Accept']:
error_obj = {"Error": "Accept header must be application/json"}
return (json.dumps(error_obj), 406)
else:
query = client.query(kind=constants.loads)
q_limit = int(request.args.get('limit', '5'))
q_offset = int(request.args.get('offset', '0'))
l_iterator = query.fetch(limit=q_limit, offset=q_offset)
pages = l_iterator.pages
results = list(next(pages))
if l_iterator.next_page_token:
next_offset = q_offset + q_limit
next_url = request.base_url + "?limit=" + str(
q_limit) + "&offset=" + str(next_offset)
else:
next_url = None
for e in results:
e["id"] = e.key.id
e["self"] = str(request.base_url) + "/" + str(e.key.id)
if e['carrier'] is not None:
for f in e["carrier"]:
f["self"] = str(request.base_url) + "/" + str(f.key.id)
output = {"loads": results}
if next_url:
output["next"] = next_url
return response_status_json(output, 'application/json', 200, None,
None)
else:
error_obj = {"Error": "Method not recognized"}
return (json.dumps(error_obj), 405)
def setUp(self) -> None:
self.v = Validator(leather_serial_schema)
def validate(user_schema: dict) -> dict:
v = Validator()
v.validate(user_schema, user())
return v.errors
def __init__(self, document): super(Validate, self).__init__() self.v = Validator() self.__validate(document)
def validate_doc_microbial(d):
v = Validator(mygene_schema_microbe, allow_unknown=True)
v.validate(d)
if v.errors:
raise ValueError(v.errors)
return v.document
def validate(self):
"""
Validates the action_block based on the cerberus schema
example:: ansible_action_block::::
- name: build_openshift_cluster
type: ansible
actions:
- playbook: test_playbook.yaml
vars: test_var.yaml
extra_vars: { "testvar": "world"}
"""
schema = {
'name': {
'type': 'string',
'required': True
},
'type': {
'type': 'string',
'allowed': ['ansible']
},
'path': {
'type': 'string',
'required': False
},
'context': {
'type': 'boolean',
'required': False
},
'vault_password_file': {
'type': 'string',
'required': False
},
'src': {
'type': 'dict',
'schema': {
'type': {
'type': 'string',
'required': True
},
'url': {
'type': 'string',
'required': True
}
}
},
'actions': {
'type': 'list',
'schema': {
'type': 'dict',
'schema': {
'playbook': {
'type': 'string',
'required': True
},
'vars': {
'type': 'string',
'required': False
},
'extra_vars': {
'type': 'dict',
'required': False
}
}
},
'required': True
}
}
v = Validator(schema)
status = v.validate(self.action_data)
if not status:
raise HookError("Invalid syntax: {0}".format((v.errors)))
else:
return status
def flexio_handler(flex):
# get the api key from the variable input
auth_token = dict(flex.vars).get('fullcontact_api_key')
if auth_token is None:
raise ValueError
# get the input
input = flex.input.read()
try:
input = json.loads(input)
if not isinstance(input, list): raise ValueError
except ValueError:
raise ValueError
# define the expected parameters and map the values to the parameter names
# based on the positions of the keys/values
params = OrderedDict()
params['email'] = {'required': True, 'type': 'string'}
params['properties'] = {
'required': False,
'validator': validator_list,
'coerce': to_list,
'default': '*'
}
input = dict(zip(params.keys(), input))
# validate the mapped input against the validator
# if the input is valid return an error
v = Validator(params, allow_unknown=True)
input = v.validated(input)
if input is None:
raise ValueError
# map this function's property names to the API's property names
property_map = OrderedDict()
property_map['full_name'] = 'fullName'
property_map['age_range'] = 'ageRange'
property_map['gender'] = 'gender'
property_map['location'] = 'location'
property_map['title'] = 'title'
property_map['organization'] = 'organization'
property_map['twitter_url'] = 'twitter'
property_map['facebook_url'] = 'facebook'
property_map['linkedin_url'] = 'linkedin'
property_map['bio'] = 'bio'
property_map['avatar_url'] = 'avatar'
# get the properties to return and the property map
properties = [p.lower().strip() for p in input['properties']]
# if we have a wildcard, get all the properties
if len(properties) == 1 and properties[0] == '*':
properties = list(property_map.keys())
# see here for more info:
# https://docs.fullcontact.com/#person-enrichment
# https://dashboard.fullcontact.com/api-ref#response-codes-&-errors
data = json.dumps({'email': input['email'].lower().strip()})
headers = {
'Content-Type': 'application/json',
'Authorization': 'Bearer ' + auth_token
}
url = 'https://api.fullcontact.com/v3/person.enrich'
# get the response data as a JSON object
response = requests_retry_session().post(url, data=data, headers=headers)
# sometimes results are pending; for these, return text indicating
# the result is pending so the user can refresh later to look for
# the completed result
status_code = response.status_code
if status_code == 202:
flex.output.content_type = "application/json"
flex.output.write([['Result Pending...']])
return
# if a result can't be found or wasn't formatted properly,
# return a blank (equivalent to not finding a bad email address)
if status_code == 400 or status_code == 404 or status_code == 422:
flex.output.content_type = "application/json"
flex.output.write([['']])
return
# return an error for any other non-200 result
response.raise_for_status()
# limit the results to the requested properties
content = response.json()
properties = [
content.get(property_map.get(p, ''), '') or '' for p in properties
]
result = [properties]
# return the results
result = json.dumps(result, default=to_string)
flex.output.content_type = "application/json"
flex.output.write(result)
def valve_validation(input):
"""
Validate input['valve'] deeper than cerberus
Parameters
----------
input : dict
Structure holding input
Return
----------
: bool
True for success, False for failure
"""
schema_psv = {
'initial' : {'required' : True},
'calculation' : {'required' : True},
'validation' : {'required' : False},
'vessel' : {'required' : True},
'heat_transfer' : {'required' : False},
'valve':{
'required' : True,
'type': 'dict',
'allow_unknown': False,
'schema':{
'type': {'required' : True,'type': 'string', 'allowed': ['orifice', 'psv', 'controlvalve', 'mdot']},
'flow': {'required' : True,'type': 'string', 'allowed': ['discharge', 'filling']},
'diameter': {'required' : True,'type': 'number', 'min': 0},
'discharge_coef': {'required' : True,'type': 'number', 'min': 0},
'set_pressure': {'required' : True,'type': 'number', 'min': 0},
'end_pressure': {'type': 'number', 'min': 0},
'blowdown': {'required' : True,'type': 'number', 'min': 0, 'max': 1},
'back_pressure': {'required' : True,'type': 'number', 'min': 0},
'Cv': {'type': 'number', 'min': 0},
'mdot': {'type': ['number','list']},
'time' : {'type': 'list'},
}
},
}
schema_orifice = {
'initial' : {'required' : True},
'calculation' : {'required' : True},
'validation' : {'required' : False},
'vessel' : {'required' : True},
'heat_transfer' : {'required' : False},
'valve':{
'required' : True,
'type': 'dict',
'allow_unknown': False,
'schema':{
'type': {'required' : True,'type': 'string', 'allowed': ['orifice', 'psv', 'controlvalve', 'mdot']},
'flow': {'required' : True,'type': 'string', 'allowed': ['discharge', 'filling']},
'diameter': {'required' : True,'type': 'number', 'min': 0},
'discharge_coef': {'required' : True,'type': 'number', 'min': 0},
'set_pressure': {'type': 'number', 'min': 0},
'end_pressure': {'type': 'number', 'min': 0},
'blowdown': {'type': 'number', 'min': 0, 'max': 1},
'back_pressure': {'required' : True,'type': 'number', 'min': 0},
'Cv': {'type': 'number', 'min': 0},
'mdot': {'type': ['number','list']},
'time' : {'type': 'list'},
}
},
}
schema_control_valve = {
'initial' : {'required' : True},
'calculation' : {'required' : True},
'validation' : {'required' : False},
'vessel' : {'required' : True},
'heat_transfer' : {'required' : False},
'valve':{
'required' : True,
'type': 'dict',
'allow_unknown': False,
'schema':{
'type': {'required' : True,'type': 'string', 'allowed': ['orifice', 'psv', 'controlvalve', 'mdot']},
'flow': {'required' : True,'type': 'string', 'allowed': ['discharge', 'filling']},
'back_pressure': {'required' : True,'type': 'number', 'min': 0},
'Cv': {'required' : True,'type': 'number', 'min': 0},
'time_constant': {'type': 'number', 'min': 0},
'characteristic': {'type': 'string', 'allowed': ['linear', 'eq', 'fast']},
}
},
}
schema_mdot = {
'initial' : {'required' : True},
'calculation' : {'required' : True},
'validation' : {'required' : False},
'vessel' : {'required' : True},
'heat_transfer' : {'required' : False},
'valve':{
'required' : True,
'type': 'dict',
'allow_unknown': False,
'schema':{
'type': {'required' : True,'type': 'string', 'allowed': ['orifice', 'psv', 'controlvalve', 'mdot']},
'flow': {'required' : True,'type': 'string', 'allowed': ['discharge', 'filling']},
'mdot': {'required' : True,'type': ['number','list']},
'time' : {'required' : True,'type': ['number','list']},
'back_pressure': {'required' : True,'type': 'number', 'min': 0},
}
},
}
if input['valve']['type'] == 'psv':
v = Validator(schema_psv)
retval = v.validate(input)
if v.errors:
print(v.errors)
elif input['valve']['type'] == 'orifice':
v = Validator(schema_orifice)
retval = v.validate(input)
if v.errors:
print(v.errors)
elif input['valve']['type'] == 'controlvalve':
v = Validator(schema_control_valve)
retval = v.validate(input)
if v.errors:
print(v.errors)
elif input['valve']['type'] == 'mdot':
v = Validator(schema_mdot)
retval = v.validate(input)
if v.errors:
print(v.errors)
return retval
