"id": fields.String( title="Database ID", description="Used to identify a database.", required=True, example="hyrise-1", ) }, ) model_throughput = monitor.clone( "Throughput", model_database, { "throughput": fields.Integer( title="Throughput", description="Query throughput of a given time interval.", required=True, example=7381, ) }, ) model_detailed_throughput = monitor.clone( "Detailed Throughput", model_database, { "detailed_throughput": fields.List( fields.Nested( monitor.model( "Throughput per query", { "workload_type": fields.String(
from flask_restx import fields from dollar.api.restx import api order = api.model( 'Order', { 'id_company': fields.Integer(readOnly=True), 'delivery_time': fields.Integer(), 'delivery_cost': fields.Integer(), 'good': fields.Integer(), 'bad': fields.Integer(), 'feedback': fields.Integer(), 'call': fields.Integer(), }) product = api.model( 'Product', { 'id_company': fields.Integer(readOnly=True), 'price': fields.Integer(), 'sale': fields.Integer(), 'views': fields.Integer(), }) company = api.model( 'Company', { 'id': fields.Integer(readOnly=True, description='The unique identifier'), 'company': fields.String(readOnly=True, description='Company name'), 'category': fields.Integer(readOnly=True), 'verification': fields.Integer(readOnly=True), 'own': fields.Integer(readOnly=True), 'days_online': fields.Integer(readOnly=True),
'in': 'path', 'required': False, 'default': 0 }), ('filter_{type}[{field}]', { 'description': 'Filter for field with specified type. Type can be one of [like,in,nin,gt,lt,gte,lte,eq,neq]', 'type': 'string', 'in': 'path', 'required': False, 'default': None }) ]) datasource_rows_metadata = ns_conf.model('RowsResponse', { 'data': fields.List(fields.Raw, required=False, description='rows of datasource data'), 'rowcount': fields.Integer(required=False, description='Count of rows in dataset') }) EXAMPLES = [{ 'data': [ { 'name': 'Mercury', 'mass': 0.055, 'radius': 0.3829 }, { 'name': 'Venus', 'mass': 0.815, 'radius': 0.9499 }, { 'name': 'Earth', 'mass': 1.0,
GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with py-ispyb. If not, see <http://www.gnu.org/licenses/>. """ __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 = { "eventTrainId": f_fields.Integer(required=True, description=""), "name": f_fields.String(required=False, description=""), "timeOn": f_fields.Float(required=False, description="sec"), "duration": f_fields.Float(required=False, description="sec"), "period": f_fields.Float(required=False, description=""), "numberOfRepetitions": f_fields.Float(required=False, description=""), "nameInEventLog": f_fields.String(required=False, description=""), "triggerDevice": f_fields.String(required=False, description=""), } class EventTrainSchema(Schema): """Marshmallows schema class representing EventTrain table""" eventTrainId = ma_fields.Integer() name = ma_fields.String()
client = Cloudant.iam(api_access['username'], api_access['apikey'], connect=True) product_ns = api.namespace('product', description='User CIR Product Operations') # Define the API models we will use (these will show up in the Swagger Specification). rating = api.model( 'Rating', { 'efficiency': fields.Integer( required=False, description= 'The efficiency-in-use rating (0-9, where 0 is best) of this item' ), 'energy': fields.Float(required=False, description='The energy (J) to produce this item'), 'CO2': fields.Float(required=False, description='The CO2 released (Kg) to produce this item'), 'otherGG': fields.Float( required=False, description= 'The other green house gases released (Kg) to produce this item'), 'water': fields.Float(
from flask_restx import fields from cortex.api import api_manager dns_serializer = api_manager.model( 'DNS', { 'ip': fields.String(required=True, description='Host IP Address'), 'hostname': fields.String(required=True, description='Host name'), 'error': fields.String(required=False, description='Error Resposne'), 'success': fields.Integer( required=True, description='DNS Lookup Status - 0: failure 1: success'), })
app = Flask(__name__, static_url_path='') api = Api( app, 'todos', description='Operações ligadas as suas tarefas', ) ns = Namespace('todos', description='Operações ligadas as suas tarefas') api.add_namespace(ns) todo = api.model( 'Todo', { 'id': fields.Integer(readonly=True, description='Identificador único da tarefa'), 'tittle': fields.String(required=True, description='Nome da Tarefa'), 'description': fields.String(required=True, description='Descrição da tarefa'), 'done': fields.Boolean(required=True, description='A tarefa será concluída?'), }, ) @app.errorhandler(400) def not_found(error): return make_response(jsonify({'error': 'Bad request'}), 400)
from core import token from core.cache import get_discovery_cache from google.oauth2.credentials import Credentials logger = logging.getLogger('tpf-backend') api = Namespace('users', description='Users') apimodel = api.model( 'User', { 'email': fields.String(required=True, description='User primary email'), 'name': fields.String(description='Full name'), 'title': fields.String(description='Job title'), 'photo': fields.String(description='Photo'), 'photo_mimetype': fields.String(description='Photo MIME type'), 'photo_width': fields.Integer(description='Photo width in pixels'), 'photo_height': fields.Integer(description='Photo height in pixels'), }) def _escape_query_arg(query): return query.replace('"', '\\"') class Users: def get_namespace(config): UsersList.customer_id = config['config']['cloudIdentityCustomerId'] User.customer_id = config['config']['cloudIdentityCustomerId'] UsersList.config = config User.config = config return api
from flask_restx import Namespace, Resource, fields from ..Configuration import get_configuration api = Namespace('storages', description='Energy storages') storage = api.model( 'Storage', { 'id': fields.Integer(required=True, description='ID of the storage'), 'name': fields.String(required=True, description='Name of the storage'), 'image': fields.String(required=False, description='URL of the image for the storage'), 'type': fields.String(required=True, description='Type of the storage'), 'currentStorageCapacityInPercent': fields.Float( required=False, description='Current Storage capacity in percent', attribute=lambda x: x['adapter'].get_current_storage_capacity()) }) @api.route('/') class StorageList(Resource): @api.doc('list_storages') @api.marshal_list_with(storage) def get(self): return get_configuration()['storages']
# Authors : Benoit HERARD <benoit.herard(at)orange.com> # # Description : # Public data model definitions # ------------------------------------------------------- # History : # 1.0.0 - 2017-02-20 : Release of the file # from flask_restx import fields from api.restx import API # Model desecription for methods parameters POWER_POST = API.model( 'powerPost', { 'power': fields.Integer(required=True, description='Power consumption in Watts'), 'time': fields.Integer(required=False, description='Measurment time stamp'), 'environment': fields.String(required=True, description='Recorder environment \ identifier'), }) MEASUREMENT = API.model( "measurement", { 'sensor': fields.String(required=True, description="Sensor/measurment name"), 'unit': fields.String(required=True, description='Measurement unit'), 'value': fields.Float(required=True, decription='Measurement value'),
from flask_restx import Resource, fields, Model magstats_model = Model( "Magstats", { "fid": fields.Integer(description="Filter ID (1=g; 2=r, 3=i"), "stellar": fields.Boolean( description="whether the object appears to be unresolved in the given band" ), "corrected": fields.Boolean( description="whether the corrected photometry should be used" ), "ndet": fields.Integer( description="number of detections in the given band" ), "ndubious": fields.Integer( description="number of dubious corrections" ), "magmean": fields.Float( description="the mean magnitude for the given fid" ), "magmedian": fields.Float( description="the median magnitude for the given fid" ), "magmax": fields.Float( description="the max magnitude for the given fid" ), "magmin": fields.Float( description="the min magnitude for the given fid" ), "magsigma": fields.Float(
scenariosNamespace = Namespace('scenario') parser = reqparse.RequestParser() parser.add_argument('skip', type=int, help='skip tasks') parser.add_argument('maximum', type=int, help='maximum tasks returned') parser.add_argument('id', type=str, help='task id') scenario_model = scenariosNamespace.model( 'Scenario', { 'title': fields.String(description="Scenarios title"), 'description': fields.String(description="Scenarios description"), 'userId': fields.String(description='users id'), 'emissions': fields.List(fields.String, description="Scenarios emissions"), 'date': fields.Integer(description="Scenarios date of creation") }) def token_required(f): @wraps(f) def decorated(*args, **kwargs): token = None if 'Authorization' in request.headers: token = request.headers['Authorization'] token = token.split(" ")[1] if not token: return {'message': 'Token is missing.'}, 401 if oidc.validate_token(token) is True: # try: # userid = oidc.user_getfield('sub', token)
"type": fields.String(description='Contract type'), }) CardModel = api.model( 'Card', { "ksi": fields.String(description='Key Session Identifier'), "number": fields.String(description='Card number'), "state": fields.String(description='Contract status'), "balance": fields.Fixed(description="Current balance", decimals=2), "lastTimeUsed": fields.String(description='Last time used'), }) UseModel = api.model( 'Use', { "month": fields.String(description='Month name'), "uses": fields.Integer(description='Month uses count'), "amount": fields.Fixed(description="Month amount", decimals=2), }) ChargeModel = api.model( 'Charge', { "month": fields.String(description='Month name'), "charges": fields.Integer(description='Month charges count'), "amount": fields.Fixed(description="Month amount", decimals=2), }) ResumeModel = api.model( 'Resume', { 'uses': fields.List(fields.Nested(UseModel)), 'charges': fields.List(fields.Nested(ChargeModel)), })
GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with py-ispyb. If not, see <http://www.gnu.org/licenses/>. """ __license__ = "LGPLv3+" 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 = { 'eventTrainId': f_fields.Integer(required=True, description=''), 'name': f_fields.String(required=False, description=''), 'timeOn': f_fields.Float(required=False, description='sec'), 'duration': f_fields.Float(required=False, description='sec'), 'period': f_fields.Float(required=False, description=''), 'numberOfRepetitions': f_fields.Float(required=False, description=''), 'nameInEventLog': f_fields.String(required=False, description=''), 'triggerDevice': f_fields.String(required=False, description=''), } class EventTrainSchema(Schema): """Marshmallows schema class representing EventTrain table""" eventTrainId = ma_fields.Integer() name = ma_fields.String()
from flask_restx import fields, reqparse from rest import api from utils import parser_utils CategorySchema = api.model( 'Category', { 'id': fields.Integer(required=False, description='Category id.'), 'name': fields.String(required=True, description='Category name min 3, max 50.'), }) CategoryParser = reqparse.RequestParser() CategoryParser.add_argument('name', type=parser_utils.validate_string(50, 3), required=True, location='json')
from flask_restx import fields from flask_restx.fields import MarshallingError from flask_restx.marshalling import marshal from .common import ns playlist_identifier = ns.model( "playlist_identifier", { # Use `FormattedString`s in these models to act as a constant via the source string arg ("playlist" here) "type": fields.FormattedString("playlist"), "playlist_id": fields.Integer(required=True), }, ) explore_playlist_identifier = ns.model( "explore_playlist_identifier", { "type": fields.FormattedString("explore_playlist"), "playlist_id": fields.String(required=True), }, ) class PlaylistLibraryIdentifier(fields.Raw): def format(self, value): try: if value.get("type") == "playlist": return marshal(value, playlist_identifier) if value.get("type") == "explore_playlist": return marshal(value, explore_playlist_identifier)
from .utils import HtContext _LOGGER = logging.getLogger(__name__) api = Namespace( "timeprog", description="Operations related to the time programs of the heat pump.") time_prog_model = api.model( "time_prog_model", { "index": fields.Integer( min=0, description="index of the time program", required=False, readonly=True, example=0, ), "name": fields.String( description="name of the time program", required=False, readonly=True, example="Warmwasser", ), "ead": fields.Integer( min=0, description="number of entries a day of the time program", required=False,
You should have received a copy of the GNU Lesser General Public License along with py-ispyb. If not, see <http://www.gnu.org/licenses/>. """ __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 = { "micrographId": f_fields.Integer(required=True, description=""), "crystalSlurryId": f_fields.Integer(required=True, description=""), "url": f_fields.String(required=False, description=""), "objectSidePixelSize": f_fields.String(required=False, description="comma separated two floats"), "descriptionJson": f_fields.String(required=False, description=""), } class MicrographSchema(Schema): """Marshmallows schema class representing Micrograph table""" micrographId = ma_fields.Integer()
from flask_restx import Namespace, Resource, fields from webargs.flaskparser import use_kwargs from werkzeug.exceptions import NotFound from ..utils import (get_json_from_file_resource, get_dict_of_elements_from_json_file_list, validate_id, PAGINATION_ARGUMENTS, DOC_PAGINATION_ARGUMENTS, OFFICES_FILENAME) api = Namespace('offices', description='Offices') OFFICE_RESOURCE_KEY = "office" OFFICE_ID_FIELD_KEY = "id" office_model = api.model( 'Office', { OFFICE_ID_FIELD_KEY: fields.Integer(required=True, description='The office identifier'), 'city': fields.String(description='The office city'), 'country': fields.String(description='The office country'), 'address': fields.String(description='The office address'), }) @api.route('') class Offices(Resource): @api.doc('list_offices', params=DOC_PAGINATION_ARGUMENTS) @api.marshal_list_with(office_model) @use_kwargs(PAGINATION_ARGUMENTS, location="query") def get(self, limit, offset):
from flask import Blueprint from flask_restx import Api, fields from train_model import get_model api = Api(version='1.0', title='ML API Example', validate=False) ns = api.namespace('heart', description='Heart disease') _, model_info = get_model() feature_row = api.model('featues', { feat: fields.Float(required=True) for feat in model_info['required_cols'] }) information = api.model( 'model information', { 'model_name': fields.String(required=True), 'f1-score': fields.Float(required=True), 'required_cols': fields.List(fields.String()) }) prediction = api.model('prediction', {'prediction': fields.Integer()}) api_blueprint = Blueprint('api', __name__)
('root', 'example')) cors = CORS(app) db = client.weather collection = db.temperature temperature = api.model( 'Temperature', { # '_id' : fields.String(), 'id_station': fields.String(required=True, description='@MAC Station'), 'id_sonde': fields.String(required=True, description='@MAC Sonde'), 'latitude': fields.Float(required=True, description='Latitude'), 'longitude': fields.Float(required=True, description='Longitude'), 'ville': fields.String(required=True, description='ville'), 'timestamp': fields.Integer(required=True, description='Timestamp'), 'temperature': fields.Float(required=True, description='Temperature'), 'humidite': fields.Float(required=True, description='Humidite') }) app.config['CORS_HEADERS'] = 'Content-Type' @app.route("/") @cross_origin() def helloWorld(): return "Hello, cross-origin-world!" @app.after_request # blueprint can also be app~~ def after_request(response):
# app/api/users.py # APIs for users from flask import request from flask_restx import Namespace, Resource, fields from app.api.utils import (add_user, delete_user, get_all_users, get_user_by_email, get_user_by_id, update_user) users_namespace = Namespace("users") user = users_namespace.model( "User", { "id": fields.Integer(readOnly=True), "username": fields.String(required=True), "email": fields.String(required=True), # "password": fields.String(required=True), "created_date": fields.DateTime, }, ) user_post = users_namespace.inherit( "User post", user, {"password": fields.String(required=True)} ) class UsersList(Resource): @users_namespace.marshal_with(user, as_list=True) def get(self): """Returns all users."""
You should have received a copy of the GNU Lesser General Public License along with py-ispyb. If not, see <http://www.gnu.org/licenses/>. """ __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 = { 'autoProcScalingStatisticsId': f_fields.Integer(required=True, description='Primary key (auto-incremented)'), 'autoProcScalingId': f_fields.Integer( required=False, description='Related autoProcScaling item (used by foreign key)'), 'scalingStatisticsType': f_fields.String( required=True, description='Scaling statistics typeenum(overall,innerShell,outerShell)' ), 'comments': f_fields.String(required=False, description='Comments...'), 'resolutionLimitLow': f_fields.Float(required=False, description='Low resolution limit'), 'resolutionLimitHigh': f_fields.Float(required=False, description='High resolution limit'),
credentials = f.read() api_access = ast.literal_eval(credentials) client = Cloudant.iam(api_access['username'], api_access['apikey'], connect=True) project_ns = api.namespace('project', description='User Cloud Project Operations') # Define the API models we will use (these will show up in the Swagger Specification). project = api.model( 'Project', { 'id': fields.Integer(readonly=True, description="Carbon offset project UID"), 'name': fields.String(required=True, description="The name of the carbon offset project"), 'description': fields.String(required=True, description="Description of the carbon offset project"), 'location': fields.String( required=True, description="The country in which the project is located"), 'cost': fields.Float( required=True, description= "The cost per tonne of carbon eliminated associated with this project"
from flask_restx import fields, Model todo_model = Model( 'todo', { 'id': fields.Integer(readonly=True, description='The task unique identifier'), 'task': fields.String(required=True, description='The task details') })
class RequestDto: api = Namespace("request", path="/request") no_pattern = "([1-9]|1[012])-([1-9]|([1-9][0-9]))+" # date_pattern = "(\d{4}-\d{2}-\d{2} ([2][0-3]|[0-1][0-9]|[1-9]):[0-5][0-9]:([0-5][0-9]|[6][0]))" date_pattern = "\d{4}-\d{2}-\d{2}" photo_fn_pattern = "(.*/)*.+\.(png|jpg|jpeg|PNG|JPG|JPEG)" id_pattern = "[a-f0-9]{8}-?[a-f0-9]{4}-?4[a-f0-9]{3}-?[89ab][a-f0-9]{3}-?[a-f0-9]{12}" request = api.model( "request", { "id": fields.String(), "no": fields.String(required=True, pattern=no_pattern), "date": fields.String( dt_format="rfc822", required=True, pattern=date_pattern), "detail": fields.String(), "result": fields.Integer(required=True, min=0, max=2), "rating": fields.Integer(required=True, min=0, max=5), "photo_fn": fields.String(required=True, pattern=photo_fn_pattern), "client": fields.Nested(api.model( "client", { "id": fields.String(required=True, attribute="client_id", pattern=id_pattern), "name": fields.String(attribute="client_name") }), required=True), "approach": fields.Nested(api.model( "approach", { "id": fields.String(required=True, attribute="approach_id", pattern=id_pattern), "name": fields.String(attribute="approach_name") }), required=True), "type": fields.Nested(api.model( "type", { "id": fields.String(required=True, attribute="type_id", pattern=id_pattern), "name": fields.String(attribute="type_name") }), required=True), "fixers": fields.List(fields.Nested(api.model( "fixer", { "id": fields.String(required=True, attribute="fixer_id", pattern=id_pattern), "name": fields.String(attribute="fixer_name") }), required=True), min_items=1) })
from flask_restx import fields, Model base_resp = Model( 'Body', { 'return_code': fields.Integer( title='返回码', description='200为成功', example=200, required=True), 'return_msg': fields.String(title='返回信息', description='成功时可为空字符串', example='Success', required=True) }) resource_model = Model( 'ResourceModel', { 'created_by': fields.Integer(title='创建者ID', example=1, required=True), 'created_at': fields.String( title='创建时间', example='2020-01-01 08:00:00', required=True), 'updated_by': fields.Integer(title='更新者ID', example=1), 'updated_at': fields.String(title='更新时间', example='2020-01-01 08:00:01') }) user_model = resource_model.clone( 'user', { "user_id": fields.Integer(title="用户ID"), 'user_name': fields.String(title="用户名"),
class SMEDTO: sme_api = Namespace("SME", description="SME related operations") sme_list = sme_api.model( "sme_list", { "name": fields.String(required=True, description="SME name"), "postal_address": fields.String( required=True, description="SME postal address" ), "location": fields.String(required=True, description="SME location"), "telephone": fields.String(required=True, description="SME telephone"), "email": fields.String(required=True, description="SME email address"), "description": fields.String(required=True, description="SME description"), "sector": fields.String(required=True, description="SME sector"), "principal_product_service": fields.String( required=True, description="SME principal product/service", ), "other_product_service": fields.String( required=True, description="SME other products/services" ), "age": fields.String(required=True, description="SME age"), "establishment_date": fields.Date(description="SME establishment date"), "ownership_type": fields.String( required=True, description="SME ownership type" ), "bank_account_details": fields.String( required=True, description="SME bank account details" ), "employees_number": fields.Integer( required=True, description="SME employees_number" ), "client": fields.Nested( ClientDTO().client, description="SME representative" ), }, ) sme = sme_api.model( "sme", { "name": fields.String(required=True, description="SME name"), "postal_address": fields.String( required=True, description="SME postal address" ), "location": fields.String(required=True, description="SME location"), "telephone": fields.String(required=True, description="SME telephone"), "email": fields.String(required=True, description="SME email address"), "description": fields.String(required=True, description="SME description"), "sector": fields.String(required=True, description="SME sector"), "principal_product_service": fields.String( required=True, description="SME principal product/service", ), "other_product_service": fields.String( required=True, description="SME other products/services" ), "age": fields.String(required=True, description="SME age"), "establishment_date": fields.Date(description="SME establishment date"), "ownership_type": fields.String( required=True, description="SME ownership type" ), "bank_account_details": fields.String( required=True, description="SME bank account details" ), "employees_number": fields.Integer( required=True, description="SME employees_number" ), "client_email": fields.String(required=True, description="Client email"), }, )
from flask_restx import fields from cortex.api import api_manager from cortex.api.serializers import pagination tasks_serializer = api_manager.model( 'task', { 'id': fields.Integer(required=True, description='Task ID.'), 'module': fields.String(required=True, description='The module that started the task'), 'username': fields.String(required=True, description='The user that started the task'), 'start': fields.DateTime(required=False, description='The date and time this task was started'), 'end': fields.DateTime(required=False, description='The date and time this task finished'), 'status': fields.Integer( required=True, description= 'The status of the task - 0: in progress, 1: success, 2: failure, 3: warnings' ), 'description': fields.String(required=False, description='The description of the task'), })
if str(app.config['SPRING_PROFILES_ACTIVE']).__contains__('kubernetes'): initialize_kubernetes_client(app) else: initialize_consul_client(app) initialize_db(app) api = initialize_api(app) ns = api.namespace('api/products', description='Product operations') nsReceipt = api.namespace('api/receipts', description='Receipt operations') productModel = api.model( 'Product', { 'name': fields.String(required=True, description='Name'), 'quantity': fields.Integer(required=True, description='Quantity'), 'category': fields.String(required=True, description='Category Name'), }) upload_parser = api.parser() upload_parser.add_argument('file', location='files', type=FileStorage, required=True) # Create configuration object with enabled logging and sampling of all requests. config = Config( config={ 'sampler': { 'type': 'const', 'param': 1