def test_marshal_nested_with_skip_none(self): model = OrderedDict([ ('foo', fields.Raw), ('fee', fields.Nested( OrderedDict([ ('fye', fields.String) ]), skip_none=True)) ]) marshal_fields = OrderedDict([('foo', 'bar'), ('bat', 'baz'), ('fee', None)]) output = marshal(marshal_fields, model, skip_none=True) expected = OrderedDict([('foo', 'bar')]) assert output == expected
def getTicketDisableBatchProcessModel(appObj): subModel = appObj.flastRestPlusAPIObject.model( 'TicketDisableBatchProcessSubModel', { 'ticketGUID': fields.String(default='DEFAULT', description='GUID for this ticket'), 'objectVersion': fields.String(default='DEFAULT', description='Object version'), }) return appObj.flastRestPlusAPIObject.model( 'TicketDisableBatchProcessModel', { 'tickets': fields.List(fields.Nested(subModel)), })
class BalanceRetrieve(Resource): balance_model = api.model('Balance Response', balance_retrieve_response_model) balance_wrapper = {"data": fields.List(fields.Nested(balance_model))} http_balance_response = api.inherit('HTTP Balance Response', httpResponseBase_response, balance_wrapper) @jwt_required @api.marshal_with(http_balance_response) def get(self): uuid = get_jwt_identity()['uuid'] return HttpResponse(data=retrieveBalance(uuid)), 200
def getLoginAPITicketModel(appObj): return appObj.flastRestPlusAPIObject.model( 'LoginAPITicketModel', { 'ticketType': fields.Nested(apiSharedModels.getTicketTypeModel(appObj)), 'isUsable': fields.String( default='INVALID', description='Is the ticket usable (INVALID, EXPIRED or USABLE)' ), 'expiry': fields.DateTime(dt_format=u'iso8601', description='Datetime ticket will expire') })
def test_marshal_wildcard_list(self): wild = fields.Wildcard(fields.List(fields.String)) wildcard_fields = OrderedDict([('*', wild)]) model = OrderedDict([('preview', fields.Nested(wildcard_fields))]) sub_dict = OrderedDict([ ('1:1', [1, 2, 3]), ('16:9', [4, 5, 6]), ('9:16', [7, 8, 9]) ]) marshal_dict = OrderedDict([('preview', sub_dict)]) output = marshal(marshal_dict, model) assert output == {'preview': {'9:16': ['7', '8', '9'], '16:9': ['4', '5', '6'], '1:1': ['1', '2', '3']}}
def test_marshal_list_of_nesteds(self): model = OrderedDict([ ('foo', fields.Raw), ('fee', fields.List(fields.Nested({ 'fye': fields.String }))) ]) marshal_fields = OrderedDict([('foo', 'bar'), ('bat', 'baz'), ('fee', {'fye': 'fum'})]) output = marshal(marshal_fields, model) expected = OrderedDict([('foo', 'bar'), ('fee', [OrderedDict([('fye', 'fum')])])]) assert output == expected
def test_marshal_wildcard_nested(self): nest = fields.Nested( OrderedDict([("thumbnail", fields.String), ("video", fields.String)]) ) wild = fields.Wildcard(nest) wildcard_fields = OrderedDict([("*", wild)]) model = OrderedDict([("preview", fields.Nested(wildcard_fields))]) sub_dict = OrderedDict( [ ("9:16", {"thumbnail": 24, "video": 12}), ("16:9", {"thumbnail": 25, "video": 11}), ("1:1", {"thumbnail": 26, "video": 10}), ] ) marshal_dict = OrderedDict([("preview", sub_dict)]) output = marshal(marshal_dict, model) assert output == { "preview": { "1:1": {"thumbnail": "26", "video": "10"}, "16:9": {"thumbnail": "25", "video": "11"}, "9:16": {"thumbnail": "24", "video": "12"}, } }
class AuthDto: api = Namespace("Authentication", description="Authenticate and receive tokens.") user_obj = api.model( "User object", { "id": fields.String, "first_name": fields.String, "last_name": fields.String, "full_name": fields.String, "date_joined": fields.DateTime, "email": fields.String, "is_superuser": fields.Boolean, "is_active": fields.Boolean, "is_staff": fields.Boolean, }, ) auth_login = api.model( "Login data", { "email": fields.String(required=True), "password": fields.String(required=True), }, ) auth_refresh = api.parser() auth_refresh.add_argument('Authorization', type=str, location='headers') auth_success = api.model( "Auth success response", { "status": fields.Boolean, "message": fields.String, "access_token": fields.String, "refresh_token": fields.String, "user": fields.Nested(user_obj), }, ) refresh_success = api.model( "Refresh success response", { "status": fields.Boolean, "message": fields.String, "access_token": fields.String, }, )
class HarvestingFormDto: api = Namespace('harvesting_form', description='harvesting_form related operations') harvesting_form = api.model('harvesting_form', { 'date': fields.Date(required=True, description='partial form'), 'time': fields.DateTime(required=True, description='partial form'), 'plot': fields.Integer(required=True, description='partial form'), 'quantity': fields.Integer(required=True, description='partial form'), 'harvest_quantity': fields.String(required=True, description='partial form'), 'note': fields.String(required=True, description='partial form'), }) harvesting_form_field_based = api.model('harvesting_form_field_based', { 'harvesting_form': fields.Nested(harvesting_form, required=True), 'field_required': fields.String(default=None, required=True, description="fields to make predictions on"), })
class IssueFormDto: api = Namespace('issue_form', description='issue_form related operations') issue_form = api.model('issue_form', { 'date': fields.Date(required=True, description='partial form'), 'time': fields.DateTime(required=True, description='partial form'), 'plot': fields.Integer(required=True, description='partial form'), 'issue_type': fields.Integer(required=True, description='partial form'), 'description': fields.String(required=True, description='partial form'), 'note': fields.String(required=True, description='partial form'), }) issue_form_field_based = api.model('issue_form_field_based', { 'issue_form': fields.Nested(issue_form, required=True), 'field_required': fields.String(default=None, required=True, description="fields to make predictions on"), })
class MapDto: api = Namespace('maps', description='Map object related operations') coordinate_model = api.model( 'Coordinate', { 'x': fields.Integer(required=True, description='x coordinate'), 'y': fields.Integer(required=True, description='y coordinate') }) map_model = api.model( 'Map', { '_id': ObjectIDField(description='Map ID'), 'height': fields.Integer(required=True, description='Map height'), 'width': fields.Integer(required=True, description='Map width'), 'tank1_start': fields.Nested(coordinate_model, required=True, description='Starting position for the first tank'), 'tank2_start': fields.Nested(coordinate_model, required=True, description='Starting position for the second tank') # 'obstacles': fields.List( # fields.List( # fields.Integer(), # # min_items=2, # # max_items=2, # description='An obstacle is a list of integers that represent X and Y coordinates on the map' # ), # description='The list of obstacles' # ), })
def test_marshal_list_of_nesteds(self): model = OrderedDict( [ ("foo", fields.Raw), ("fee", fields.List(fields.Nested({"fye": fields.String}))), ] ) marshal_fields = OrderedDict( [("foo", "bar"), ("bat", "baz"), ("fee", {"fye": "fum"})] ) output = marshal(marshal_fields, model) expected = OrderedDict( [("foo", "bar"), ("fee", [OrderedDict([("fye", "fum")])])] ) assert output == expected
def test_marshal_nested_with_null(self): model = OrderedDict([ ('foo', fields.Raw), ('fee', fields.Nested( OrderedDict([ ('fye', fields.String), ('blah', fields.String) ]), allow_null=True)) ]) marshal_fields = OrderedDict([('foo', 'bar'), ('bat', 'baz'), ('fee', None)]) output = marshal(marshal_fields, model) expected = OrderedDict([('foo', 'bar'), ('fee', None)]) assert output == expected
def get_api_dict(api: Api, depth: int = 0, name: str = 'ParsedDocument') -> Model: return api.model( name, { 'content': fields.Nested(DocumentContent.get_api_dict(api), description='Document content structure'), 'metadata': fields.Nested(DocumentMetadata.get_api_dict(api), allow_null=False, skip_none=True, description='Document meta information'), 'version': fields.String( description= 'the version of the program that parsed this document', example="2020.07.11"), 'warnings': fields.List( fields.String( description='list of warnings and possible errors', example="DOCX: seems that document corrupted")), 'attachments': fields.List(fields.Nested( api.model('others_ParsedDocument', {})), description='structure of attachments', required=False) if depth == get_config()['recursion_deep_attachments'] else fields.List( fields.Nested(ParsedDocument.get_api_dict( api, depth=depth + 1, name='refParsedDocument' + str(depth)), description='Attachment structure', required=False)) })
class BrandDto: api = Namespace('brand', description='brand related operations') brand = api.model('brand', { 'id': fields.Integer(required=False, description='brand id'), 'name': fields.String(required=True, description='brand name'), 'products': fields.List(fields.Nested(ProductDto.product)) }) post_brand = api.model('brand', { 'name': fields.String(required=True, description='brand name'), 'products': fields.List(fields.Integer(description='Product identifier')), }) put_brand = api.model('brand', { 'name': fields.String(required=False, description='brand name'), 'products': fields.List(fields.Integer(description='Product identifier')), })
def test_marshal_wildcard_list(self): wild = fields.Wildcard(fields.List(fields.String)) wildcard_fields = OrderedDict([("*", wild)]) model = OrderedDict([("preview", fields.Nested(wildcard_fields))]) sub_dict = OrderedDict([("1:1", [1, 2, 3]), ("16:9", [4, 5, 6]), ("9:16", [7, 8, 9])]) marshal_dict = OrderedDict([("preview", sub_dict)]) output = marshal(marshal_dict, model) assert output == { "preview": { "9:16": ["7", "8", "9"], "16:9": ["4", "5", "6"], "1:1": ["1", "2", "3"], } }
def test_marshal_nested_with_skip_none(self): model = OrderedDict([ ("foo", fields.Raw), ( "fee", fields.Nested(OrderedDict([("fye", fields.String)]), skip_none=True, allow_null=True), ), ( "bee", fields.Nested(OrderedDict([("bye", fields.String)]), skip_none=True), ), ]) marshal_fields = OrderedDict([ ("foo", "bar"), ("bat", "baz"), ("fee", None), ("bee", {}), ]) output = marshal(marshal_fields, model, skip_none=True) expected = OrderedDict([("foo", "bar"), ("bee", {})]) assert output == expected
class InstagramDTO: api = Namespace('instagram', description='instagram related operations') comment = api.model( 'InstagramComment', { 'id': fields.String, 'text': fields.String, 'created_at': fields.DateTime, 'username': fields.String, 'sentiment': fields.String }) response = api.model( 'InstagramResponse', { 'comments': fields.List(fields.Nested(comment)), 'has_next_page': fields.Boolean, 'new_end_cursor': fields.String })
class User(Resource): res_userinfo = UserNs.impl.model( 'user_list', { 'status': fields.String(required=True, description='status'), 'message': fields.String(required=True, description='status'), 'data': fields.Nested(UserNs.userinfo) }) @UserNs.impl.doc('get a user') @UserNs.impl.marshal_with(res_userinfo) def get(self, public_id): user = get_a_user(public_id) if not user: UserNs.impl.abort(404, 'cant find user', status='fail') else: return {'status': 'success', 'message': 'list', 'data': user}
class AuthDto: api = Namespace("auth", description="authentication related operations") users_payload = UsersDto.users_payload auth_response = api.inherit( "AuthenticationResponse", UsersDto.user_response, {"auth_token": fields.String(description="authentication token")}, ) logout_response = api.inherit( "LogoutResponse", BaseDto.response, {"message": fields.String(description="success or failure message")}, ) user = UsersDto.user user_status_response = api.inherit("UserStatusResponse", BaseDto.response, {"data": fields.Nested(user)})
class TaskDto(): api = Namespace('tasks', description='Task api information') model_content = api.model( 'content', { 'text': fields.String(required=True, description='text value'), 'created_on': fields.Date(description='YYYY-MM-DD'), 'updated_on': fields.Date(description='YYYY-MM-DD'), }) model_nest = fields.Nested(model_content) model_wild = fields.Wildcard(model_nest) task = api.model('task', {'*': model_wild})
class PatientsLists(Resource): model = namespace.model( 'PatientsData', { 'patients': fields.List(required=True, cls_or_instance=fields.Nested(patient_out)), }) @namespace.response(code=200, model=model, description='') @namespace.response( code=500, model=failed_response, description='Unexpected error, see contents for details.') def get(self): patients = PatientRepository.get_all_active() result = [] for pa in patients: result.append(_patient_model_to_dto(pa)) return result @namespace.doc(body=patient_in_post_put) @namespace.response(code=200, model=patient_out, description='') @namespace.response(code=400, model=failed_response, description='') @namespace.response(code=401, model=failed_response, description='') @namespace.response(code=500, model=failed_response, description='') def post(self): post_data = request.get_json() pa = PatientModel(first_name=post_data['first_name'], last_name=post_data['last_name'], date_of_birth=_parse_datetime( post_data['date_of_birth']), height=float(post_data['height']), weight=float(post_data['weight']), sex=post_data['sex'], active=True, heparin=False, insulin=False, target_aptt_low=None, target_aptt_high=None, solution_heparin_iu=25000, solution_ml=500, tddi=None, target_glycemia=None, other_params={}) return _update_patient(pa, post_data, True)
def getTicketWithCaculatedFieldsModel(appObj): return appObj.flastRestPlusAPIObject.model( 'TicketTypeWithCaculated', { 'id': fields.String( default='DEFAULT', description='Unique identifier of Ticket - used in URL'), 'typeGUID': fields.String( default='DEFAULT', description='Unique identifier of Ticket - used in URL'), 'expiry': fields.DateTime(dt_format=u'iso8601', description='Datetime ticket will expire'), 'foreignKey': fields.String( default='DEFAULT', description='Unique identifier of Ticket - used in URL'), 'usedDate': fields.DateTime( dt_format=u'iso8601', description='Datetime ticket was used or none if it wasn\'t'), 'useWithUserID': fields.String( default=None, description='Unique identifier of Ticket - used in URL'), 'reissueRequestedDate': fields.DateTime( dt_format=u'iso8601', description='Datetime ticket was reissueRequestedDate'), 'reissuedTicketID': fields.String( default=None, description='Unique identifier of Ticket - used in URL'), 'disabled': fields.Boolean(default=False, description='Has this ticket been disabled'), RepositoryObjBaseClass.getMetadataElementKey(): fields.Nested( RepositoryObjBaseClass.getMetadataModel( appObj, flaskrestplusfields=fields)), # Extra below 'usableState': fields.String(default='DEFAULT', description='Usable state of this ticket') })
class InventoryDto: api = Namespace('inventory', description='inventory related operations') inventory = api.model('inventory', { 'id': fields.Integer(required=False, description='inventory id'), 'name': fields.String(required=True, description='inventory name'), 'store_id': fields.Integer(required=True, description='store to which inventory belongs'), 'products': fields.List(fields.Nested(ProductDto.product)) }) post_inventory = api.model('inventory', { 'store_id': fields.Integer(required=True, description='store to which inventory belongs'), 'name': fields.String(required=True, description='brand name'), 'products': fields.List(fields.Integer(description="Product identifiers")) }) put_inventory = api.model('inventory', { 'name': fields.String(required=False, description='brand name'), 'products': fields.List(fields.Integer(description="Product identifiers")) })
def test_marshal_nested_ordered(self): model = OrderedDict( [("foo", fields.Raw), ("fee", fields.Nested({"fye": fields.String,}))] ) marshal_fields = { "foo": "bar", "bat": "baz", "fee": {"fye": "fum"}, } expected = OrderedDict([("foo", "bar"), ("fee", OrderedDict([("fye", "fum")]))]) output = marshal(marshal_fields, model, ordered=True) assert isinstance(output, OrderedDict) assert output == expected assert isinstance(output["fee"], OrderedDict)
class AttachmentModel(ModelCreator): id = create_id_field( required=True, description="Attachment ID in database", ) author = fields.Nested(full_employee) post = create_id_field( required=True, description="ID of Post that contains this attachment") filename = fields.String(required=True, description="Name of an attachment", example="gravity_gun_firmware.bin", min_length=1) size = fields.Integer(required=True, description="Size of attachment (in bytes)", example=256256, min=0, max=MAX_FILE_SIZE)
def test_marshal_nested_with_null(self): model = OrderedDict([ ("foo", fields.Raw), ( "fee", fields.Nested( OrderedDict([("fye", fields.String), ("blah", fields.String)]), allow_null=True, ), ), ]) marshal_fields = OrderedDict([("foo", "bar"), ("bat", "baz"), ("fee", None)]) output = marshal(marshal_fields, model) expected = OrderedDict([("foo", "bar"), ("fee", None)]) assert output == expected
def getCreateTicketTypeModel(appObj): return appObj.flastRestPlusAPIObject.model( 'CreateTicketType', { 'tenantName': fields.String(default='DEFAULT', description='Tenant name for this ticket type'), 'ticketTypeName': fields.String(default='DEFAULT', description='Name displayed on admin screent'), 'description': fields.String(default='DEFAULT', description='Description of ticket type'), 'enabled': fields.Boolean( default=False, description='Can the ticket type currently be used'), 'welcomeMessage': fields.Nested(getCreateTicketTypeModel_welcomeMessage(appObj), skip_none=True), 'allowUserCreation': fields.Boolean( default=False, description= 'Allow unknown logins to create new users when using this ticket.' ), 'issueDuration': fields.Integer( default='DEFAULT', description='Hours to issue ticket for on creation'), 'roles': fields.List( fields.String( default='DEFAULT', description='List of roles this tickert type will assign') ), 'postUseURL': fields.String( default='DEFAULT', description='URL to send user to after ticket is used'), 'postInvalidURL': fields.String( default='DEFAULT', description= 'URL to send user to after invalid or request validaiton') })
class HDDSMARTPredictionDto: api = Namespace('HDDSMARTPrediction', description='HDDSMARTPrediction related operations') smart_prediction = api.model( 'SMARTPrediction', { 'track_dev_id': fields.String(30, description='tracked device id', example="0"), 'timestamp': fields.String(30, description='Prediction Timestamp', example="2019-12-01 14:20:30"), 'model': fields.String(required=True, description='HDD model', example="XYZ"), 'serial_number': fields.String(required=True, description='HDD serial number', example="HD00"), 'capacity_bytes': fields.Integer(example=1000000000), 'failure': fields.Integer, 'prediction': fields.Float } ) prediction_list_example = {'prediction_list': [ { "track_dev_id": "0", "timestamp": "2019-12-01 14:20:30", "model": "XYZ", "serial_number": "HD00", "capacity_bytes": 1000000000, "failure": 0, "prediction": 0 }, { "track_dev_id": "1", "timestamp": "2019-12-01 14:20:40", "model": "UVT", "serial_number": "00DH", "capacity_bytes": 1000000001, "failure": 1, "prediction": 1 } ] } smart_prediction_list = api.model( 'SMARTPredictionList', { 'prediction_list': fields.List(fields.Nested(smart_prediction)) } )
class ApplicationFormDto: api = Namespace('application_form', description='application_form related operations') application_form = api.model('application_form', { 'date': fields.Date(required=True, description='partial form'), 'time': fields.DateTime(required=True, description='partial form'), 'plot': fields.Integer(required=True, description='partial form'), 'product': fields.String(required=True, description='partial form'), 'quantity': fields.Integer(required=True, description='partial form'), 'dose': fields.Float(required=True, description='partial form'), 'machine': fields.String(required=True, description='partial form'), 'note': fields.String(required=True, description='partial form'), }) application_form_field_based = api.model('application_form_field_based', { 'application_form': fields.Nested(application_form, required=True), 'field_required': fields.String(default=None, required=True, description="fields to make predictions on"), })