abort_bad_path_param("version", full_ns) args = full_recommended_track_parser.parse_args() limit = format_limit(args, default_limit=DEFAULT_RECOMMENDED_LIMIT) args["limit"] = max(TRENDING_LIMIT, limit) strategy = trending_strategy_factory.get_strategy( TrendingType.TRACKS, version_list[0]) full_recommended_tracks = get_full_recommended_tracks( request, args, strategy) return success_response(full_recommended_tracks[:limit]) trending_ids_route_parser = trending_parser.copy() trending_ids_route_parser.remove_argument("time") track_id = full_ns.model("track_id", {"id": fields.String(required=True)}) trending_times_ids = full_ns.model( "trending_times_ids", { "week": fields.List(fields.Nested(track_id)), "month": fields.List(fields.Nested(track_id)), "year": fields.List(fields.Nested(track_id)), }, ) trending_ids_response = make_response("trending_ids_response", full_ns, fields.Nested(trending_times_ids)) @full_ns.route( "/trending/ids", defaults={"version": DEFAULT_TRENDING_VERSIONS[TrendingType.TRACKS].name},
""" Module for Swagger category models """ from flask_restx import fields from ..collections import property_namespace booking_model = property_namespace.model( 'Booking', { 'checkin_date': fields.String(required=True, description='Booking checkin date'), 'checkout_date': fields.String(required=True, description='Booking checkout date'), })
from werkzeug.exceptions import BadRequest from solutions import create_api, create_app, mainTitle, course4_field_names app = create_app() # pylint: disable=invalid-name api = create_api(app, mainTitle, 'Example Employee API') # pylint: disable=invalid-name CSV_FILE_NAME = '/../example.csv' API_MODEL = api.model( 'Employee', { 'employee_id': fields.Integer(required=True, description='Id of the employee'), 'name': fields.String(required=True, min_length=1, max_length=200, description='Name of the employee') }) logger.getLogger().setLevel(logger.INFO) @api.route('/employee/<string:employee_id>') class Csv(Resource): """Class for the employee API""" @staticmethod def get(employee_id): """GET endpoint for retrieving employee info with the given employee_id""" try: return jsonify(retrieve_employee_with_id(employee_id)) except KeyError:
__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 = { 'autoProcProgramId': f_fields.Integer(required=True, description='Primary key (auto-incremented)'), 'processingCommandLine': f_fields.String( required=False, description='Command line for running the automatic processing'), 'processingPrograms': f_fields.String(required=False, description='Processing programs (comma separated)'), 'processingStatus': f_fields.Integer(required=False, description='success (1) / fail (0)'), 'processingMessage': f_fields.String(required=False, description='warning, error,...'), 'processingStartTime': f_fields.DateTime(required=False, description='Processing start time'), 'processingEndTime': f_fields.DateTime(required=False, description='Processing end time'), 'processingEnvironment': f_fields.String(required=False, description='Cpus, Nodes,...'), 'recordTimeStamp':
class cb1: rap = Namespace('/', description='CB1') res = rap.model('result', {'ResultFlag': fields.String(description="ResultFlag")})
class Order_Crwaler(Resource): signin_fields_account = order.model( "order_crwaler", { "token": fields.String( description="Access Token", required=True, example="token"), "jobName": fields.String( description="Login Account", required=True, example="JobName"), "param": fields.String( description="json to String", required=True, example="JobName") }) def post(self): """ User sign in API """ rv, code = {}, 201 try: req = request.json hasKey = ["token", "jobName", "param"] isKey = Utils.isDicHasKey(req, hasKey) if not isKey: return ReqCode.notKey.value, 400 isNullKey = Utils.isDicKeyValueNull(req, hasKey) if not isNullKey: return ReqCode.keyValNull.value, 400 hasKey = ["email", "password"] isKey = Utils.isDicHasKey(req["account"], hasKey) if not isKey: return ReqCode.notKey.value, 400 isNullKey = Utils.isDicKeyValueNull(req["account"], hasKey) if not isNullKey: return ReqCode.keyValNull.value, 400 # Import user information from MariaDB account = req["account"] userInfo = MariaUserSql().getAccountInfo(account) if not userInfo['result']: rv = CommonCode.UnknownError.value rv = userInfo['msg'] return rv, 400 if userInfo['data'] is None: return SignCode.SignFail.value, 400 # if userInfo[''] is null: pwdChk = Encryption().checkBcrypt(userInfo["data"]["password"], account["password"]) # Create session if passwords match if pwdChk: session = RedisSession().createSession( userInfo["data"]["email"]) rv = copy.deepcopy(CommonCode.Success.value) rv["data"] = {"session": session} else: rv, code = SignCode.SignFail.value, 400 except Exception as ex: rv = copy.deepcopy(CommonCode.UnknownError.value) rv["msg"] = str(ex) code = 400 return rv, code # ,header{"hi": "hello"}
# from maxfw.core import MAX_API, PredictAPI from core.model import ModelWrapper from flask import abort from flask_restx import fields from werkzeug.datastructures import FileStorage # Set up parser for image input data image_parser = MAX_API.parser() image_parser.add_argument('image', type=FileStorage, location='files', required=True, help="An image file") label_prediction = MAX_API.model('LabelPrediction', { 'index': fields.String(required=False, description='Labels ranked by highest probability'), 'caption': fields.String(required=True, description='Caption generated by image'), 'probability': fields.Float(required=True, description="Probability of the caption") }) predict_response = MAX_API.model('ModelPredictResponse', { 'status': fields.String(required=True, description='Response status message'), 'predictions': fields.List(fields.Nested(label_prediction), description='Predicted captions and probabilities') }) class ModelPredictAPI(PredictAPI): model_wrapper = ModelWrapper() @MAX_API.doc('predict')
"""__init__ module for the solutions package""" from flask import Flask from flask_restx import Api, Resource, fields from werkzeug.middleware.proxy_fix import ProxyFix from texts import mainTitle, descriptiveTextCourse1 MY_NAME = 'Wietse' QUESTION1_TEMPLATE = 'My name is {0}!' API_MODEL_COURSE3 = 'AwesomeDictionary', { 'Original request': fields.String(required=True, min_length=1, max_length=200, description='Original request') } awesome_dictionary_to_return = { "Most awesome programming language.": "Python", "Reason": "You dont need a reason.", "Why": "Just try to do these labs in another language.", "Original request": "" } course4_field_names = ['employee_id', 'name'] def create_app(): """Function creating the Flask app""" app = Flask(__name__) app.wsgi_app = ProxyFix(app.wsgi_app)
import source.backend.db as db from bson.objectid import ObjectId import logging import datetime logger = logging.getLogger(__name__) mongo = db.mongo api = Namespace("posts", description="Posts related routes", path="/api/posts") post = api.model( "Post", { "_id": fields.String(description="Post ID"), "user": fields.String(description="Belong to user"), "username": fields.String(), "title": fields.String(), "content": fields.String(), "createtime": fields.DateTime(), "updatetime": fields.DateTime(), "tags": fields.List(fields.String()), }, ) tag = api.model( "SearchingTag", {"tag": fields.String(required=True, description="searching tag")}, )
from flask_restx import Resource, fields from flask import request from sample_project.user import ns user = ns.model( 'User', { 'id': fields.Integer, 'name': fields.String(required=True, min_length=1), 'email': fields.String(required=True, min_length=5), }) @ns.route('/users', methods=['POST']) class User(Resource): @ns.expect(user, validate=True) @ns.marshal_with(user, envelope='user') def post(self): data = request.json data['id'] = 1 return data, 201 @ns.route('/users/<string:user_id>', methods=['GET']) class UserDetail(Resource): @ns.marshal_with(user, envelope='user') def get(self, user_id): if user_id == '1': return { 'id': 1, 'name': 'John Doe',
from flask_restx import Resource, fields, Namespace from script_runner.server import app api = Namespace('server-health', description="Service health checks.", path='/') health_output = api.model('HealthOutput', { 'version': fields.String(), 'server': fields.Boolean(), }) @api.route('/health') class HealthResource(Resource): @api.doc(model=health_output) def get(self): return { 'version': app.config['SERVER_VERSION'], 'server': True, }
"id": fields.String, "name": fields.String, "amount": fields.Integer } flavor_fields = { "id": fields.String, "name": fields.String, "icon": fields.String, "color": fields.String } product_serializer = api.model( "Product", { "id": fields.String(), "name": fields.String(required=True, description="Product name"), "short_description_nl": fields.String(description="NL Description as shown in the price list"), "description_nl": fields.String( description="EN Description as shown in the detail view"), "short_description_en": fields.String(description="NL Description as shown in the price list"), "description_en": fields.String( description="EN Description as shown in the detail view"), "approved": fields.Boolean(description="Approved?"), },
Specifying no numbers at all will retrieve all accounts available, while specifying any number of account numbers will retrieve those that match any accounts. #### Privileges - economy - accounts """ post_model = api.model( "post_transaction", { "amount": fields.Float(example=39.9, required=True, min=0), "date_trans": fields.Integer(example=round(datetime.now().timestamp()), required=False), "desc": fields.String(example="Transaction for stuff", required=True), "from_account": fields.Integer(example=101, required=True), "to_account": fields.Integer(example=401, required=True) }) @api.route("") class TransactionByDateResource(Resource): @api.response(200, "Successfully retrieved transactions") @api.doc(description=get_doc) @api.expect(between_dates, validate=True) @privilege_required("transactions") @privilege_required("economy") def get(self):
class NullableString(fields.String): __schema_type__ = ['string', 'null'] __schema_example__ = 'nullable string' api = Namespace('Api', description='') contacts_ns = 'contacts' messages_ns = 'messages' rooms_ns = 'rooms' contact_model = api.model( 'Contact', { 'id': fields.Integer(readonly=True), 'address': fields.String(required=True), 'name': NullableString(), 'nickname': fields.String(required=True), 'online': fields.Boolean(readonly=True), }) room_model = api.model( 'Room', { 'id': fields.Integer(readonly=True), 'hash': fields.String(readonly=True), 'name': fields.String(), 'admin_address': fields.String(), 'members': fields.List(fields.Nested(contact_model, readonly=True)), 'private': fields.Boolean(readonly=True), })
get_doc = """ ### Retrieval of economy accounts Using this endpoint, you can retrieve information about the different accounts tied to your user. Specifying no numbers at all will retrieve all accounts available, while specifying any number of account numbers will retrieve those that match any accounts. #### Privileges - economy - accounts """ post_model = api.model("accounts_post", { "number": fields.Integer(example=401, required=True), "name": fields.String(example="Example account", required=True), "desc": fields.String(example="Example account for example transactions", required=True) }) post_doc = """ ### Creation of economy accounts Using this endpoint, you can create new economy accounts for your user. #### Privileges - economy - accounts """ @api.route("") class AccountsResource(Resource):
from flask_restx import Namespace, Resource, fields from flask import abort from app.models import Tweet from app import db api = Namespace('tweets') json_tweet = api.model('Tweet', { 'id': fields.Integer, 'text': fields.String, 'created_at': fields.DateTime }) json_new_tweet = api.model('New tweet', {'text': fields.String(required=True)}) @api.route('/<int:id>') @api.response(404, 'Tweet not found') @api.param('id', 'The tweet unique identifier') class TweetResource(Resource): @api.marshal_with(json_tweet) def get(self, id): tweet = db.session.query(Tweet).get(id) if tweet is None: api.abort(404, "Tweet {} doesn't exist".format(id)) else: return tweet @api.marshal_with(json_tweet, code=200) @api.expect(json_new_tweet, validate=True) def patch(self, id):
from flask_restx import fields facts_model = { 'name': fields.String('Fact name'), 'value': fields.String('Fact title') } message_model_definition = { 'message': fields.String('Body of the message to send', required=True), 'from': fields.String('User that sends the message', required=True) } message_card_model = { 'title': fields.String('Card title'), 'activity_title': fields.String('Activity title'), 'activity_subtitle': fields.String('Activity subtitle'), 'activity_image': fields.String('Activity image url'), 'activity_text': fields.String('Activity text'), 'facts': fields.List(fields.Nested(facts_model)), 'section_text': fields.String('Section image description text'), 'section_image': fields.String('Section image url'), 'section_image_title': fields.String('Section image url') }
# -*- coding: utf-8 -*- # Copyright (c) 2020 Zorglub42 {contact(at)zorglub42.fr}. # # All rights reserved. This program and the accompanying materials # are made available under the terms of the Apache License, Version 2.0 # which accompanies this distribution, and is available at # http://www.apache.org/licenses/LICENSE-2.0 """FFBC8 weatherstation data model.""" from flask_restx import fields from api.restx import API # Model desecription for methods parameters SYSTEM_COMMAND_PAYLOAD = API.model("systemCommand", { "command": fields.String( requied=True, description="Command to execute", enum=["shutdown", "reboot"] ) }) SYSTEM_TIME = API.model("dateTime", { "dateTime": fields.String( requied=True, description="Date is ISO format", example="2020-02-21T20:36:28Z" ) }) SENSOR_VALUE = API.model("sensorValue", { 'name': fields.String( required=True, description='Sensor name',
from flask_restx import Namespace, Resource, fields from dao.careProviderDao import * from dao.employeeDao import * from uuid import uuid4 from services.updateService import * api = Namespace('careProvider', description='Care Providers related operations') careProviderDao = CareProviderDao() employeeDao = EmployeeDao() updateService = UpdateService() newCareProvider = api.model( 'NewCareProvider', { 'first_name': fields.String(required=True, description='CareProvider first name'), 'last_name': fields.String(required=True, description='CareProvider last name'), 'dob': fields.String(required=True, description='CareProvider date of birth'), 'email': fields.String(required=True, description='CareProvider email id') }) careProvider = api.inherit( 'CareProvider', newCareProvider, { 'id': fields.String(required=True, description='unique careProvider id'), 'per_visit_charges': fields.String(required=True, description='careProvider per_visit_charges'),
description='Simulator Agent API') @app.errorhandler(InvalidUsage) def handle_invalid_usage(error): response = jsonify(error.to_dict()) response.status_code = error.status_code return response # Register Fabric wide operations api ns_fabric = api.namespace('fabric', description='Fabric wide Apis') fabric_put_schema = { 'address_pool': fields.String( required=True, description='List of address pools - eg: [("10.1.1.10", "10.1.1.20"),' ' ("10.1.1.30", "10.1.1.40")]'), 'n_leafs': fields.Integer(required=True, description='No of leafs in the fabric'), 'n_spines': fields.Integer(required=True, description='No of spines in the fabric'), 'n_border_leafs': fields.Integer(description='No of border leafs in the fabric'), 'n_super_spines': fields.Integer(description='No of super spines in the fabric'), 'n_pifs': fields.Integer( description='No of physical interfaces in each Leaf - eg: 48'), 'collector': fields.String( description='Address of the sflow collector if action is start')
from ..model import Study api = Namespace("Studies", description="Study related operations") # Model definition # ---------------------------------------------------------------------------------------------------------------------- entry_model = api.model( "Entry", {"property": fields.Nested(property_model_id), "value": fields.Raw()} ) entry_model_prop_id = api.model( "Entry (property collapsed)", { "property": fields.String( attribute="property.id", example="Property Object Id" ), "value": fields.Raw(), }, ) entry_model_form_format = api.model( "Entry (form format)", { "property_name_1": fields.Raw(example="Some value"), "property_name_2": fields.Raw(example="Some value"), }, ) change_log = api.model( "Change Log",
""" __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 = { 'detectorId': f_fields.Integer(required=True, description='Primary key (auto-incremented)'), 'detectorType': f_fields.String(required=False, description=''), 'detectorManufacturer': f_fields.String(required=False, description=''), 'detectorModel': f_fields.String(required=False, description=''), 'detectorPixelSizeHorizontal': f_fields.Float(required=False, description=''), 'detectorPixelSizeVertical': f_fields.Float(required=False, description=''), 'DETECTORMAXRESOLUTION': f_fields.Float(required=False, description=''), 'DETECTORMINRESOLUTION': f_fields.Float(required=False, description=''), 'detectorSerialNumber': f_fields.String(required=False, description=''), 'detectorDistanceMin':
''' 업체명 조회 ''' search_company_api = Namespace('wanted search_company', path='/search_company', description='업체명으로 업체를 조회한다.') search_company_parser = reqparse.RequestParser() search_company_parser.add_argument('search_word', type=str, default='원티드', help='검색 조건') api.add_namespace(search_company_api) ''' 태그 조회 ''' search_tag_api = Namespace('wanted search_tag', path='/search_tag', description='태그명으로 업체를 조회한다.') search_tag_parser = reqparse.RequestParser() search_tag_parser.add_argument('search_word', type=str, default='tag', help='검색 조건') api.add_namespace(search_tag_api) ''' 태그 수정 ''' update_tag_api = Namespace('wanted update_tag', path='/update_tag', description='업체의 태그명을 변경한다.') update_tag_model = update_tag_api.model('update_tag',{ 'update_tag_lang': fields.String(description='ko|en|ja', required=True, example="ko"), 'update_tag': fields.String(description='수정할 태그명', required=True, example="TAG_A") }) api.add_namespace(update_tag_api) ''' 태그 삭제 ''' delete_tag_api = Namespace('wanted delete_tag', path='/delete_tag', description='업체의 태그명을 삭제한다.(언어단위)') delete_tag_model = delete_tag_api.model('delete_tag',{ 'delete_tag_lang': fields.String(description='삭제할 태그 lang(ko|en|ja)', required=True, example="ko") }) api.add_namespace(delete_tag_api) ''' 요청 결과 모델 ''' result_model = api.model('result',{ 'company_id': fields.String(description='ID', required=True, example="1"), 'company_ko': fields.String(description='회사명(한국어)', required=True, example="원티드"),
from marshmallow import Schema, fields as ma_fields from flask_restx import fields as f_fields from marshmallow_jsonschema import JSONSchema from pyispyb.app.extensions.api import api_v1 as api dict_schema = { 'personId': f_fields.Integer(required=True, description=''), 'laboratoryId': f_fields.Integer(required=False, description=''), 'siteId': f_fields.Integer(required=False, description=''), 'personUUID': f_fields.String(required=False, description=''), 'familyName': f_fields.String(required=False, description=''), 'givenName': f_fields.String(required=False, description=''), 'title': f_fields.String(required=False, description=''), 'emailAddress': f_fields.String(required=False, description=''), 'phoneNumber': f_fields.String(required=False, description=''), 'login': f_fields.String(required=False, description=''), 'faxNumber': f_fields.String(required=False, description=''), 'recordTimeStamp':
from flask_restx import fields from esdlvalidator.api import app schema_summary = app.api.model( 'SchemaSummary', { "id": fields.String(required=False, description="ID of the schema"), "name": fields.String(required=False, description="Name of the schema"), "description": fields.String(required=False, description="Description of the schema") }) schema_validation_select = app.api.model( "select", { "function": fields.String(required=True, description="Name of the function to use", example="get"), "alias": fields.String(required=True, description="Alias for the dataset", example="areas"), "args": fields.Raw(required=True, description="Arguments passed to the select function", example={"type": "Area"}), }) schema_validation_check = app.api.model( "check", {
from collections import defaultdict app = Flask(__name__) api = Api( app, version='1.0', title='TraceMVC API', description='A simple TraceMVC API', ) ns = api.namespace('traces', description='Trace operations') trace = api.model( 'Trace', { 'plus_codes': fields.String(required=True, description='pluscod.es'), 'unix_timestamp': fields.String(required=True, description='String representing Unix timestamp'), 'domain': fields.String(required=True, description='Domain name'), 'key': fields.String(required=True, description='String of map key'), 'value': fields.String(required=True, description='String containing value'), }) class TraceDAO(object): def __init__(self): self.counter = 0
from mycodo.mycodo_flask.api import api from mycodo.mycodo_flask.api import default_responses from mycodo.mycodo_flask.api.sql_schema_fields import output_channel_fields from mycodo.mycodo_flask.api.sql_schema_fields import output_fields from mycodo.mycodo_flask.api.utils import get_from_db from mycodo.mycodo_flask.api.utils import return_list_of_dictionaries from mycodo.mycodo_flask.utils import utils_general from mycodo.mycodo_flask.utils.utils_output import get_all_output_states logger = logging.getLogger(__name__) ns_output = api.namespace('outputs', description='Output operations') MODEL_STATES_STATE = ns_output.model('states', { '*': fields.Wildcard(fields.String(description='on, off, or a duty cycle'), ) }) MODEL_STATES_CHAN = ns_output.model( 'channels', { '*': fields.Wildcard( fields.Nested( MODEL_STATES_STATE, description= 'Dictionary with channel as key and state data as value.')) }) output_list_fields = ns_output.model( 'Output Fields List', { 'output devices': fields.List(fields.Nested(output_fields)), 'output channels':
api = Api( app, version='1.0', title='My API', description='A simple TodoMVC API', ) ns = api.namespace('todos', description='TODO operations') todo = api.model( 'Todo', { 'id': fields.Integer(readonly=True, description='The task unique identifier'), 'task': fields.String(required=True, description='The task details') }) DAO = TodoDAO() @ns.route('/') class TodoList(Resource): '''Shows a list of all todos, and lets you POST to add new tasks''' @ns.doc('list_todos') @ns.marshal_list_with(todo) def get(self): '''List all tasks''' return DAO.todos @ns.doc('create_todo')
import logging logger = logging.getLogger(__name__) mongo = db.mongo api = Namespace( "profiles", description="Profile related routes", path="/api/profiles" ) profile = api.model( "Profile", { "_id": fields.String(description="Profile ID"), "user": fields.String(required=True, description="Belong to user"), "firstname": fields.String(), "lastname": fields.String(), "age": fields.Integer(), "email": fields.String(), "discipline": fields.String(), }, ) PROFILES = [] @api.route("/profile/user/<userid>", endpoint="profile") class Profile(Resource): @jwt_required
from datetime import datetime from dao.patientDao import * from dao.billDao import * from services.updateService import * from dao.patientCareDao import * api = Namespace('patient', description='Patients related operations') patientDao = PatientDao() billDao = BillDao() updateService = UpdateService() patientCareDao = PatientCareDao() newPatient = api.model( 'NewPatient', { 'firstName': fields.String(required=True, description='patient first name'), 'lastName': fields.String(required=True, description='patient last name'), 'email': fields.String(required=True, description='patient email address'), 'contactNumber': fields.Integer(required=True, description='patient contact Number'), 'consentToShare': fields.Boolean(required=True, description='patient consent to share information'), 'dob': fields.String(required=True, description='patient date of birth'), 'age': fields.Integer(required=True, description='patient age') })