from sqlalchemy import desc api = Namespace("dancing_class", description="Classes") def all_dancing_classes(): return [ d.json() for d in DancingClass.query.order_by( desc(DancingClass.datetime)).all() ] model_dancing_class = api.model( "DancingClass", { "name": fields.String(required=True), "datetime": fields.DateTime(required=True), }) model_dancing_class_person = api.model( "DancingClassPerson", { "person_id": fields.Integer(required=True), "notes": fields.String(required=False), }) model_dancing_class_couple = api.model( "DancingClassCouple", { "person_id": fields.Integer(required=True), "partner_id": fields.Integer(required=True), }) model_couple = api.model("Couple", { "couple_id": fields.Integer(required=True), })
def test_rfc822_value(self, value, expected): self.assert_field(fields.DateTime(dt_format="rfc822"), value, expected)
def test_unsupported_format(self): field = fields.DateTime(dt_format="raw") self.assert_field_raises(field, datetime.now())
def test_min_as_date(self): field = fields.DateTime(min=date(1984, 6, 7)) assert "minimum" in field.__schema__ assert field.__schema__["minimum"] == "1984-06-07T00:00:00" assert "exclusiveMinimum" not in field.__schema__
def test_max_as_datetime(self): field = fields.DateTime(max=datetime(1984, 6, 7, 1, 2, 0)) assert "maximum" in field.__schema__ assert field.__schema__["maximum"] == "1984-06-07T01:02:00" assert "exclusiveMaximum" not in field.__schema__
class ArticleModel: def __init__(self, api): self.api = api article_id = fields.Integer( title="articleId", description="記事ID", example=1, ) title = fields.String( title="title", description="記事タイトル", example="flask-restxの使い方", required=True, ) body = fields.String( title="body", description="記事本文", example="hogehoge", ) created_at = fields.DateTime( title="createdAt", description="作成日", ) created_by = fields.String( title="createdBy", description="作成者", example="山田 太郎", ) updated_at = fields.DateTime( title="updatedAt", description="更新日", ) updated_by = fields.String( title="updatedBy", description="更新者", example="山田 太郎", ) def article_post_request_model(self): return self.api.model( "Article post request model", model={ "title": self.title, "body": self.body, }, ) def article_put_request_model(self): return self.api.model( "Article put request model", model={ "title": self.title, "body": self.body, }, ) def article_get_response_model(self): return self.api.model( "Article get response model", model={ "ariticleId": self.article_id, "title": self.title, "body": self.body, "createdAt": self.created_at, "createdBy": self.created_by, "updatedAt": self.updated_at, "updatedBy": self.updated_by, }, )
default=1, help="Page number") parser.add_argument("per_page", type=int, required=False, default=10, help="Page size") # Response marshalling object = object_ns.model( "Object", { "name": fields.String(description="Object name."), "description": fields.String(description="Object description."), "last_updated": fields.DateTime(description="Updated time of the object."), "json_object": fields.Raw(description="The object."), }, ) metadata = object_ns.model( "metadata", { "count": fields.String(readonly=True, description="Total number of the items of the data."), "offset": fields.String( readonly=True, description= "Position of the first element of the data from the total data amount.",
from flask_restx import Namespace, Resource, fields from app.db import tweet_repository from app.models import Tweet api = Namespace('tweets') # Base route json_tweet = api.model( 'Tweet', { 'id': fields.Integer(required=True), 'text': fields.String(required=True, min_length=1), 'created_at': fields.DateTime(required=True), }) json_new_tweet = api.model( 'New tweet', { 'text': fields.String(required=True, min_length=1), # Don't allow empty string }) @api.route('/<int:tweet_id>') # route extension (ie: /tweets/<int:id>) @api.response(404, 'Tweet not found') @api.param('tweet_id', 'The tweet unique identifier') class TweetResource(Resource): @api.marshal_with(json_tweet) # Used to control JSON response format def get(self, tweet_id): # GET method tweet = tweet_repository.get(tweet_id) if tweet is None: api.abort( 404
'username': fields.String(required=True, description='The user username'), 'videoname': fields.String( required=True, description='The videoname the user did the experience with'), 'videotype': fields.String( required=True, description='The videoname type (either continuous or intermittent)' ), 'input': fields.String(required=True, description='The user input'), 'dateExperience': fields.DateTime( required=True, description='The date which the user took the experience') }) EPFeelingsScreenshots = api.model( 'EPFeelingScreenshots', { 'username': fields.String(required=True, description='The user username'), 'feeling': fields.String( required=True, description='The feeling associated with the screenshot'), 'source': fields.String(required=True, description='The source of the image'), }) EPReactionsScreenshots = api.model( 'EPReactionScreenshots', {
from backend.common.db.repository.patient_repository import PatientRepository from backend.heparin.heparin_dosage import recommended_heparin, HeparinRecommendation from backend.insulin.insulin_dosage import recommended_insulin logger = logging.getLogger(__name__) # create the namespace namespace = Namespace('recommendation') heparin_recommendation_out = { 'actual_heparin_continuous_dosage': fields.Float(required=True, description='Actual heparin continuous dosage.'), 'previous_heparin_continuous_dosage': fields.Float(required=True, description='Previous heparin continuous dosage.'), 'actual_heparin_bolus_dosage': fields.Float(required=True, description='Actual heparin bolus dosage.'), 'previous_heparin_bolus_dosage': fields.Float(required=True, description='Previous heparin bolus dosage.'), 'next_remainder': fields.DateTime(required=True, description='Next reminder.'), 'doctor_warning': fields.String(required=False, description='Doctor warning.'), } def heparin_recommendation_to_out( heparin_recommendation: HeparinRecommendation, previous_heparin_continuous_dosage: float, previous_heparin_bolus_dosage: float ): return { 'actual_heparin_continuous_dosage': float(heparin_recommendation.heparin_continuous_dosage), 'previous_heparin_continuous_dosage': previous_heparin_continuous_dosage, 'actual_heparin_bolus_dosage': float(heparin_recommendation.heparin_bolus_dosage), 'previous_heparin_bolus_dosage': previous_heparin_bolus_dosage, 'next_remainder': heparin_recommendation.next_remainder.isoformat(),
parser.add_argument("code_id", type=str, help="The id of the code (repository).") parser.add_argument("page", type=int, default=1, location="args") parser.add_argument("per_page", type=int, location="args") # Response marshalling code = code_ns.model( "Code", { "code_id": fields.String( description="The id of the code (repository).", ), "repository_url": fields.String(description="The URL of the repository."), "scm_type": fields.String(description="The type of the repository."), "last_updated": fields.DateTime(description="Last updated date."), }, ) code_list_fields = code_ns.model( "CodesList", { "metadata": fields.Raw( description= "Metada (number of page, current page, total number of items)."), "data": fields.List(fields.Nested(code), description="List of items."), }, )
api = Namespace("user", description="User administration related operations") user = api.model( "User", { "id": fields.String(required=True, description="The user identifier"), "firstname": fields.String(required=True, description="The user first name"), "lastname": fields.String(required=True, description="The user last name"), "username": fields.String(required=True, description="The user email/username"), "gender": fields.String(required=True, description="The user gender"), "activision_id": fields.String(required=True, description="The user gender"), "stream_type": fields.String(required=True, description="The user gender"), "stream_url": fields.String(required=True, description="The user gender"), "avatar_url": fields.String(required=True, description="The user gender"), "dob": fields.Date(required=False, description="The user date of birth"), "registration_date": fields.DateTime(required=False, description="The user date of registration"), }, ) create_user = reqparse.RequestParser() create_user.add_argument("firstname", type=str, required=True, location='json') create_user.add_argument("lastname", type=str, required=True, location='json') create_user.add_argument("username", type=str, required=True, location='json') create_user.add_argument("gender", type=str, required=True, location='json') create_user.add_argument("password", type=str, required=True, location='json') create_user.add_argument("dob", type=str, required=True, location='json', help='YYYY-MM-DD') @api.route("/") class CurrentUser(Resource):
api = Namespace( 'books', path='/', description='Book API', ) book_model = api.model( 'Book', { 'id': fields.String(), 'name': fields.String(), 'rating': fields.Float(), 'authorId': fields.String(), 'collaboratorId': fields.String(), 'published': fields.Date(), 'created': fields.DateTime(), 'updated': fields.DateTime(), 'author': fields.Raw(), 'collaborator': fields.Raw(), 'genre': fields.Raw(), }) book_schema = BookSchema() books_many_schema = BookSchema(many=True) @api.route('/book/<bookId>', endpoint='book_by_id') # noqa: E501 class BookResource(Resource): # type: ignore @api.doc(id='get-book-by-id', responses={ 401: 'Unauthorised',
from werkzeug.exceptions import BadRequest from typing import Optional from ..models.Bill import Bill from ..models.Category import Category from ..models.User import User from .api import api api = Namespace("bills", description="Bill related operations") bill = api.model('Bill', { 'amount': fields.Integer(required=True, description='Amount'), 'caregory_id': fields.Integer(required=True, description='category'), 'user_id': fields.Integer(required=True, description='user'), 'date': fields.DateTime(required=False, description='date'), }) @api.route("/<int:bill_id>") @api.doc( responses={404: "Bill not found"}, params={"bill_id": "The Bill ID"}) class BillResource(Resource): @api.marshal_with(bill, code=201) def get(self, bill_id): """ Get a list of all bills """ bills = Bill.find_by_date(date)
from app.extensions.api import api_v1 as api dict_schema = { 'sessionId': f_fields.Integer(required=True, description=''), 'beamLineSetupId': f_fields.Integer(required=False, description=''), 'proposalId': f_fields.Integer(required=True, description=''), 'beamCalendarId': f_fields.Integer(required=False, description=''), 'projectCode': f_fields.String(required=False, description=''), 'startDate': f_fields.DateTime(required=False, description=''), 'endDate': f_fields.DateTime(required=False, description=''), 'beamLineName': f_fields.String(required=False, description=''), 'scheduled': f_fields.Integer(required=False, description=''), 'nbShifts': f_fields.Integer(required=False, description=''), 'comments': f_fields.String(required=False, description=''), 'beamLineOperator': f_fields.String(required=False, description=''), 'bltimeStamp': f_fields.DateTime(required=True, description=''), 'visit_number':
dict_schema = { 'phasingProgramRunId': f_fields.Integer(required=True, description='Primary key (auto-incremented)'), 'phasingCommandLine': f_fields.String(required=False, description='Command line for phasing'), 'phasingPrograms': f_fields.String(required=False, description='Phasing programs (comma separated)'), 'phasingStatus': f_fields.Integer(required=False, description='success (1) / fail (0)'), 'phasingMessage': f_fields.String(required=False, description='warning, error,...'), 'phasingStartTime': f_fields.DateTime(required=False, description='Processing start time'), 'phasingEndTime': f_fields.DateTime(required=False, description='Processing end time'), 'phasingEnvironment': f_fields.String(required=False, description='Cpus, Nodes,...'), 'recordTimeStamp': f_fields.DateTime(required=False, description=''), } class PhasingProgramRunSchema(Schema): """Marshmallows schema class representing PhasingProgramRun table""" phasingProgramRunId = ma_fields.Integer() phasingCommandLine = ma_fields.String() phasingPrograms = ma_fields.String()
from flask_restx import fields from core.api import api beer_model = api.model( 'Beer', { 'id': fields.Integer(readOnly=True, description='The unique identifier of a beer.'), 'name': fields.String(required=True, description='Name of the beer.'), 'sku': fields.String(required=True, description='Stock Keeping Unit'), 'price': fields.String(required=True, description='Price of a single unit /bottle/ of beer.'), 'image': fields.String(required=True, description='Image containing the beer.'), 'time_created': fields.DateTime(required=True, description='Moment, in which the beer was created.'), 'time_modified': fields.DateTime( required=True, description='Moment, in which the beer was last modified.'), })
from flask_restx import Namespace, Resource, fields from app import db from app.models import Tweet api = Namespace('tweets') tweet = api.model( 'Tweet', { 'id': fields.Integer(readonly=True, description='The tweet unique identifier'), 'text': fields.String(required=True, description='The tweet message'), 'created_at': fields.DateTime(readonly=True, description='The creation date') }) @api.route('/') class TweetResource(Resource): @api.doc('get_tweet') @api.marshal_list_with(tweet) def get(self): return db.session.query(Tweet).all(), 200 @api.doc('create_tweet') @api.expect(tweet) @api.marshal_with(tweet, code=201) def post(self): """
__license__ = "LGPLv3+" from marshmallow import Schema, fields as ma_fields from flask_restx import fields as f_fields from marshmallow_jsonschema import JSONSchema from app.extensions.api import api_v1 as api dict_schema = { 'autoProcProgramMessageId': f_fields.Integer(required=True, description=''), 'autoProcProgramId': f_fields.Integer(required=False, description=''), 'recordTimeStamp': f_fields.DateTime(required=True, description=''), 'severity': f_fields.String(required=False, description='enum(ERROR,WARNING,INFO)'), 'message': f_fields.String(required=False, description=''), 'description': f_fields.String(required=False, description=''), } class AutoProcProgramMessageSchema(Schema): """Marshmallows schema class representing AutoProcProgramMessage table""" autoProcProgramMessageId = ma_fields.Integer() autoProcProgramId = ma_fields.Integer() recordTimeStamp = ma_fields.DateTime()
def __init__(self, ns_auth: Namespace, ns_teams: Namespace): user_register_model = { 'email': fields.String(max_length=EMAIL_MAX_LENGTH, required=True), 'name': fields.String(max_length=NAME_MAX_LENGTH, required=True), 'tempo': fields.Integer(min=0, required=True, description='Runners tempo, in secs/km'), 'password': fields.String(max_length=PASSWORD_MAX_LENGTH, required=True) } user_reset_model = { 'email': fields.String(max_length=EMAIL_MAX_LENGTH, required=True) } registration_error_keys = {} for key in user_register_model: registration_error_keys[key] = fields.List(fields.String, attribute=key) self.user_login = ns_auth.model( 'LoginRequest', { 'email': fields.String(max_length=EMAIL_MAX_LENGTH, required=True), 'password': fields.String(max_length=PASSWORD_MAX_LENGTH, required=True) }) self.user_register = ns_auth.model('RegisterRequest', user_register_model) self.user_reset = ns_auth.model('PasswordResetRequest', user_reset_model) self.user = ns_auth.model( 'User', { 'id': fields.String, 'email': fields.String(max_length=EMAIL_MAX_LENGTH, required=True), 'name': fields.String(max_length=NAME_MAX_LENGTH, required=True), 'tempo': fields.Float(min=0, required=True) }) self.import_model = ns_auth.model( 'Import', {'connection': fields.String(required=True)}) self.jwt_response = ns_auth.model( 'JWTResponse', { 'access_token': fields.String(required=True), 'refresh_token': fields.String, 'expires_at': fields.Integer(required=True), 'user': fields.Nested(self.user) }) self.jwt_refresh_response = ns_auth.model( 'JWTRefreshResponse', { 'access_token': fields.String(required=True), 'expires_at': fields.DateTime(required=True) }) self.error = ns_auth.model('ErrorResponse', {"msg": fields.String()}) self.security_bad_request = ns_auth.model('BadSecurityResponse', registration_error_keys) self.response_meta = ns_auth.model('ResponseMetadata', {'code': fields.Integer}) self.registration_error_keys = ns_auth.model('RegistrationErrorKeys', registration_error_keys) self.registration_response_body = ns_auth.model( 'RegistrationResponseBody', { 'csrf_token': fields.String, 'user': fields.Nested(self.user), 'errors': fields.Nested(self.registration_error_keys) }) self.registration_response = ns_auth.model( 'RegistrationResponse', { 'meta': fields.Nested(self.response_meta), 'response': fields.Nested(self.registration_response_body) }) self.stage = ns_teams.model( name='Stage', model={ 'index': fields.Integer(min=0, max=NUMBER_OF_STAGES - 1, required=True), 'email': fields.String(max_length=EMAIL_MAX_LENGTH, required=True), 'estimated_time': fields.Integer(min=0), 'real_time': fields.Integer(min=0), 'length': fields.Integer(min=0), 'id': fields.String }) self.team = ns_teams.model( 'Team', { 'id': fields.String, 'name': fields.String(max_length=TEAM_NAME_MAX_LENGTH, required=True), 'donation': fields.Float(min=0), 'average_tempo': fields.Integer( min=0, description='Average tempo for so far completed stages'), 'stages_completed': fields.Integer(min=0, max=NUMBER_OF_STAGES), 'start': fields.Integer( min=0, max=DAY_SECONDS, description= "Team's starting time of day, in seconds since midnight"), 'members': fields.List(fields.String(max_length=EMAIL_MAX_LENGTH), required=True), 'stages': fields.List(fields.Nested(self.stage)) }) self.team_list = ns_teams.model( 'TeamsList', {'teams': fields.List(fields.Nested(self.team))}) self.user_list = ns_teams.model( 'UserList', {'users': fields.List(fields.Nested(self.user))}) self.edit_stages_request = ns_teams.model( 'EditStagesRequest', {'stages': fields.List(fields.Nested(self.stage))}) self.add_members_request = ns_teams.model( 'AddMembersRequest', { 'members': fields.List(fields.String(max_length=EMAIL_MAX_LENGTH), required=True) }) self.vapid_public_key = ns_auth.model( 'VAPIDKey', {'public_key': fields.String(required=True)}) self.push_subscription_keys = ns_auth.model('PushSubscriptionKeys', { 'p256dh': fields.String(), 'auth': fields.String() }) self.push_subscription = ns_auth.model( 'PushSubscription', { 'endpoint': fields.String(required=True), 'expiration_time': fields.Integer(), 'keys': fields.Nested(self.push_subscription_keys) })
def test_defaults(self): field = fields.DateTime() assert not field.required assert field.__schema__ == {"type": "string", "format": "date-time"} self.assert_field(field, None, None)
'resolutionLimitLow': f_fields.Float(required=False, description='Low resolution limit'), 'resolutionLimitHigh': f_fields.Float(required=False, description='High resolution limit'), 'rMerge': f_fields.Float(required=False, description='Rmerge'), 'rMeasWithinIPlusIMinus': f_fields.Float(required=False, description='Rmeas (within I+/I-)'), 'rMeasAllIPlusIMinus': f_fields.Float(required=False, description='Rmeas (all I+ & I-)'), 'rPimWithinIPlusIMinus': f_fields.Float(required=False, description='Rpim (within I+/I-) '), 'rPimAllIPlusIMinus': f_fields.Float(required=False, description='Rpim (all I+ & I-)'), 'fractionalPartialBias': f_fields.Float(required=False, description='Fractional partial bias'), 'nTotalObservations': f_fields.Integer(required=False, description='Total number of observations'), 'nTotalUniqueObservations': f_fields.Integer(required=False, description='Total number unique'), 'meanIOverSigI': f_fields.Float(required=False, description='Mean((I)/sd(I))'), 'completeness': f_fields.Float(required=False, description='Completeness'), 'multiplicity': f_fields.Float(required=False, description='Multiplicity'), 'anomalousCompleteness': f_fields.Float(required=False, description='Anomalous completeness'), 'anomalousMultiplicity': f_fields.Float(required=False, description='Anomalous multiplicity'), 'recordTimeStamp': f_fields.DateTime(required=False, description='Creation or last update date/time'), 'anomalous': f_fields.Integer(required=False, description='boolean type:0 noanoum - 1 anoum'), 'ccHalf': f_fields.Float(required=False, description='information from XDS'), 'ccAnomalous': f_fields.Float(required=False, description=''), } class AutoProcScalingStatisticsSchema(Schema): """Marshmallows schema class representing AutoProcScalingStatistics table""" autoProcScalingStatisticsId = ma_fields.Integer() autoProcScalingId = ma_fields.Integer() scalingStatisticsType = ma_fields.String() comments = ma_fields.String() resolutionLimitLow = ma_fields.Float() resolutionLimitHigh = ma_fields.Float() rMerge = ma_fields.Float()
def test_max(self): field = fields.DateTime(max="1984-06-07T00:00:00") assert "maximum" in field.__schema__ assert field.__schema__["maximum"] == "1984-06-07T00:00:00" assert "exclusiveMaximum" not in field.__schema__
# Response marshalling release = release_ns.model( "Release", { "release_id": fields.String(description="The id of the release.", ), "version": fields.String(description="The version of the release."), "changes": fields.String(description="The changes related to the release."), "release_url": fields.String(description="The URL of the release."), "project_id": fields.String(description="The id of the project."), "published_at": fields.DateTime(description="Date of publication of the release."), }, ) release_list_fields = release_ns.model( "ReleasesList", { "metadata": fields.Raw( description= "Metada (number of page, current page, total number of items)."), "data": fields.List(fields.Nested(release), description="List of items."), }, )
def test_max_exclusive(self): field = fields.DateTime(max="1984-06-07T00:00:00", exclusiveMax=True) assert "maximum" in field.__schema__ assert field.__schema__["maximum"] == "1984-06-07T00:00:00" assert "exclusiveMaximum" in field.__schema__ assert field.__schema__["exclusiveMaximum"] is True
cpe_fields = {} cpe_fields['cpe_23_uri'] = fields.String(attribute='cpe_23_uri') cpe_fields['vendor'] = fields.String(attribute='vendor') cpe_fields['product'] = fields.String(attribute='product') cpe_fields['vulnerable'] = fields.Boolean(attribute='vulnerable') cvssv3_fields = {} cvssv3_fields['version'] = fields.String(attribute='version') cvssv3_fields['vector_string'] = fields.String(attribute='vector_string') cvssv3_fields['attack_vector'] = fields.String(attribute='attack_vector') cvssv3_fields['cvss3_score'] = fields.Float(attribute=('cvss3_score')) cve_fields = {} cve_fields['cve_id'] = fields.String(attribute='cve_id') cve_fields['description'] = fields.String(attribute='description') cve_fields['published_date'] = fields.DateTime(attribute='published_date') cve_fields['last_modified'] = fields.DateTime(attribute='last_modified') model_cotroller_1 = {} model_cotroller_1['cve_id'] = fields.String(attribute='cve_id') model_cotroller_1['description'] = fields.String(attribute='description') model_cotroller_1['published_date'] = fields.DateTime( attribute='published_date') model_cotroller_1['last_modified'] = fields.DateTime(attribute='last_modified') model_cotroller_1['cpes'] = fields.List(fields.Nested(cpe_fields)) model_cotroller_1['cvssv3'] = fields.Nested(cvssv3_fields) model_cotroller_2 = {} model_cotroller_2['cves'] = fields.List(fields.Nested(cve_fields))
def test_iso8601_value(self, value, expected): self.assert_field(fields.DateTime(dt_format="iso8601"), value, expected)
fields.String(required=True, description="Unique exercise name"), "description": fields.String(required=True, description="Description", default=False), "is_public": fields.Boolean( required=True, description="Is this riff exercise visible to everyone?", default=False), "root_key": fields.String( required=True, description= "Root key of exercise (for printing purposes in the future)", default=False), "created_at": fields.DateTime(), "created_by": fields.String(), "modified_at": fields.DateTime(), "gravatar_image": fields.String(), "tags": fields.Nested(tag_info_marshaller), "stars": fields.Integer(), "instrument_key": fields.String(), "instruments": fields.List(fields.String), },
def test_unsupported_value_format(self): field = fields.DateTime(dt_format="raw") self.assert_field_raises(field, "xxx")
'undulatorType3': f_fields.String(required=False, description=''), 'focalSpotSizeAtSample': f_fields.Float(required=False, description=''), 'focusingOptic': f_fields.String(required=False, description=''), 'beamDivergenceHorizontal': f_fields.Float(required=False, description=''), 'beamDivergenceVertical': f_fields.Float(required=False, description=''), 'polarisation': f_fields.Float(required=False, description=''), 'monochromatorType': f_fields.String(required=False, description=''), 'setupDate': f_fields.DateTime(required=False, description=''), 'synchrotronName': f_fields.String(required=False, description=''), 'maxExpTimePerDataCollection': f_fields.String(required=False, description=''), 'maxExposureTimePerImage': f_fields.Float(required=False, description='unit: seconds'), 'minExposureTimePerImage': f_fields.String(required=False, description=''), 'goniostatMaxOscillationSpeed': f_fields.String(required=False, description=''), 'goniostatMaxOscillationWidth': f_fields.String(required=False, description='unit: degrees'), 'goniostatMinOscillationWidth': f_fields.String(required=False, description=''), 'maxTransmission':