output_unique_id_fields = ns_output.model('Output Device Fields List', {
'output device': fields.Nested(output_fields),
'output device channels': fields.List(fields.Nested(output_channel_fields)),
'output device channel states': fields.Nested(
MODEL_STATES_STATE,
description='Dictionary with channel as key and state data as value.')
})
output_set_fields = ns_output.model('Output Modulation Fields', {
'state': fields.Boolean(
description='Set a non-PWM output state to on (True) or off (False).',
required=False),
'channel': fields.Float(
description='The output channel to modulate.',
required=True,
example=0,
min=0),
'duration': fields.Float(
description='The duration to keep a non-PWM output on, in seconds.',
required=False,
example=10.0,
exclusiveMin=0),
'duty_cycle': fields.Float(
description='The duty cycle to set a PWM output, in percent (%).',
required=False,
example=50.0,
min=0),
'volume': fields.Float(
description='The volume to send to an output.',
required=False,
def test_value(self, value, expected):
self.assert_field(fields.Float(), value, expected)
def test_decode_error_on_invalid_value(self):
field = fields.Float()
self.assert_field_raises(field, "not a float")
app.config.from_object("project.config.Config")
db = SQLAlchemy(app)
api = Api(app, version='1.0',
title='UGC API services',
description='REST APIs for processing user-generated content')
ns = api.namespace('comments_api', description='REST services API for news comments')
# input and output definitions
hate_speech_single_input = api.model('HateSpeechSingleInput', {
'text': fields.String(required=True, description='input text for classification')
})
hate_speech_single_output = api.model('HateSpeechSingleOutput', {
'label': fields.String(required=True, description='predicted class'),
'confidence': fields.Float(required=True, description='prediction confidence')
})
hate_speech_list_input = api.model('HateSpeechListInput', {
'texts': fields.List(fields.String, required=True, description='input list of texts for classification')
})
hate_speech_list_output = api.model('HateSpeechListOutput', {
'labels': fields.List(fields.String, required=True, description='list of predicted classes'),
'confidences': fields.List(fields.Float, required=True, description='list of prediction confidences')
})
@ns.route('/hate_speech/')
class HateSpeechClassifier(Resource):
@ns.doc('predict hate speech from single text')
@ns.expect(hate_speech_single_input, validate=True)
@ns.marshal_with(hate_speech_single_output)
def test_with_default(self):
field = fields.Float(default=0.5)
assert not field.required
assert field.__schema__ == {"type": "number", "default": 0.5}
metrics_parser = reqparse.RequestParser()
metrics_parser.add_argument("start_date",
type=inputs.date_from_iso8601,
help="initial date",
required=True)
metrics_parser.add_argument("end_date",
type=inputs.date_from_iso8601,
help="final date",
required=True)
metric_datum_model = api.model(
"Metric datum",
{
"date": fields.Date(required=True,
description="The date of the datum"),
"value": fields.Float(required=True,
description="The value of the datum"),
},
)
metric_model = api.model(
"Metric",
{
"name":
fields.String(),
"data":
fields.List(fields.Nested(metric_datum_model, description="The data")),
},
)
@api.route('')
'autoProcProgramId':
f_fields.Integer(required=False,
description='Foreign key to the AutoProcProgram table'),
'spotTotal':
f_fields.Integer(required=False, description='Total number of spots'),
'inResTotal':
f_fields.Integer(required=False,
description='Total number of spots in resolution range'),
'goodBraggCandidates':
f_fields.Integer(required=False,
description='Total number of Bragg diffraction spots'),
'iceRings':
f_fields.Integer(required=False,
description='Number of ice rings identified'),
'method1Res':
f_fields.Float(required=False,
description='Resolution estimate 1 (see publication)'),
'method2Res':
f_fields.Float(required=False,
description='Resolution estimate 2 (see publication)'),
'maxUnitCell':
f_fields.Float(
required=False,
description='Estimation of the largest possible unit cell edge'),
'pctSaturationTop50Peaks':
f_fields.Float(required=False,
description='The fraction of the dynamic range being used'),
'inResolutionOvrlSpots':
f_fields.Integer(required=False, description='Number of spots overloaded'),
'binPopCutOffMethod2Res':
f_fields.Float(required=False,
description='Cut off used in resolution limit calculation'),
import numpy as np
import sys
from flask_cors import CORS
flask_app = Flask(__name__)
CORS(flask_app)
app = Api(app=flask_app,
version="1.0",
title="Iris Plant identifier",
description="Predict the type of iris plant")
name_space = app.namespace('prediction', description='Prediction APIs')
model = app.model(
'Prediction params', {
'sepalLength':
fields.Float(required=True,
description="Sepal Length",
help="Sepal Length cannot be blank"),
'sepalWidth':
fields.Float(required=True,
description="Sepal Width",
help="Sepal Width cannot be blank"),
'petalLength':
fields.Float(required=True,
description="Petal Length",
help="Petal Length cannot be blank"),
'petalWidth':
fields.Float(required=True,
description="Petal Width",
help="Petal Width cannot be blank")
})
fields.Integer(
attribute='_group',
description='ID der Gruppe, zu der diese Liste gehört.'),
'archived':
fields.Boolean(attribute='_archived',
description='Status der Shoppinglist')
})
list_entry = api.inherit(
'ListEntry', bo, {
'articleId':
fields.Integer(
attribute='_article',
description='Zu welchem Artikel gehört dieser Listeneintrag? '),
'amount':
fields.Float(attribute='_amount',
description='Menge des Listeneintrags '),
'unit':
fields.String(attribute='_unit',
description='Einheit des Listeneintrags '),
'purchasingUserId':
fields.Integer(attribute='_purchasing_user',
description='Wer den Artikel kaufen muss. '),
'shoppingListId':
fields.Integer(
attribute='_shopping_list',
description='Zu welcher Liste dieser Listeneintrag gehört.'),
'retailerId':
fields.Integer(attribute='_retailer',
description='Bei wem wurde der Artikel gekauft. '),
'checked':
fields.Boolean(attribute='_checked',
port = int(os.getenv('PORT', 8000))
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"),
'total_cost' : fields.String(required=False, description="The total cost of purchasing offsets, given a value in tonnes of carbon emissions to offset"),
'url' : fields.String(required=True, description="URL containing more details on the project")
})
db_name = 'cp-db'
# A Data Access Object to handle the reading and writing of Product records to the Cloudant DB
class ProjectDAO(object):
def __init__(self):
if db_name in client.all_dbs():
self.cp_db = client[db_name]
else:
self.cp_db=client.create_database(db_name)
self.import_data()
description="Number of ticks this modifier will remain active"),
"abbreviation":
fields.String(description="Three letter abbreviation of this modifier")
})
UNKNOWN_NODE_RESPONSE = Response("Could not find the requested node",
status=404)
node = api.model(
"node", {
"node_id":
fields.String(description="Unique identifier of the node",
example="generator",
readonly=True),
"temperature":
fields.Float(description="Temperature of this node in degrees Kevlin",
example=273.3),
"performance":
fields.Float(
description=
"At what capacity is this node running? The number is a factor and will always be between min_performance and max_performance",
example=1),
"target_performance":
fields.Float(
description=
"What performance / capacity level is this node trying to reach? Note that not all nodes have an instant change, so it's target can be different from it's actual performance ",
example=1),
"min_performance":
fields.Float(
description=
"What is the minimum value of performance that this node can have?",
example=0.5),
SUCCESS_CODES = (200, 202)
booking_req_model = api.model(
"Booking",
{
"username": fields.String(required=True, description="User name"),
"email": fields.String(
required=True, description="Email address of user"
),
"property_name": fields.String(
required=True, description="Name of the property"
),
"property_latitude": fields.Float(
required=True, description="Latitude or property"
),
"property_longitude": fields.Float(
required=True, description="Longitude or property"
),
},
)
property_booking_model = api.model(
"PropertyBookingResponse",
{
"username": fields.String,
"emai": fields.String,
"property_id": fields.Integer,
"id": fields.Integer,
},
)
api = Api(blueprint,
version="0.1.0",
title="Twitter Dashboard API",
doc="/docs")
app.register_blueprint(blueprint)
GET_TWITTER_INFO = api.model(
"UserInfo", {
"username": fields.String(),
"profile_url": fields.String(),
"bio": fields.String(),
"date_created": fields.DateTime(dt_format="iso8601"),
"display_name": fields.String(),
"vectors": fields.List(fields.String()),
"scores": fields.List(fields.Float())
})
# documentation for swagger UI
ns_analytics = api.namespace("analytics",
description="Gets the user's dashboard analytics")
@ns_analytics.route("")
class GetUserAnalytics(Resource):
"""
Returns basic info of twitter user
"""
@api.param(
"Username",
description=
''' Provide the secret credentials '''
api_access = config['DEFAULT']
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', {
'Production': fields.Float(required=False, description='The efficiency-in-use rating (0-9, where 0 is best) of this item'),
'Transportation': fields.Float(required=False, description='The energy (J) to produce this item'),
'Retail': fields.Float(required=False, description='The CO2 released (Kg) to produce this item'),
})
product = api.model('Product', {
'id': fields.String(readonly=True, description='The unique product registration identifier'),
'UID': fields.String(readonly=True, description='The unique product registration identifier'),
'CarbonFootprint': fields.Float(required=True, description='The barcode for this product id, in EAN-13 format'),
'CurrentCompany': fields.String(required=True, description='The type of product'),
'isRecycleable': fields.String(required=True, description='The category of this product, with its type'),
'Stages': fields.Nested(rating),
'Date': fields.String(required=True, description='The category of this product, with its type'),
'description': fields.String(required=True, description='The description of this product, with its type'),
'previous': fields.String(required=True, description='The description of this product, with its type')
})
errors.abort(code=400, message="Unknown action")
stats_response_model = api.model(
"JobStatsResponse",
{
"alive":
fields.Integer(
description="Number of fuzzing processes running",
required=True,
attribute="mean_alive",
),
"cpu_hours":
fields.Float(
description="Number of CPU hours consumed",
required=True,
attribute="mean_cpu_hours",
),
"crashes":
fields.Integer(
description="Number of crashes triggered",
required=True,
attribute="mean_crashes",
),
"current_path":
fields.Integer(
description="For AFL, the current path depth",
required=True,
attribute="mean_current_path",
),
"execs":
}
input_parser = MAX_API.parser()
input_parser.add_argument('image', type=FileStorage, location='files', required=True,
help='An image file (encoded as PNG or JPG/JPEG)')
input_parser.add_argument('threshold', type=float, default=0.7,
help='Probability threshold for including a detected object in the response in the range '
'[0, 1] (default: 0.7). Lowering the threshold includes objects the model is less '
'certain about.')
label_prediction = MAX_API.model('LabelPrediction', {
'label_id': fields.String(required=False, description='Class label identifier'),
'label': fields.String(required=True, description='Class label'),
'probability': fields.Float(required=True, description='Predicted probability for the class label'),
'detection_box': fields.List(fields.Float(required=True), description='Coordinates of the bounding box for '
'detected object. Format is an array of '
'normalized coordinates (ranging from 0 to 1'
') in the form [ymin, xmin, ymax, xmax].')
})
predict_response = MAX_API.model('ModelPredictResponse', {
'status': fields.String(required=True, description='Response status message'),
'predictions': fields.List(fields.Nested(label_prediction),
description='Predicted class labels, probabilities and bounding box for each detected '
'object')
})
class ModelPredictAPI(PredictAPI):
from flask import abort
from flask_restx import Resource, Namespace, Model, fields, reqparse
from infraestructura.productos_repo import ProductosRepo
repo = ProductosRepo()
nsProducto = Namespace('productos', description='Administrador de productos')
modeloProductoSinID = Model(
'ProductoSinCod', {
'tipo': fields.String(),
'descripcion': fields.String(),
'porcentaje_ganancia': fields.Integer(),
'costo': fields.Float()
})
modeloProducto = modeloProductoSinID.clone('Producto', {
'codigo': fields.Integer(),
})
nsProducto.models[modeloProducto.name] = modeloProducto
nsProducto.models[modeloProductoSinID.name] = modeloProductoSinID
nuevoProductoParser = reqparse.RequestParser(bundle_errors=True)
nuevoProductoParser.add_argument('tipo', type=str, required=True)
nuevoProductoParser.add_argument('descripcion', type=str)
nuevoProductoParser.add_argument('costo', type=float)
nuevoProductoParser.add_argument('porcentaje_ganancia',
type=int,
required=True)
description=
'Weather the image is the last one of the annotation process.'),
'isLast':
fields.Boolean(
readOnly=True,
description=
'Weather the image is the last one of the annotation process.'),
'labelIds':
fields.List(fields.Integer(readOnly=True, description='Label id.'),
description='All label ids which belongs to this image.'),
'isJunk':
fields.Boolean(
readOnly=True,
description='Indicates if the image was marked as Junk.'),
'annoTime':
fields.Float(readOnly=True, description='Annotation time in seconds')
})
bbox_data = api.model(
'BBox Data', {
'x':
fields.Float(readOnly=True,
description='Relative and centered value of x.'),
'y':
fields.Float(readOnly=True,
description='Relative and centered value of y.'),
'w':
fields.Float(readOnly=True,
description='Relative value of box width.'),
'h':
fields.Float(readOnly=True,
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 = {
'dataCollectionId': f_fields.Integer(required=True, description='Primary key (auto-incremented)'),
'BLSAMPLEID': f_fields.Integer(required=False, description=''),
'SESSIONID': f_fields.Integer(required=False, description=''),
'experimenttype': f_fields.String(required=False, description=''),
'dataCollectionNumber': f_fields.Integer(required=False, description=''),
'startTime': f_fields.DateTime(required=False, description='Start time of the dataCollection'),
'endTime': f_fields.DateTime(required=False, description='end time of the dataCollection'),
'runStatus': f_fields.String(required=False, description=''),
'axisStart': f_fields.Float(required=False, description=''),
'axisEnd': f_fields.Float(required=False, description=''),
'axisRange': f_fields.Float(required=False, description=''),
'overlap': f_fields.Float(required=False, description=''),
'numberOfImages': f_fields.Integer(required=False, description=''),
'startImageNumber': f_fields.Integer(required=False, description=''),
'numberOfPasses': f_fields.Integer(required=False, description=''),
'exposureTime': f_fields.Float(required=False, description=''),
'imageDirectory': f_fields.String(required=False, description='The directory where files reside - should end with a slash'),
'imagePrefix': f_fields.String(required=False, description=''),
'imageSuffix': f_fields.String(required=False, description=''),
'imageContainerSubPath': f_fields.String(required=False, description='Internal path of a HDF5 file pointing to the data for this data collection'),
'fileTemplate': f_fields.String(required=False, description=''),
'wavelength': f_fields.Float(required=False, description=''),
'resolution': f_fields.Float(required=False, description=''),
'detectorDistance': f_fields.Float(required=False, description=''),
'SESSIONID':
f_fields.Integer(required=False, description=''),
'experimenttype':
f_fields.String(required=False, description=''),
'dataCollectionNumber':
f_fields.Integer(required=False, description=''),
'startTime':
f_fields.DateTime(required=False,
description='Start time of the dataCollection'),
'endTime':
f_fields.DateTime(required=False,
description='end time of the dataCollection'),
'runStatus':
f_fields.String(required=False, description=''),
'axisStart':
f_fields.Float(required=False, description=''),
'axisEnd':
f_fields.Float(required=False, description=''),
'axisRange':
f_fields.Float(required=False, description=''),
'overlap':
f_fields.Float(required=False, description=''),
'numberOfImages':
f_fields.Integer(required=False, description=''),
'startImageNumber':
f_fields.Integer(required=False, description=''),
'numberOfPasses':
f_fields.Integer(required=False, description=''),
'exposureTime':
f_fields.Float(required=False, description=''),
'imageDirectory':
from flask_restx import fields
from app.rest import api
shopping_cart_row_dto = api.model(
'Shopping Cart Row', {
'productId': fields.String(example='855109'),
'quantity': fields.Integer(example='5', default=0),
'amount': fields.Float(example='20', default=0),
'prediction': fields.Float(example='20')
})
shopping_cart_dto = api.model(
'Shopping Cart', {
'clientId': fields.String(example='60228'),
'platformId': fields.String(example='3726012812'),
'products': fields.List(fields.Nested(model=shopping_cart_row_dto))
})
model_input_dto = api.model('Input Model Data', {'modelId': fields.String})
model_info_dto = api.model(
'Current Model Info', {
'modelId': fields.String(attribute='model_id'),
'modelType': fields.String(attribute='model_type'),
'modelParams': fields.String(attribute='model_params'),
'datetime': fields.DateTime
})
"product_id": fields.String,
"product_name": fields.String,
"internal_product_id": fields.String,
"quantity": fields.Integer,
},
)
order_serializer = api.model(
"Order",
{
"id": fields.String(required=True),
"shop_id": fields.String(required=True, description="Shop Id"),
# Todo: use fields from improviser to marshall
"order_info": fields.Nested(order_info_serializer),
# "order_info": fields.String(),
"total": fields.Float(required=True, description="Total"),
"customer_order_id": fields.Integer,
},
)
order_serializer_with_shop_names = {
"id": fields.String(required=True),
"shop_id": fields.String(required=True, description="Shop Id"),
"shop_name": fields.String(description="Shop Name"),
# Todo: use fields from improviser to marshall
"order_info": fields.Nested(order_info_marshaller),
# "order_info": fields.String(),
"total": fields.Float(required=True, description="Total"),
"customer_order_id": fields.Integer,
"status": fields.String,
"created_at": fields.DateTime,
def test_defaults(self):
field = fields.Float()
assert not field.required
assert field.__schema__ == {"type": "number"}
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(
required=False,
description='The volume of water (litres) to produce this item'),
'plastic':
fields.Float(
required=False,
def test_none_uses_default(self):
field = fields.Float(default=0.5)
assert not field.required
assert field.__schema__ == {"type": "number", "default": 0.5}
assert field.format(None) == 0.5
from mindsdb.api.http.namespaces.configs.predictors import ns_conf
from flask_restx import fields
quality_metric = ns_conf.model('QualityMetric', {
'type': fields.String(required=False, description='The quality type', enum=['error', 'warning', 'info']),
'score': fields.Float(required=False, description='The score on the specific metric value 0-1'),
'description': fields.String(required=False, description='The quality metric description'),
'warning': fields.String(required=False, description=''),
'name': fields.String(required=False, description=''),
})
def test_raises(self):
self.assert_field_raises(fields.Float(), "bar")
class GetCartItemSchema(UpdateCartItemSchema):
name = fields.String(attribute='product.name')
price = fields.Float(attribute='product.price')
def test_decode_error_on_invalid_type(self):
field = fields.Float()
self.assert_field_raises(field, {"a": "dict"})
__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 = {
"sampleStockId": f_fields.Integer(required=True, description=""),
"name": f_fields.String(required=True, description=""),
"crystalSlurryId": f_fields.Integer(required=True, description=""),
"concentrationFactor": f_fields.Float(required=True, description=""),
"crystalDensity": f_fields.Float(required=True, description=""),
"additiveId": f_fields.Integer(
required=False, description="reference to Additive.additiveId"
),
"note": f_fields.String(required=False, description=""),
}
class SampleStockSchema(Schema):
"""Marshmallows schema class representing SampleStock table"""
sampleStockId = ma_fields.Integer()
name = ma_fields.String()
crystalSlurryId = ma_fields.Integer()
concentrationFactor = ma_fields.Float()
