default_label="Gordo Endpoints",
)
# POST type declarations
API_MODEL_INPUT_POST = api.model("Prediction - Multiple Samples",
{"X": fields.List(fields.List(fields.Float))})
API_MODEL_OUTPUT_POST = api.model(
"Prediction - Output from POST",
{"output": fields.List(fields.List(fields.Float))})
_tags = {
fields.String: fields.Float
} # tags of single prediction record {'tag-name': tag-value}
_single_prediction_record = {
"start": fields.DateTime,
"end": fields.DateTime,
"tags": fields.Nested(_tags),
"total_abnormality": fields.Float,
}
class AnomalyView(BaseModelView):
"""
Serve model predictions via POST method.
Gives back predictions looking something like this
(depending on anomaly model being served)::
{
'data': [
{
'end': ['2016-01-01T00:10:00+00:00'],
#
# List pagination for users.
#
resource_user = api.model('User', {
'id': fields.Integer(description='user id'),
'useremail': fields.String(description='The user email', required=True),
'username': fields.String(description='The user name', required=True),
'userphone': fields.String(description='The user phone', required=True),
'userdesc': fields.String(description='user description or profile', required=False),
'views': fields.Integer(min=0),
})
resource_users = api.model('Users', {
'users': fields.List(fields.Nested(resource_user), description='The user list'),
'count': fields.Integer(min=0),
'page': fields.Integer(min=0)
})
luParser = api.parser()
luParser.add_argument('page', type=int, help='Page number', location='query')
luParser.add_argument('itemsInPage', type=int, help='Number of Items in a page', location='query')
@ns.route('/users')
class Users(Resource):
@api.expect(luParser)
#@api.marshal_with(resource_users, as_list=False)
fields.String(required=True,
description='Language of the code to be executed'),
'difficulty':
fields.Integer(required=True, description='Problem difficulty'),
'time_limit':
fields.Integer(required=True,
description='Number of seconds before TLE'),
'memory_limit':
fields.Integer(required=True, description='Number of KBs before MLE'),
'topic_id':
fields.Integer(required=True, description='Problem\'s topic'),
'type':
fields.String(required=True, description='Problem type'),
'test_cases':
fields.List(
fields.Nested(case_creation),
required=True,
description='Array of strings containing the test cases\' input'),
'belongs_to':
fields.Integer(required=True, description='Parent problem'),
'is_subproblem':
fields.Boolean(required=True,
description='Is the problem a function or subproblem?')
})
evaluator_result = api.model(
'Result', {
'status':
fields.String(required=True, description='Compilation status'),
'test_cases':
fields.List(
def init(api, cors, impl):
"""Configures REST handlers for cell resource."""
namespace = webutils.namespace(api, __name__, 'Cell REST operations')
master = api.model(
'Master', {
'hostname': fields.String(description='Hostname'),
'idx': fields.Integer(description='Index of master'),
'zk-followers-port':
fields.Integer(description='ZK follower port'),
'zk-election-port': fields.Integer(description='ZK election port'),
'zk-jmx-port': fields.Integer(description='ZK JMX port'),
'zk-client-port': fields.Integer(description='ZK client port'),
})
partition = api.model(
'Partition', {
'partition': fields.String(description='Name'),
'cpu': fields.String(description='Total cpu capacity'),
'disk': fields.String(description='Total disk capacity'),
'memory': fields.String(description='Total memory capacity'),
'down-threshold':
fields.String(description='Server down threshold'),
})
model = {
'_id': fields.String(description='Name'),
'username': fields.String(description='Treadmill User ID'),
'root': fields.String(description='Treadmill Root'),
'archive-server': fields.String(description='Archive Server'),
'archive-username': fields.String(description='Archive Username'),
'ssq-namespace': fields.String(description='SSQ Namespace'),
'location': fields.String(description='Location'),
'version': fields.String(description='Version'),
'masters': fields.List(fields.Nested(master)),
'partitions': fields.List(fields.Nested(partition)),
}
cell_model = api.model('Cell', model)
@namespace.route('/')
class _CellList(restplus.Resource):
"""Treadmill Cell resource"""
@webutils.get_api(api,
cors,
marshal=api.marshal_list_with,
resp_model=cell_model)
def get(self):
"""Returns list of configured cells."""
return impl.list()
@namespace.route('/<cell>')
@api.doc(params={'cell': 'Cell ID/name'})
class _CellResource(restplus.Resource):
"""Treadmill Cell resource."""
@webutils.get_api(api,
cors,
marshal=api.marshal_with,
resp_model=cell_model)
def get(self, cell):
"""Return Treadmill cell configuration."""
return impl.get(cell)
@webutils.post_api(api,
cors,
req_model=cell_model,
resp_model=cell_model)
def post(self, cell):
"""Creates Treadmill cell."""
return impl.create(cell, flask.request.json)
@webutils.put_api(api,
cors,
req_model=cell_model,
resp_model=cell_model)
def put(self, cell):
"""Updates Treadmill cell configuration."""
return impl.update(cell, flask.request.json)
@webutils.delete_api(api, cors)
def delete(self, cell):
"""Deletes Treadmill cell."""
return impl.delete(cell)
from flask_restplus import fields
from app.apis.serializers.xfields import Any
from app.apis import api
notified_event = api.model('notified event', {
'event': fields.String(required=True, example='msg', description='notify event name'),
'data': Any(required=True),
})
notified_msg = api.model('notified msg', {
'kind': fields.String(required=True, enum=('chat', 'chat_notify'), example='chat', description='msg kind'),
'chat_id': fields.String(required=True, example='group.1', description='msg kind'),
'user': fields.String(required=True, example='cs:test:customer:u#001', description='xchat chat member uid'),
'id': fields.Integer(required=False, min=1, description='msg id'),
'msg': fields.String(required=True, description='msg content'),
'ts': fields.Integer(required=True, description='msg timestamp(unit: s)'),
'domain': fields.String(required=False, example='cs', description='msg domain'),
})
user_status = api.model('user status', {
'user': fields.String(required=True),
'status': fields.String(required=True, enum=('online', 'offline')),
})
notified_user_status = api.model('notified user status', {
'statuses': fields.List(fields.Nested(user_status), required=True),
})
from app.models import User, Group, UserGroupMembership
user_fields = Model(
'User',
{
'login': fields.String,
'first_name': fields.String,
'last_name': fields.String,
'links': {
'self': fields.Url('api.user', absolute=True),
'collection': fields.Url('api.users', absolute=True),
# 'groups': fields.List(fields.Nested('api.groups'))
}
})
user_collection = Model('UserList',
{'users': fields.List(fields.Nested(user_fields))})
group_fields = Model(
'Group',
{
# 'login': fields.String,
'full_name': fields.String,
'short_name': fields.String,
'links': {
'self': fields.Url('api.group', absolute=True),
'collection': fields.Url('api.groups', absolute=True)
# 'groups': fields.List(fields.Nested('api.groups'))
}
})
required=True, description='Limit entity candidates', example=10),
})
protag_response = server.api.model(
'protagonist', {
'id':
fields.String(required=True,
min_length=1,
description='ID of the class',
example='Q3914'),
'label':
fields.String(required=True,
min_length=1,
description='Label of the class',
example='sekolah'),
'description':
fields.String(
required=True,
min_length=1,
description='Description of the class',
example=
'institution designed to teach students under the direction of teachers'
),
'score':
fields.Float(example=1, description='Confidence score')
})
protag_response_list = server.api.model(
'protagonist_candidates_list',
{'results': fields.List(fields.Nested(protag_response))})
class UserDto:
api = Namespace('user', description='user related operations')
user_short = api.model(
'user_short', {
'username': fields.String(required=True,
description='user username'),
'name': fields.String(description='users name'),
'recipe_count': fields.Integer(),
'following_count': fields.Integer(),
'total_likes': fields.Integer(),
'badges': fields.String(),
'is_following': fields.Boolean(required=False)
})
user_self = api.clone(
'user_self', user_short, {
'email':
fields.String(required=True, description='user email address'),
'bio':
fields.String(),
'following':
fields.List(fields.Nested(user_short),
required=False,
description="The other users that a user follows"),
'followers':
fields.List(fields.Nested(user_short),
required=False,
description="The users that follow this user"),
'recipes':
fields.List(fields.Nested(RecipeDto.recipe_short),
required=False,
description="All of a User's Recipes, in short form"),
'follower_count':
fields.String(),
})
user_create = api.model(
'user_create', {
'email': fields.String(required=True,
description='user email address'),
'username': fields.String(required=True,
description='user username'),
'password': fields.String(required=True,
description='user password'),
'name': fields.String(required=True, description='users name'),
'bio': fields.String(required=True, description="users bio")
})
user_detail = api.clone(
'user_detail', user_short, {
'email':
fields.String(required=True, description='user email address'),
'bio':
fields.String(),
'total_likes':
fields.Integer(),
'following':
fields.List(fields.Nested(user_short),
required=False,
description="The other users that a user follows"),
'recipes':
fields.List(fields.Nested(RecipeDto.recipe_short),
required=False,
description="All of a User's Recipes, in short form"),
})
'Funcionario', {
'id':
fields.Integer(readOnly=True, description='Chave única do usuário'),
'nome':
fields.String(required=True,
description='Nome do usuário - Máximo 100 caracteres'),
'jornada_trabalho':
fields.Integer(
required=True,
enum=['4', '6', '8'],
description=
'Representa a jornada de trabalho do usuário (4h00, 6h00 e 8h00')
})
produto = api.model(
'Produto', {
'id':
fields.Integer(readOnly=True, description='Chave única do produto'),
'nome':
fields.String(
required=True,
description='Nome do produto - Máximo de 100 caracteres'),
'id_funcionario':
fields.Integer(attribute='id_funcionario',
description='ID do funcionário'),
'materias_primas':
fields.List(
fields.Nested(materia_prima),
description='Lista de matérias primas utilizadas no produto')
})
input_parser = MAX_API.parser()
input_parser.add_argument('audio', type=FileStorage, location='files', required=True,
help="signed 16-bit PCM WAV audio file")
input_parser.add_argument('start_time', type=float, default=0,
help='The number of seconds into the audio file the prediction should start at.')
input_parser.add_argument('filter', required=False, action='split', help='List of labels to filter (optional)')
label_prediction = MAX_API.model('LabelPrediction', {
'label_id': fields.String(required=False, description='Label identifier'),
'label': fields.String(required=True, description='Audio class label'),
'probability': fields.Float(required=True)
})
predict_response = MAX_API.model('ModelPredictResponse', {
'status': fields.String(required=True, description='Response status message'),
'predictions': fields.List(fields.Nested(label_prediction), description='Predicted audio classes and probabilities')
})
class ModelPredictAPI(PredictAPI):
model_wrapper = ModelWrapper()
@MAX_API.doc('predict')
@MAX_API.expect(input_parser)
@MAX_API.marshal_with(predict_response)
def post(self):
"""Predict audio classes from input data"""
result = {'status': 'error'}
args = input_parser.parse_args()
class RecipeDto:
api = Namespace('recipe', description='Recipe related operations')
ingredient_fields = api.model(
'ingredient', {
'text': fields.String,
'annotation': fields.String(
required=False, nullable=True, default=""),
})
step_fields = api.model(
'step', {
'text': fields.String,
'annotation': fields.String(
required=False, nullable=True, default=""),
})
image_metadata = api.model(
'image_metadata', {
'url': fields.String,
'username': fields.String,
'profile_image': fields.String,
'is_remix': fields.Boolean,
'recipe_id': fields.Integer
})
recipe_short = api.model(
'recipe_short', {
'title': fields.String,
'id': fields.Integer,
'totaltime': fields.String,
'username': fields.String,
'remix_count': fields.Integer,
'likes_count': fields.Integer,
'description': fields.String,
'featured_image': fields.String,
'liked': fields.Boolean(default=False, required=False),
'tags': fields.List(fields.String)
})
recipe_create = api.model(
'recipe_create', {
'title':
fields.String(nullable=True),
'parent_id':
fields.Integer(nullable=True),
'cooktime':
fields.String(nullable=True),
'preptime':
fields.String(nullable=True),
'totaltime':
fields.String(nullable=True),
'public':
fields.Boolean(nullable=True),
'servings':
fields.String(nullable=True),
'source':
fields.String(),
'calories':
fields.Integer,
'cost':
fields.Integer,
'difficulty':
fields.Integer,
'description':
fields.String(nullable=True),
'ingredients':
fields.List(
fields.Nested(ingredient_fields),
description='The ingredients & associated annotations'),
'steps':
fields.List(fields.Nested(step_fields),
description='The steps & associated annotations'),
'tags':
fields.List(fields.String,
description='Tags associated with this recipe')
})
recipe = api.model(
'recipe', {
'title':
fields.String,
'parent_id':
fields.Integer,
'id':
fields.Integer,
'cooktime':
fields.String,
'preptime':
fields.String,
'totaltime':
fields.String,
'username':
fields.String,
'remix_count':
fields.Integer,
'public':
fields.Boolean,
'servings':
fields.String,
'source':
fields.String,
'calories':
fields.Integer,
'cost':
fields.Integer,
'difficulty':
fields.Integer,
'likes_count':
fields.Integer,
'liked':
fields.Boolean(default=False, required=False),
'description':
fields.String,
'featured_image':
fields.String,
'owner_images':
fields.List(fields.String),
'community_images':
fields.List(fields.Nested(image_metadata)),
'remixes':
fields.List(
fields.Nested(recipe_short),
required=False,
description="All remixes of this recipe, in short form"),
'ingredients':
fields.List(
fields.Nested(ingredient_fields),
required=True,
description='The ingredients & associated annotations'),
'steps':
fields.List(fields.Nested(step_fields),
required=True,
description='The steps & associated annotations'),
'tags':
fields.List(fields.String)
})
description='Job related operations',
tag="test")
limits_model = api.model('LimitsModel', {
'cpu': fields.Integer(min=1, attribute='cpu'),
'memory': fields.Integer(min=128, attribute='memory')
})
dependency_model = api.model('DependencyModel', {
'on': fields.List(fields.String),
'job': fields.String,
'job-id': fields.String
})
resource_model = api.model('ResourceModel', {
'limits': fields.Nested(limits_model)
})
job_model = api.model('JobModel', {
'id': fields.String,
'name': fields.String,
'type': fields.String,
'state': fields.String,
'start_date': fields.DateTime,
'end_date': fields.DateTime,
'resources': fields.Nested(resource_model),
'message': fields.String,
'docker_file': fields.String,
'depends_on': fields.Nested(dependency_model),
})
def test_nullable_nested_field(self):
api = Api(self.app)
nested_fields = api.model('NestedModel', {'name': fields.String})
prop = field_to_property(fields.Nested(nested_fields, allow_null=True))
self.assertEqual(prop, {'$ref': '#/definitions/NestedModel'})
})
pagination = api.model(
'A page of results', {
'page':
fields.Integer(description='Number of this page of results'),
'pages':
fields.Integer(description='Total number of pages of results'),
'per_page':
fields.Integer(description='Number of items per page of results'),
'total':
fields.Integer(description='Total number of results'),
})
page_of_blog_posts = api.inherit(
'Page of blog posts', pagination,
{'items': fields.List(fields.Nested(blog_post))})
category = api.model(
'Blog category', {
'id':
fields.Integer(readOnly=True,
description='The unique identifier of a blog category'),
'name':
fields.String(required=True, description='Category name'),
})
category_with_posts = api.inherit(
'Blog category with posts', category,
{'posts': fields.List(fields.Nested(blog_post))})
readonly=True, description='Model status', enum=state_enums),
'num_trained_epochs':
fields.Integer(
readonly=True,
description='Current number of trained epochs for the model'),
'max_train_epochs':
fields.Integer(
required=True,
description='Maximum number of training epochs for the model'),
'warm_start_model_id':
fields.String(
required=False,
description=
'UID of the warm starting model in the case of a model clone'),
'param_vals':
fields.List(fields.Nested(param_val),
required=True,
description='Hyperparameter values'),
'metrics':
fields.List(fields.Nested(metric),
readonly=True,
description='Model training metrics'),
'exception_message':
fields.String(
readonly=True,
description=
'Exception message in the case of an model initialization failure')
})
################### Experiment ##################
experiment = api.model(
class App:
"""/caught route namespace and return data models."""
api: Namespace = Namespace(
'Caught moving targets',
path="/caught"
)
caught_data: Model = api.model('CaughtData', {
"source": fields.String(
attribute='Obs.source',
description='Observational data source'
),
"designation": fields.String(
attribute='Obj.desg',
description='Object designation'
),
"jd": fields.Float(
attribute='Found.jd',
description='mid-point of the observation and epoch for'
' ephemeris (Julian date)'
),
"ra": fields.Float(
attribute='Found.ra',
description='ephemeris Right Ascension (deg)'
),
"dec": fields.Float(
attribute='Found.dec',
description='ephemeris Declination (deg)'
),
"dra": fields.Float(
attribute='Found.dra',
description='RA * cos(Dec) rate of change (arcsec/hr)'
),
"ddec": fields.Float(
attribute='Found.ddec',
description='Declination rate of change (arcsec/hr)'
),
"unc_a": fields.Float(
attribute='Found.unc_a',
description='Error ellipse semi-major axis (arcsec)'
),
"unc_b": fields.Float(
attribute='Found.unc_b',
description='Error ellipse semi-minor axis (arcsec)'
),
"unc_theta": fields.Float(
attribute='Found.unc_theta',
description='Error ellipse position angle (deg)'
),
"vmag": fields.Float(
attribute='Found.vmag',
description='brightness estimate (magnitude); for comet ephemerides from JPL, this value is T-mag, if available, otherwise N-mag'
),
"rh": fields.Float(
attribute='Found.rh',
description='heliocentric distance (au)'
),
"rdot": fields.Float(
attribute='Found.rdot',
description='heliocentric distance rate of change (km/s)'
),
"delta": fields.Float(
attribute='Found.delta',
description='observer-target distance (au)'
),
"phase": fields.Float(
attribute='Found.phase',
description='phase angle (degrees)'
),
"selong": fields.Float(
attribute='Found.selong',
description='solar elongation (degrees)'
),
"sangle": fields.Float(
attribute='Found.sangle',
description='projected comet-sun vector position angle'
' (degrees E of N)'
),
"vangle": fields.Float(
attribute='Found.vangle',
description='projected comet velocity vector position angle'
' (degrees E of N)'
),
"trueanomaly": fields.Float(
attribute='Found.trueanomaly',
description='true anomaly based on osculating elements'
' (degrees)'
),
"tmtp": fields.Float(
attribute='Found.tmtp',
description='T-Tp, time from perihelion, based on osculating'
' elements (days)'
),
"filter": fields.String(
attribute='Obs.filter',
description='filter name'
),
"exposure": fields.Float(
attribute='Obs.exposure',
description='exposure time (s)'
),
"airmass": fields.Float(
attribute='Obs.airmass',
description='observation airmass'
),
"productid": fields.String(
attribute='Obs.productid',
description='Archive product ID'
),
"instrument": fields.String(
attribute='Obs.instrument',
description='Instrument'
),
"archive_url": fields.String(
attribute='archive_url',
description='URL to original archive image'
),
"cutout_url": fields.String(
attribute='cutout_url',
description='URL to cutout around target ephemeris'
),
"thumbnail_url": fields.String(
attribute='thumbnail_url',
description='URL to cutout thumbnail'
),
"preview_url": fields.String(
attribute='preview_url',
description='URL to preview cutout image in web format'
),
})
caught_model: Model = api.model('Caught', {
'count': fields.Integer(
description=("Number of observations that caught the target's"
" ephemeris position")
),
'job_id': fields.String(
description='Unique job ID of results'
),
'data': fields.List(fields.Nested(caught_data))
})
from views.users import User, user_response_model
from views.user_roles import UserRoleService
from views.roles import RoleService, role_response_model
api = Namespace('whoami', description="who am i api")
class WhoAmIService(object):
@classmethod
def whoami(cls, id):
user = User.query.filter_by(id=id).first()
user = user.as_dict()
user_role = UserRoleService.get_user(id)
school_id = user_role.school_id
role = RoleService.get(user_role.role_id)
user['school_id'] = school_id
user['role'] = role
return user
whoami_response_model = api.inherit('User_Whoami', user_response_model, {
'school_id': fields.String(description="The school id"),
'role': fields.Nested(role_response_model),
})
@api.route('/')
class UserWhoAmIResource(Resource):
@api.doc('get user info')
@api.marshal_with(whoami_response_model)
@jwt_required()
def get(self):
'''Get user info by access token'''
return WhoAmIService.whoami(current_identity['user_id'])
'pondsdischargedtoenv': fields.String, 'pondsreclamation': fields.String, 'pondsreclamationcost': fields.Arbitrary, 'sandgrvqrytotalexistdistarea': fields.Arbitrary, 'nrsosapplicationid': fields.String, 'isblastselect': fields.String, 'istimberselect': fields.String, 'applicant': fields.Nested(CLIENT), 'submitter': fields.Nested(CLIENT), 'documents': fields.List(fields.Nested(DOCUMENT)), 'contacts': fields.List(fields.Nested(CONTACT)), 'existing_placer_activity': fields.Nested(PLACER_ACTIVITY), 'existing_settling_pond': fields.Nested(SETTLING_POND), 'exp_access_activity': fields.List(fields.Nested(EXP_ACCESS_ACTIVITY)), 'exp_surface_drill_activity': fields.List(fields.Nested(EXP_SURFACE_DRILL_ACTIVITY)), 'proposed_placer_activity':
'name': fields.String(),
'description': fields.String(),
'is_active': fields.Boolean(),
'created_at': fields.DateTime(),
'updated_at': fields.DateTime(),
'user_created': fields.String(),
'categories': fields.List(fields.Integer()),
'quantity_in_stock': fields.Integer(),
'price': fields.Float()
})
book_list_model = ns.model(name='BookListModel',
model={
'total': fields.Integer(),
'results':
fields.List(fields.Nested(book_model))
})
@ns.route('/list/')
class BookList(Resource):
@ns.marshal_with(book_list_model)
@ns.doc(
params={
'_page': 'page number',
'_limit': 'size in page',
'q': 'key search by name',
'_sort': 'Sort field',
'_order': 'Sort type',
'is_active': 'Filter status'
})
"releaseDate": fields.Date(attribute="release_date"),
"actors": fields.List(fields.String(required=True)),
"genres": fields.List(fields.String(required=True)),
"sumOfMarks": fields.Integer(readonly=True, attribute="sum_of_marks"),
"numberOfMarks": fields.Integer(readonly=True,
attribute="number_of_marks")
})
mark_data_fields = api.model(
"Mark Data",
{"mark": fields.Integer(required=True, min=1, max=100, example=75)})
movie_action_fields = api.model(
"Movie Action", {
"type": fields.String(required=True, example="rate"),
"data": fields.Nested(mark_data_fields, required=True)
})
def create_or_update_movie_with_payload(movie_id=None):
if movie_id is not None:
movie = Movie.objects.get_or_404(id=movie_id)
else:
movie = Movie()
movie.title = api.payload.get("title", movie.title)
movie.release_date = api.payload.get("releaseDate", movie.release_date)
movie.actors = api.payload.get("actors", movie.actors)
movie.genres = api.payload.get("genres", movie.genres)
try:
Define a swagger model that can be used for:
- defining expected shape of inputs/outputs to the api
- autogenerate swagger documentation for the structure of api data
"""
arch_extract_list_elem = api.model('ArchExtractListElem', {
'label': fields.String(
required=False,
description='Id of arch extract record'),
'archExtractId': fields.Integer(
required=True,
description='Id of arch extract record'),
})
arch_extract_list = api.model('ArchExtractList', {
'archExtractIdList': fields.List(fields.Nested(arch_extract_list_elem, skip_none=True)),
})
arch_extract_new_input = api.model('ArchExtractNewInput', {
'label': fields.String(
required=False,
),
})
arch_extract_output_record = api.model('ArchExtractOutput', {
'archExtractOutputId': fields.Integer(
required=True,
),
'archExtractOutputFilename': fields.String(
required=True,
),
# app = Flask(__name__)
app.wsgi_app = ProxyFix(app.wsgi_app)
api = Api(app,title='TODO_API')
ns = api.namespace('TODO\'s', description='TODO operations')
todoState = api.model('TodoState',{
'Not_Started': fields.Integer(description='Work is Not Started Yet!'),
'In_Progress': fields.Integer(description='Work is Started But Not Finished Yet!'),
'Finished': fields.Integer(description='Work is Finished!'),
})
todo = api.model('Todo', {
'task': fields.String(required=True, description='Task Details'),
'due_by':fields.Date(required=True,description='Deadline For Task to be Finished!'),
'status':fields.Nested(todoState),
})
todoUpdate = api.model('TodoUpdate', {
'task': fields.String(readonly=True, description='Task Details'),
'due_by':fields.Date(readonly=True,description='Deadline For Task to be Finished!'),
'status':fields.Nested(todoState),
})
@ns.route("/")
class TodoList(Resource):
@ns.doc("List Of Todos")
@ns.marshal_list_with(todo,code=201)
def get(self):
'''List Of All Tasks..'''
Obj = Todo.query.all()
def create_model_data_raw( ns_,
model_name = "Data_raw",
schema = "tag",
) :
"""
data_raw_fields model
"""
if schema in ["dmf", "tag" ] :
if schema == "tag" :
schema_ = f_basics_tag
if schema == "dmf" :
schema_ = f_basics_dmf
data_raw_fields = fields.Nested(
ns_.model( model_name , schema_ ),
description = "Data_raw"
)
if schema in [ "dsi", "dsr", "dso" ] :
### JUST A DRAFT
# raw_nested_fields = fields.Nested(
# ns_.model( model_name , { "arbitrary_field" : RawData} ),
# description = "Data_raw"
# )
# raw_field = fields.List(
# RawData ,
# description = "List of the {}s on this document".format(model_name),
# default = []
# )
if schema == "dso" :
schema_f = f_headers_dso
else :
schema_f = f_headers_ds
f_coll_headers = fields.Nested(
ns_.model( model_name , schema_f ),
description = "Coll_headers"
)
f_coll_headers_list = fields.List(
f_coll_headers,
description = "List of {}s on this document".format(schema),
default = []
)
schema_ = {
"f_col_headers" : f_coll_headers_list,
# "f_col_headers" : f_coll_headers,
"f_data" : f_data,
}
data_raw_fields = fields.Nested(
ns_.model( model_name , schema_ ),
description = "Data_raw"
)
if schema in [ "rec" ] :
data_raw_fields = fields.Nested(
ns_.model( model_name , f_basics_rec ),
description = "Data_raw"
)
return data_raw_fields
'''
* Author : see AUTHORS
* Licence: MIT, see LICENSE
'''
from flask_restplus import fields
from src.api.apiConfig import api
charset_model = api.model(
'charset', {
'id': fields.Integer(readOnly=True, required=False),
'name': fields.String(readOnly=True, required=False),
'keyspace': fields.Integer(),
'time': fields.DateTime(readOnly=True, required=False),
'data': fields.String()
})
charsetCollection_model = api.inherit(
'Charset collection', {'items': fields.List(fields.Nested(charset_model))})
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from flask_restplus import fields
from app import api
cts_stats_fields_attributes = api.model(
'CtsStats', {
'containers':
fields.Nested(
api.model(
'CtsContainers', {
'names': fields.List(fields.String),
'count': fields.Integer,
'count_running': fields.Integer
})),
'cpus':
fields.Nested(
api.model(
'CtsCPUs', {
'cpus_count': fields.Integer,
'cpus_usage': fields.Integer,
'processes_count': fields.Integer
})),
'memory':
fields.Nested(
api.model(
'CtsMemory', {
'memory_count': fields.String,
'memory_current_count': fields.Float
})),
'disk':
'cert_crt': fields.String(),
'cert_key': fields.String(),
'verify': fields.String(),
'sender': fields.String(),
'recipient': fields.String(),
'server': fields.String(),
'port': fields.String(),
'login': fields.String(),
'password': fields.String(),
'production_name': fields.String()
})
_lxdconfig_fields_get = api.model(
'LXDConfigFieldsGet', {
'type': fields.String(default='lxdconfig'),
'attributes': fields.Nested(lxdconfig_fields_attributes),
'id': fields.Integer(default=1)
})
lxdconfig_fields_get = api.model(
'LXDConfigGet', {'data': fields.Nested(_lxdconfig_fields_get)})
lxdconfig_fields_post = api.model(
'LXDConfigPost', {
'endpoint': fields.String(required=True),
'cert_crt': fields.String(required=True),
'cert_key': fields.String(required=True),
'verify': fields.String(required=True, default='False'),
'sender': fields.String(required=True),
'recipient': fields.String(required=True),
'server': fields.String(required=True),
'BasicMineLocation', {
'latitude': fields.String,
'longitude': fields.String,
'utm_easting': fields.String,
'utm_northing': fields.String,
'utm_zone_number': fields.String,
'utm_zone_letter': fields.String,
'mine_location_description': fields.String,
})
BASIC_MINE_LIST = api.model(
'BasicMineList', {
'mine_guid': fields.String,
'mine_name': fields.String,
'mine_no': fields.String,
'mine_location': fields.Nested(BASIC_MINE_LOCATION_MODEL),
})
MINE_TENURE_TYPE_CODE_MODEL = api.model('MineTenureTypeCode', {
'mine_tenure_type_code': fields.String,
'description': fields.String,
})
MINE_LOCATION_MODEL = api.model(
'MineLocation', {
'latitude':
fields.Fixed(description='fixed precision decimal.', decimals=7),
'longitude':
fields.Fixed(description='fixed precision decimal.', decimals=7),
'utm_easting':
fields.String,
'contact_people',
{
'email': fields.String(required=True, attribute='contact.email'),
'person': fields.String(required=True, attribute='person.full_name')
}
)
company_fields = company_api.model(
'Company',
{
'id': fields.Integer(),
'name': fields.String(
required=True,
description="Company name",
example="test_company"),
'address': fields.Nested(address_fields),
'tech_person': fields.Nested(contact_people_fields),
'legal_person': fields.Nested(contact_people_fields),
'date_created': fields.DateTime(
required=False,
attribute='date_created'),
'date_modified': fields.DateTime(
required=False,
attribute='date_modified'),
}
)
@company_api.route('', endpoint='company')
class CompaniesEndPoint(Resource):
from flask_restplus import fields
from api.restplus import api
from api.courses.serializers import course
from api.users.serializers import user
from api.teams.serializer import team
from api.assignments.serializers import assignment
group = api.model('Group', {
'id': fields.Integer(required=True, description='Group id'),
'period': fields.String(required=True, description='Group period'),
'professor_id': fields.Integer(required=True, description='Group professor id'),
'course': fields.Nested(course),
'students': fields.List(fields.Nested(user)),
'assignments': fields.Nested(assignment),
'teams': fields.List(fields.Nested(team))
})
group_with_students = api.model('GroupWithStudents', {
'id': fields.Integer(required=True, description='Group id'),
'period': fields.String(required=True, description='Group period'),
'professor_id': fields.Integer(required=True, description='Group professor id'),
'course': fields.Nested(course),
'students': fields.List(fields.Nested(user))
})
group_with_assignments = api.model('GroupWithAssignments', {
'id': fields.Integer(required=True, description='Group id'),
'period': fields.String(required=True, description='Group period'),
'professor_id': fields.Integer(required=True, description='Group professor id'),
'course': fields.Nested(course),
'assignments': fields.Nested(assignment)
'Offer minimal model', {
'id':
fields.String(required=True, description='Offer ID'),
'facilitator_id':
fields.String(required=True,
description='Facilitator ID',
attribute=lambda o: o.facilitator.id),
'name':
fields.String(required=True, description='Name'),
'tags':
fields.List(fields.String(), required=True, description='Tags'),
'price':
fields.Integer(required=True, description='Price')
})
offer_model = api.inherit(
'Offer model', offer_minimal_model, {
'description':
fields.String(required=True, description='Description'),
'facilitator':
fields.Nested(
facilitator_nested, required=True, description='Facilitator')
})
offer_container = api.model(
'Offer container', {
'offers':
fields.List(fields.Nested(offer_minimal_model),
required=True,
description='Offers list')
})
