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') }