"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
