class TrackerDto:
ns_trakers = api.namespace("tracker1",
description="Trackers related operations")
_tracker = ns_trakers.model(
"tracker1",
dict(tracker_id=fields.String(),
creation_date=formattedDateTime(),
name=fields.String(required=True),
asset_class=fields.String(),
theme=fields.String(),
direction=fields.String(required=True),
portal_name=fields.String(),
tickers=fields.List(fields.String(required=True)),
weights=fields.Raw(required=True),
lbound_weights=fields.Raw(required=True),
ubound_weights=fields.Raw(required=True),
volatility_target=fields.Float(required=True, min=0.0),
volatility_max=fields.Float(required=True, min=0.0),
volatility_tolerance=fields.Float(required=True, min=0.0),
volatility_duration=fields.Integer(required=True, min=0),
notional=fields.Float(required=True, min=0.0),
calibration_volume_threshold=fields.Float(required=True, min=0.0),
retails_units=fields.Raw(),
leverage=fields.Float(required=True),
min_risky=fields.Float(required=True),
gonogo_return=fields.Float(required=True),
gonogo_weight=fields.Float(required=True),
max_uncalibrate=fields.Integer(required=True),
factsheet_link=fields.String(),
performances=fields.Raw(),
benchmark=fields.String()))
class FxVolMC(Resource):
@api.response(200, "Success")
@api.expect(
api.model(
"fx vol calibration MC", {
"asOfDate": fields.String(default="2011-02-02"),
"marketDataDefinitions": fields.Raw(example=mdDef,
type="json"),
"marketData": fields.Raw(example=mdValues, type="json")
}))
def post(self):
"""
interpolation : smile axis
:return: the interpolated value
"""
content = request.get_json()
calib1FxVolMC = functools.partial(
calib1FxVol, parse(content["asOfDate"]), content["marketData"],
content["marketDataDefinitions"]["yieldCurves"])
pool = multiprocessing.Pool(multiprocessing.cpu_count() - 1)
surface = pool.starmap(
calib1FxVolMC,
zip(content["marketDataDefinitions"]["fxVolatilities"]))
pool.close()
pool.join()
pool.terminate()
#output result
output = outputFxVolCalibrated(surface, content)
return output
class InterpolationYC(Resource):
@api.response(200, "Success")
@api.expect(
api.model(
"interpolation of the yield curve", {
"asOfDate":
fields.String,
"date":
fields.String,
"marketDataDefinitions":
fields.Raw(example=yieldCurveDef, type="json"),
"marketData":
fields.Raw(example=yieldCurveValues, type="json")
}))
def post(self):
"""
interpolation : smile axis
:return: the interpolated value
"""
content = request.get_json()
values = content["marketData"]["yieldCurveValues"][0][
"discountFactors"]
definition = content["marketDataDefinitions"]["yieldCurves"][0]
asOf = datetime.strptime(content["asOfDate"], "%Y-%m-%d")
date = datetime.strptime(content["date"], "%Y-%m-%d")
df = computeDiscountFactor(values, definition, asOf, date)
# define model
return jsonify({"discountFactors": df})
def addServicesModel(self, ns):
addOutlet = ns.model(
'addOutletModel', {
'service_id':
fields.String(required=False, description="Provide service id"),
'outlet_id':
fields.String(required=True,
description="Provide newly added outlet id"),
'user_id':
fields.String(required=True,
min_length=1,
example=1,
description='User id is required'),
'vendor_id':
fields.String(required=True,
min_length=1,
example=1,
description='vendor id is required'),
'category_id':
fields.List(fields.String,
required=True,
description='Category id is required'),
'service_master_id':
fields.List(fields.String,
required=True,
description='Service master id is required'),
'name':
fields.String(required=True,
min_length=1,
description='Address is required'),
'benefits':
fields.List(
fields.String, required=False, description='City is required'),
'note':
fields.String(required=False, description='Note is required'),
'description':
fields.String(required=True,
description='Description is required'),
'images':
fields.List(fields.String,
required=False,
description='Images id is required'),
'buffer':
fields.Raw(fields.String,
required=True,
min_length=1,
description='Prices is required'),
'prices':
fields.Raw(fields.String,
required=True,
description='Prices is required'),
'is_combo':
fields.Integer(required=True, description='Note is required'),
})
return addOutlet
class FxVolPerFormanceMC(Resource):
@api.response(200, "Success")
@api.expect(
api.model(
"fx vol calibration performance", {
"marketData": fields.Raw(example=MdPerf, type="json"),
"asOfDate": fields.String(default="2011-02-02"),
"marketDataDefinitions": fields.Raw(example=MdDefPerf,
type="json")
}))
def post(self):
"""
interpolation : smile axis
:return: the interpolated value
"""
# All the program statements
start_json = timeit.default_timer()
content = request.get_json()
stop_json = timeit.default_timer()
start_MCBuilding = timeit.default_timer()
calib1FxVolMC = functools.partial(
calib1FxVol, parse(content["asOfDate"]), content["marketData"],
content["marketDataDefinitions"]["yieldCurves"])
pool = multiprocessing.Pool(multiprocessing.cpu_count() - 1)
end_MCBuilding = timeit.default_timer()
start_calib = timeit.default_timer()
surface = pool.starmap(
calib1FxVolMC,
zip(content["marketDataDefinitions"]["fxVolatilities"]))
pool.close()
pool.join()
pool.terminate()
stop_calib = timeit.default_timer()
# define model
start_output = timeit.default_timer()
output = outputFxVolCalibrated(surface, content)
stop_output = timeit.default_timer()
nb_surface = len(content["marketDataDefinitions"]["fxVolatilities"])
expiry = [
len(fxvol["expiries"])
for fxvol in content["marketDataDefinitions"]["fxVolatilities"]
]
return jsonify({
"nb Surface": nb_surface,
"nb expiry per curve": json.dumps(expiry),
"nb total expiry": int(np.sum(expiry)),
"total": stop_output - start_json,
"parsing input": stop_json - start_json,
"multicore setting": end_MCBuilding - start_MCBuilding,
"calibration : ": stop_calib - start_calib,
"paring output : ": stop_output - start_output
})
class fxVol(Resource):
@api.response(200,"Success")
@api.expect(api.model("fx vol calibration", {"asOfDate": fields.String(default="2011-02-02"),
"marketDataDefinitions": fields.Raw(example=mdDef, type="json"),
"marketData": fields.Raw(example=mdValues, type="json")
}))
def post(self):
"""
FX vol calibration mock
:return: calibrated fx vol
"""
# define model
return jsonify(outputFXVol)
def test_nested_object(self, mocker):
foo = mocker.Mock()
bar = mocker.Mock()
bar.value = 42
foo.bar = bar
field = fields.Raw()
assert field.output('bar.value', foo) == 42
def test_nested_object(self):
foo = Mock()
bar = Mock()
bar.value = 42
foo.bar = bar
field = fields.Raw()
assert_equal(field.output('bar.value', foo), 42)
class Heston(Resource):
@api.response(200,"Success")
@api.expect(api.model("heston calibration", {"calibrationDate": fields.String(default="2016-07-05"),
"marketDataSet": fields.String(default="DEFAULT"),
"marketDataProvider" : fields.String("PE_STORE_MDP"),
"inputs" : fields.Raw(example=inputs_heston, type="json"),
"marketData": fields.Raw(example=input_md, type="json")
}))
def post(self):
"""
Heston calibration mock
:return: heston parameters
"""
# define model
return jsonify({"calibrationResults":hestonOutput})
class CommonModels:
SuccessModel = IocManager.api.model(
'SuccessModel', {
'IsSuccess':
fields.Boolean(
description='Service finished operation with successfully',
default=True),
'Message':
fields.String(description='Service result values',
default="Operation Completed"),
'Result':
fields.Raw(description='Service result values'),
})
def date_converter(o):
if isinstance(o, datetime):
return o.__str__()
@staticmethod
def get_response(result=None, message=None):
return {'Result': result, 'Message': message}
@staticmethod
def get_error_response(message):
return {"IsSuccess": False, 'Message': message}
class ResponseModel:
"""
Add success model use in marshal_with for success return
"""
success_response = Model('success_response', {
'code': fields.String(required=True),
'message': fields.String(),
'result': fields.Raw(),
})
error_response = Model('error_response', {
'code': fields.String(required=True, description='error code'),
'message': fields.String(required=True, description='error message'),
'extra': fields.Raw(),
})
def build_response(message):
response = {'message': message}
model = Model('PostResponse',
{'message': fields.Raw(description='Message for post')})
return response, model
class ParseDto:
api = Namespace('parse',
description='parse invoice',
authorizations=authorizations)
image = api.model(
'image', {
'image':
fields.String(required=True,
description='base64 encode content of the image'),
'edit_image':
fields.Boolean(required=False,
description='Return the automatically edited'
'to bird view of image'),
'try_auto_edit':
fields.Boolean(required=False,
description='Should the parser try to '
'aut detect the edges and retry'
'parsing if failed')
})
response = api.model(
'parse_response', {
'data':
fields.Raw(required=True, description='json with parse results'),
'image':
fields.String(required=False,
description='base64 encode content of the edited '
'image')
})
headers = api.parser(). \
add_argument('Authorization', location='headers', help='server to server token')
class Lsv(Resource):
@api.response(200,"Success")
@api.expect(api.model("lsv pricing", {"marketDataProviderId": fields.String(default="PE_STORE_MDP"),
"marketDataSetId": fields.String(default="$id/DEFAULT"),"pricingConfigId" : fields.String(default="$id/DEFAULT-FXO"),
"pricingMethod": fields.String(default="PRACTICAL"),
"resultHandlerId": fields.String(default="Collector"),
"pricingDates": fields.List(fields.String(default = "2016-07-05")),
"scenarioContexts" : fields.Raw(example=scenarioContext,type="json"),
"perimeter" : fields.Raw(example=perimeter,type="json"),
"taskContext" : fields.Raw(example=taskContext,type="json")
}))
def post(self):
"""
pricing lsv :mock
:return: pricing result
"""
# define model
return jsonify(reponse)
class ErrorSchema:
"""
Add error marshal swagger for error return
"""
error_res = {
'code': fields.String(required=True, description='Error code'),
'message': fields.String(required=True, description='Error message'),
'success': fields.String(description='Error message'),
'data': fields.Raw(description='Error data')
}
def test_with_partial_attribute(self, mocker):
def f(x, suffix):
return '{0}-{1}'.format(x.value, suffix)
obj = mocker.Mock()
obj.value = 42
p = partial(f, suffix='whatever')
field = fields.Raw(attribute=p)
assert field.output('foo', obj) == '42-whatever'
class FxVolPerFormance(Resource):
@api.response(200, "Success")
@api.expect(
api.model(
"fx vol calibration performance", {
"marketData": fields.Raw(example=MdPerf, type="json"),
"asOfDate": fields.String(default="2011-02-02"),
"marketDataDefinitions": fields.Raw(example=MdDefPerf,
type="json")
}))
def post(self):
"""
interpolation : smile axis
:return: the interpolated value
"""
# All the program statements
start_json = timeit.default_timer()
content = request.get_json()
stop_json = timeit.default_timer()
start_calib = timeit.default_timer()
surface = constructFXVolSurface(content)
stop_calib = timeit.default_timer()
# define model
start_output = timeit.default_timer()
output = outputFxVolCalibrated(surface, content)
stop_output = timeit.default_timer()
nb_surface = len(content["marketDataDefinitions"]["fxVolatilities"])
expiry = [
len(fxvol["expiries"])
for fxvol in content["marketDataDefinitions"]["fxVolatilities"]
]
return jsonify({
"nb Surface": nb_surface,
"nb expiry per curve": json.dumps(expiry),
"nb total expiry": int(np.sum(expiry)),
"total": stop_output - start_json,
"parsing input": stop_json - start_json,
"calibration : ": stop_calib - start_calib,
"paring output : ": stop_output - start_output
})
class SABR(Resource):
@api.response(200, "Success")
@api.expect(
api.model(
"SABR calibration", {
"asOfDate": fields.String(default="2011-02-02"),
"marketDataDefinitions": fields.Raw(example=mdDef,
type="json"),
"marketData": fields.Raw(example=mdValues, type="json")
}))
def post(self):
"""
interpolation : smile axis
:return: the interpolated value
"""
content = request.get_json()
surface = constructFXVolSurface(content)
# define model
output = outputFxVolCalibrated(surface, content)
return output
def object_list_resp(api):
desc = {
"etag": "String",
"content_type": "String",
"is_dir": "Boolean",
"object_name": "String",
"metadata": "json",
"size": "String",
"bucket_name": "String",
"last_modified": "Timestamp (Seconds)"
}
resp = api.model('object_list_resp',
{'object-name': rest_fields.Raw(desc)})
return resp
def object_stats_resp(api):
desc = {
"size": "string",
"object_name": "string",
"bucket_name": "string",
"etag": "string",
"last_modified": "datetime",
"content_type": "string",
"is_dir": "string",
"metadata": "{}"
}
resp = api.model('object_stats_resp',
{'object-name': rest_fields.Raw(desc)})
return resp
def create_node_model(ns):
"""
"""
model = ns.model(
'Node', {
'id':
fields.Integer(description='node unique identifier in the graph'),
'labels':
fields.List(
fields.String(), required=True, description='node labels'),
'properties':
fields.Raw(required=True, description='Node properties')
})
return model
def add_serializers(self):
api = self.api
""" Serializador para formulario reducido de consignacion """
self.detalle_consignacion = api.model(
"Detalles menores de consignación", {
"elemento":
fields.Raw(
required=False,
description="Descripción del elemento en formato JSON"),
"no_consignacion":
fields.String(required=True, description="Id de elemento"),
"detalle":
fields.Raw(required=False,
description="json con detalle de la consignación"),
"responsable":
fields.String(
required=True,
description="responsable del ingreso de consignación")
})
""" Serializador para formulario extendido de consignacion"""
self.consignacion = api.model(
"Detalles de consignación", {
"no_consignacion":
fields.String(required=True, description="Id de elemento"),
"fecha_inicio":
fields.String(required=True,
description="formato: [yyyy-mm-dd hh:mm:ss]"),
"fecha_final":
fields.String(required=True,
description="formato: [yyyy-mm-dd hh:mm:ss]"),
"detalle":
fields.Raw(required=False,
description="json con detalle de la consignación")
})
return api
class LocationModel:
location = Model(
'location', {
'code':
fields.String(required=True, description='location code'),
'name':
fields.String(required=False, description='location name'),
'parentCode':
fields.String(required=True, description='location parent code'),
})
location_success = ResponseModel.success_response.clone(
'location_success', {'result': fields.List(fields.Nested(location))})
location_mapping_success = ResponseModel.success_response.clone(
'location_mapping_success',
{'result': fields.Raw(description="'location_code':'location_name'")})
class BranchModel:
branch = Model(
'branch', {
'code': fields.String(required=True, description='branch code'),
'name': fields.String(required=True, description='branch name'),
})
branch_success = ResponseModel.success_response.clone(
'branch_success', {'result': fields.List(fields.Nested(branch))})
branch_error = ResponseModel.error_response.clone('branch_error')
branch_mapping = Model('branch_mapping')
branch_mapping_success = ResponseModel.success_response.clone(
'branch_mapping_success',
{'result': fields.Raw(description="'branch_code':'branch_name'")})
class ReportRequestDto:
api = Namespace('reports',
description='Reports System - Report Generation Endpoints')
report_request = api.model(
'ReportRequest', {
'template':
fields.String(description='Base64 encoded HTML template'),
'template_name':
fields.String(description='Name of the template'),
'template_vars':
fields.Raw(
required=True,
description='JSON payload to replace the variables in template'
),
'report_name':
fields.String(required=True, description='Name of the report')
})
class WarehouseModel:
warehouse = Model(
'warehouse', {
'code':
fields.String(required=True, description='warehouse code'),
'name':
fields.String(required=False, description='warehouse name'),
'branchCode':
fields.String(required=False, description='warehouse branch code'),
})
warehouse_success = ResponseModel.success_response.clone(
'warehouse_success', {'result': fields.List(fields.Nested(warehouse))})
warehouse_mapping_success = ResponseModel.success_response.clone(
'warehouse_mapping_success', {
'result':
fields.Raw(description="'warehouse_code':'warehouse_name'")
})
class PostDto:
api = Namespace('article', description='article related operations')
article = api.model(
'article', {
'author':
fields.String(required=True, description="Author of the post"),
'title':
fields.String(required=True, description="Title of the post"),
'body':
fields.String(required=True, description="Body of the post"),
'post_time':
fields.DateTime(description="Time Created"),
'imgLinks':
fields.List(fields.String, description="ImgLinks"),
})
articleGen = api.model(
'articleGen', {
'author':
fields.String(required=True,
description="Username author of the post"),
'title':
fields.String(required=True, description="Title of the post"),
'body':
fields.String(required=True, description="Body of the post"),
'post_time':
fields.DateTime(description="Time Created"),
})
imgGen = api.model(
'imgGen', {
'image': fields.Raw(description="Raw Binary Data for images"),
})
tagList = api.model(
'tagList', {
'tags': fields.List(fields.String, description="Tags to searched"),
})
rating = api.model('rating', {
'score':
fields.Integer(required=True, description="Rating of the post")
})
class EdgeDetectorDto:
api = Namespace('detect_edges',
description='detect edges in image',
authorizations=authorizations)
image = api.model(
'image', {
'image':
fields.String(required=True,
description='base64 encode content of the image')
})
# TODO should be possible to specify exact output type via fields.List
response = api.model(
'edge_detector_response', {
'data':
fields.Raw(required=True,
description='coordinate of edges as a 4x2 list '
'of integers ')
})
headers = api.parser(). \
add_argument('Authorization', location='headers', help='server to server token')
class TransactionsDTO:
api = Namespace('transaction', description='Cash change transaction')
transaction = api.model(
'transaction', {
'product_name':
fields.String(required=True,
description='transaction product name'),
'product_value':
fields.Float(required=True,
description='transaction product value'),
'client_cash':
fields.Float(required=True, description='transaction client cash')
})
transaction_update_by_id = api.model(
'transaction_update_by_name', {
'new_product_name':
fields.String(required=True,
description='transaction product name'),
'transaction_id':
fields.Integer(required=True, description='transaction id'),
})
transaction_delete_by_id = api.model(
'transaction_delete_by_id', {
'transaction_id':
fields.Integer(required=True, description='transaction id'),
})
transaction_list = api.model(
'transaction_list', {
'product_name':
fields.String(description='transaction product name'),
'product_value':
fields.Float(description='transaction product value'),
'transaction_date':
fields.DateTime(description='transaction transaction date'),
'client_cash':
fields.Float(description='transaction client cash'),
'cash_change':
fields.Float(description='transaction cash change'),
'money_bills':
fields.List(fields.Raw(description='transaction money bills'))
})
class SrmProductSchema:
srm_product = {
# 'fe_id': fields.Integer(required=True, description='Product id generated at seller_center'),
'defaultCode': fields.String(required=True, description='Default code'),
'name': fields.String(required=True, description='Name'),
'shortName': fields.String(required=False, description='Feature name'),
'partNumber': fields.String(required=False, description='Part Number'),
'attributeValueCode': fields.String(required=False, description='Property (color)'),
'type': fields.String(required=True, description='Product type:\
- consu: Product does not manage inventory (Allow to sell negative)\
- product: Product with inventory management and storage', enum=['consu','product']),
'barcode': fields.String(required=True, description='Barcode'),
'productBrandCode': fields.String(required=True, description='Brand code'),
'categCode': fields.String(required=True, description='Category'),
'uomName': fields.String(required=True, description='Unit'),
'uomPoName': fields.String(required=True, description='Purchase unit of measurement'),
'salePoint': fields.Float(required=False, description='Product points'),
'warrantyPeriod': fields.Float(required=False, description='Warranty period'),
'warrantyNote': fields.String(required=False, description='Warranty notes'),
'exchangePeriod': fields.Integer(required=False, description='1-1 Exchange period (day)'),
'warrantyStampQty': fields.Integer(required=False, description='Number of warranty stamps'),
'saleOnlineOnly': fields.Boolean(required=True, description='Sale online only', default=False),
'supportDelivery': fields.Boolean(required=True, description='Support delivery', default=False),
'productStatus': fields.Integer(required=False, description='Status'),
'costPriceCalc': fields.Boolean(required=True, description='Calculate cost price', default=False),
'tracking': fields.String(required=True, description='tracking', default=None),
'note': fields.String(required=False, description='Note'),
'isUncounted': fields.Boolean(required=True, description='No tally', default=False),
'isService': fields.Boolean(required=True, description='Product service', default=False),
}
srm_product_req = srm_product.copy()
srm_product_res = {
'code': fields.Integer(required=True, description='Code'),
'message': fields.String(required=True, description='Message'),
'success': fields.String(description='Success message'),
'data': fields.Raw(description='Data')
}
