class GbcMachineLearningService(Resource):
from api import api
logger = loggerElk(__name__, True)
nlp = None
machineLearningService = api.model('MachineLearningService', {
'source': fields.String(required=True, description='Source of the data (PLAINTEXT | FILE | IMAGE | S3)'),
'data': fields.String(required=True, description='Repo resource identifier (url)'),
'domain': fields.String(required=True, description='Repo resource identifier (domain name)'),
'model': fields.String(required=True, description='Source of classifier '
'(BAGGING | BOOSTING_ADA | BOOSTING_SGD '
'| DECISION_TREE | EXTRA_TREES | NAIVE_BAYES_MULTI '
'| NAIVE_BAYES_COMPLEMENT | RANDOM_FOREST | VOTING '
'| CNN_NETWORK)'),
'lang': fields.String(required=True, description='Language (es, en)'),
})
def __init__(self, *args, **kwargs):
# start - JAEGER
config = Config(config={'sampler': {'type': 'const', 'param': 1},
'logging': True
},
service_name=__name__)
config.initialize_tracer()
super().__init__(*args, **kwargs)
trace_requests() # noqa
# end - JAEGER
@api.doc(
description='Machine Learning Service',
responses={
200: 'OK',
400: 'Invalid Argument',
500: 'Internal Error'})
@api.expect(machineLearningService)
def post(self):
root_span = None
try:
self.logger.Information('GbcMachineLearningService::POST - init')
# start - JAEGER
root_span = opentracing.tracer.start_span(operation_name=inspect.currentframe().f_code.co_name)
# end - JAEGER
request_payload = request.get_json()
# self.logger.LogInput('GbcMachineLearningService::POST: ', request_payload)
source = request_payload['source']
data = request_payload['data']
domain = request_payload['domain']
model = request_payload['model']
lang = request_payload['lang']
if source == 'PLAINTEXT':
response = 'PLAINTEXT'
elif source == 'FILE':
response = 'FILE'
elif source == 'IMAGE':
response = 'IMAGE'
elif source == 'S3':
s3 = self.getS3Session()
return {'result': 'not implemented'}
else:
response = ''
raise Exception('No valid source provided')
res = {
'result': 'ok',
'response': response
}
return jsonify(res)
except Exception as e:
self.logger.Error('ERROR - GbcMachineLearningService::POST' + str(e.args), sys.exc_info())
return {'message': 'Something went wrong: ' + str(e)}, 500
finally:
root_span.finish()
class Student(object):
def __init__(self, first_name: str, last_name: str):
self.first_name = first_name
self.last_name = last_name
@classmethod
def getS3Session(cls):
session = boto3.Session(
aws_access_key_id=os.environ['ENV_ACCESS_KEY_ID'],
aws_secret_access_key=os.environ['ENV_SECRET_ACCESS_KEY']
)
s3 = session.client(u's3')
return s3
from api import api, db
from flask import request
from models.meeting import MeetingModel
from models.room import RoomModel
from models.price import PriceModel
from datetime import datetime
from session import require_session
meeting_api = Namespace('meeting')
requestSchema = {
"MeetingCreateModel": api.model("create a meeting", {
"name": fields.String(required=True, example="Hairspray",
description="name of meeting"),
"description": fields.String(required=True, example="A musical written by...",
description="short description of the meeting"),
"room": fields.String(required=True),
"date": fields.Integer(required=True),
"start": fields.Integer(required=True),
"stop": fields.Integer(required=True),
}),
"MeetingGetAllModel": api.model("get all meetings", {
}),
"MeetingGetModel": api.model("get specific meeting", {
"uuid": fields.String(required=True, example="12abc34d5efg67hi89j1klm2nop3pqrs",
description="name of meeting")
}),
"MeetingUpdateModel": api.model("create a meeting", {
"uuid": fields.String(required=True, example="12abc34d5efg67hi89j1klm2nop3pqrs",
description="name of meeting"),
"name": fields.String(required=True, example="Hairspray",
description="name of meeting"),
from flask import Flask
from flask_restplus import Resource, fields
from api import api
ns = api.namespace('todos', description='TODO operations')
todo = api.model('Todo', {
'id': fields.Integer(readOnly=True, description='The task unique identifier'),
'task': fields.String(required=True, description='The task details')
})
class TodoDAO(object):
def __init__(self):
self.counter = 0
self.todos = []
def get(self, id):
for todo in self.todos:
if todo['id'] == id:
return todo
api.abort(404, "Todo {} doesn't exist".format(id))
def create(self, data):
todo = data
todo['id'] = self.counter = self.counter + 1
self.todos.append(todo)
return todo
def update(self, id, data):
todo = self.get(id)
from flask_restplus import Resource
from flask import request
from flask_restplus import fields, reqparse
from api import api
from model.todomodel import TodoModel
todo_post = api.model(
'Todo post', {
'text':
fields.String(required=True, description='description of todo'),
'completed':
fields.Boolean(required=False, description='todo is complited or not'),
'completedAt':
fields.Float(required=False, description='todo completed time')
})
pagination_arguments = reqparse.RequestParser()
pagination_arguments.add_argument('page',
type=int,
required=False,
default=1,
help='Page number')
pagination_arguments.add_argument('bool',
type=bool,
required=False,
default=1,
help='Page number')
pagination_arguments.add_argument('per_page',
type=int,
required=False,
IssueFinder,
IssueUpdater,
IssueDeleter,
IssueStageHandler,
Stages,
)
from tools.kanbans_tools import KanbanFinder
from tools.config_reader import ConfigReader
from tools.xml_tools import update_xml_attribute
issue_model = api.model(
"Issue Model",
{
"name":
fields.String(required=True, description="Issue name"),
"description":
fields.String(required=False, description="Issue description"),
"creator":
fields.String(required=False, description="User-creator of the issue"),
},
)
issue_model_stage = api.model(
"Issue-stage Model",
{
"stage": fields.String(required=True, description="Stage name"),
},
)
config = ConfigReader()
# PAGINATION
from tools.xml_tools import update_xml_attribute
from tools.config_reader import ConfigReader
from tools.kanbans_tools import KanbanFinder, KanbanCreator, KanbanDeleter
from api import api, logger
ns = api.namespace(
"resources/kanbans",
description=
"Operations related to kanban boards located in management module",
)
kanban_model = api.model(
"Kanban Model",
{
"name":
fields.String(required=True, description="Kanban name"),
"description":
fields.String(required=True, description="Kanban description"),
},
)
# Config file reader (from env variable)
config = ConfigReader()
@ns.route("/")
class KanbansAll(Resource):
""" Endpoints for kanbans """
@api.response(200, "Kanban boards fetched")
@api.response(500, "Could not fetch Kanban boards info")
def get(self):
from flask import request
from models.seat import SeatModel
from session import require_session
seat_api = Namespace('seat')
requestSchema = {
"CreateSeatModel":
api.model(
"create seat", {
"room":
fields.String(required=True,
example="12abc34d5efg67hi89j1klm2nop3pqrs",
description="uuid of room"),
"block":
fields.Integer(required=True),
"row":
fields.Integer(required=True),
"count":
fields.Integer(),
"type":
fields.Integer(required=True),
}),
"SpecificSeatModel":
api.model(
"specific seat", {
"uuid":
fields.String(required=True,
example="12abc34d5efg67hi89j1klm2nop3pqrs",
description="uuid of seat"),
}),
from flask_bcrypt import check_password_hash, generate_password_hash
from models.administrator import AdministratorModel
from models.session import SessionModel
from session import require_session
from flask import jsonify
administrator_api = Namespace('administrator')
requestSchema = {
"AdministratorModel":
api.model(
'administrator with password', {
"firstname":
fields.String(
required=True, example="Max", description="firstname"),
"lastname":
fields.String(
required=True, example="Mustermann", description="lastname"),
"password":
fields.String(
required=True, example="qwertz", description="password"),
}),
"SpecificAdministratorModel":
api.model(
'administrator', {
"firstname":
fields.String(
required=True, example="Max", description="firstname"),
"lastname":
fields.String(
required=True, example="Mustermann", description="lastname"),
}),
from flask_restplus import fields, reqparse
from api import api
upload_parser = api.parser()
upload_parser.add_argument('image_file', location='files'
, type=werkzeug.datastructures.FileStorage
, required=True
, help="Image file")
upload_parser.add_argument(
'city', type=str
, required=True
, help="Which city you are in?"
)
camera_capture_parser = api.parser()
camera_capture_parser.add_argument(
'image_string', type=str
, required=True
, help="Camera capture image screen"
)
camera_capture_parser.add_argument(
'city', type=str
, required=True
, help="Which city you are in?"
)
camera_capture = api.model('camera_capture', {
"image_string": fields.String(required=True, description="Camera capture base64 image string.")
})
from flask import request
from flask_restplus import Resource, fields
from api import api
from api import db_worker
input_model = api.model(
"Input Model",
{
"name": fields.String(required=True, help="Nama Peserta"),
"member_id": fields.String(required=True, help="Nomor Induk Peserta"),
"email": fields.String(required=True, help="Alamat Email Peserta"),
},
)
@api.route("/test")
class Test(Resource):
@api.doc(body=input_model)
def post(self):
data = request.get_json()
status, code, msg = db_worker.insert_data(data)
return {"msg": msg}, code
"""
Serialization specifications for the REST API.
"""
from flask_restplus import fields
from api import api
nomination = api.model(
'Nomination', {
'name':
fields.String(required=True, description='The name of the nomination'),
'pic_path':
fields.String(description='The local path to the inserted picture'),
'seconded':
fields.Boolean(
description=
'Indicates whether or not the nomination has been seconded'),
'votes':
fields.Integer(
description='The number of votes that the nomination has received')
})
from flask.ext.restplus import fields
from api import api
point_model = api.model('Point', {
'id': fields.Integer,
'x': fields.Float,
'y': fields.Float
})
tsp_model_input = api.model('TSP', {
'graph': fields.Nested(point_model, description='List of graph points')
})
tsp_model_output = api.model('TSP', {
'expected': fields.List(fields.List(fields.Float), description='Two dimensional array with data'),
'net': fields.List(fields.List(fields.Float), description='Two dimensional array with data'),
'expected_order': fields.List(fields.Integer, description='Expected order of points'),
'net_order': fields.List(fields.Integer, description='Order of points'),
'net_error': fields.Float(description='Network error')
})
from datetime import datetime
ticket_api = Namespace('ticket')
requestSchema = {
"CreateTicketModel":
api.model(
"create ticket", {
"price":
fields.String(required=True,
example="12abc34d5efg67hi89j1klm2nop3pqrs",
description="uuid of price"),
"seat":
fields.String(required=True,
example="12abc34d5efg67hi89j1klm2nop3pqrs",
description="uuid of seat"),
"meeting":
fields.String(required=True,
example="12abc34d5efg67hi89j1klm2nop3pqrs",
description="uuid of meeting"),
"customer":
fields.String(required=True,
example="12abc34d5efg67hi89j1klm2nop3pqrs",
description="uuid of customer"),
}),
"SpecificTicketModel":
api.model(
"specific ticket", {
"uuid":
fields.String(required=True,
example="12abc34d5efg67hi89j1klm2nop3pqrs",
# coding=utf-8
import logging
from flask_restplus import fields
from api import api
from helpers.error_handler_helper import HandledError
__author__ = 'Tung.Luu'
_logger = logging.getLogger(__name__)
GENERAL_RESP = api.model('GENERAL_RESP', {
'error': fields.Integer(),
'data': fields.String()
})
class BaseApi(object):
@staticmethod
def api_response(http_code=200, data=None, error=None, handled_error=None):
""" Return http response
:param str error: error message, null if no error
:param obj data: response data
:param int http_code:
"""
if isinstance(handled_error, HandledError):
error, http_code = handled_error.message, handled_error.error_code
elif http_code == 500:
error = error or 'Internal server error!'
elif http_code == 200:
data = data or 'Success'
return (
from api import api
from flask_restplus import fields
signup = api.model(
'signup_form', {
'fullname': fields.String(required=True),
'phone': fields.String(required=True),
'password': fields.String(required=True),
'email': fields.String(required=True),
'deviceID': fields.String(),
'job': fields.String(),
'department': fields.String(),
'organization': fields.String(),
'address': fields.String(),
'address': fields.String(),
'userID': fields.Integer(),
'activate': fields.Boolean(),
})
login = api.model(
'login_form', {
'phone': fields.String(required=True),
'password': fields.String(required=True),
})
from api import api, db
from flask import request
from models.price import PriceModel
from session import require_session
price_api = Namespace('price')
requestSchema = {
"CreatePriceModel":
api.model(
"create price", {
"name":
fields.String(
required=True, example="Adults", description="name of price"),
"description":
fields.String(required=True,
example="person above 18 years",
description="filter for of price"),
"value":
fields.Integer(
required=True, example="15", description="amount of price")
}),
"SpecificPriceModel":
api.model(
"specific price", {
"uuid":
fields.String(required=True,
example="12abc34d5efg67hi89j1klm2nop3pqrs",
description="uuid of price"),
})
}
from api import api
from flask_restplus import fields
new_user = api.model(
'NewUser', {
'email': fields.String(description='user email', required=True),
'password': fields.String(description='password', required=True),
})
user = api.model(
'User', {
'email': fields.String(description='User id', required=True),
'balance': fields.Float(description='Current User balance',
required=True)
})
login_info = api.model(
'LoginInfo', {
'email': fields.String(description='user email', required=True),
'password': fields.String(description='password', required=True),
})
auth_info = api.model(
'AuthInfo', {
'token': fields.String(description='Oldrefresh token', required=True),
})
phone_number = api.model('PhoneNumber', {
'phone_number':
fields.String(description='Phone number', required=True),
})
from .model import UserModel
from api import api
from bson.objectid import ObjectId
user_ns = api.namespace('user', description='Operations related to user')
'''Response Marshals'''
user_output = api.model('user_output', {
'user_id': fields.String(description='User Id'),
'username': fields.String(description='Username of a user'),
'first_name': fields.String(description='First name of a user'),
'last_name': fields.String(description='Last Name of a user'),
'email': fields.String(description='Email Address'),
'date_of_birth': fields.DateTime(description='Date of birth of a user'),
'active': fields.Boolean(description='Is the user active'),
'creation_date': fields.DateTime(description='Date when the user was created'),
'email_verified': fields.Boolean(description='Is the email verified'),
'address_line_one': fields.String(description='First line of the address'),
'address_line_two': fields.String(description='Second line of the address'),
'city': fields.String(description='City'),
'state': fields.String(description='State'),
'zip': fields.Integer(description='Zip code'),
'license': fields.String(description='license number')
})
user_input = api.model('user_input', {
'username': fields.String(description='Username of a user'),
'password': fields.String(description='Password of a user'),
'first_name': fields.String(description='First name of a user'),
'last_name': fields.String(description='Last Name of a user'),
'email': fields.String(description='Email Address'),
from flask_restplus import fields
from api import api
fitness_data = api.model(
'Fitness data', {
'value':
fields.Integer(
readOnly=True, required=True, description="Value to save"),
})
activity_data = api.model(
'Activity Data', {
'name':
fields.String(
readOnly=True, required=True, description="Name of the activity"),
'datetime':
fields.DateTime(
readOnly=True, required=True, description="Activity date time"),
'duration':
fields.Integer(
readOnly=True, required=True, description="Activity duration"),
})
food_data = api.model(
'Food Data', {
'name':
fields.String(
readOnly=True, required=True, description="Name of the food"),
'datetime':
fields.DateTime(
readOnly=True, required=True, description="Activity date time"),
from flask_restplus import Api, Resource, fields
from api import api, db
from api import models
from flask import jsonify
todo = api.model(
'Todo', {
'id':
fields.Integer(readOnly=True,
description='The task unique identifier'),
'title':
fields.String(required=True, description='The task details'),
'complete':
fields.Boolean(required=False, description='The task completed')
})
ns = api.namespace('todos', description='TODO operations')
@api.route('/todos')
class TodoList(Resource):
@api.doc('create_todo')
@api.marshal_list_with(todo)
def get(self):
return [td.to_dict() for td in models.Todo.query.all()]
@api.doc('create_todo')
@api.expect(todo)
@api.marshal_with(todo, code=201)
def post(self):
todo = api.payload
from flask_restplus import Namespace, Resource, fields, abort
from api import api, db
from flask import request
from models.setting import SettingModel
from session import require_session
setting_api = Namespace('setting')
requestSchema = {
"SettingUpdateService": api.model("update a setting", {
"key": fields.String(required=True, example="color",
description="key of setting"),
"value": fields.String(required=True, example="blue",
description="value of setting")
}),
"GetSettingService": api.model("get a setting", {
"key": fields.String(required=True, example="color",
description="key of setting")
})
}
responseSchema = {
}
@setting_api.route('/<string:key>')
@setting_api.doc('get setting')
class GetSettingService(Resource):
@setting_api.doc('get a setting')
@setting_api.expect(requestSchema["GetSettingService"])
requestSchema = {
"CustomerCreateSchema":
api.model(
"create request", {
"uuid":
fields.String(required=True,
example="12abc34d5efg67hi89j1klm2nop3pqrs",
description="uuid"),
"email":
fields.String(required=True,
example="*****@*****.**",
description="email address"),
"firstname":
fields.String(
required=True, example="Max", description="firstname"),
"lastname":
fields.String(
required=True, example="Mustermann", description="lastname"),
"address":
fields.String(
required=True,
example="Musterstreet 123",
description="street with addition of the housenumber"),
"place":
fields.String(
required=True, example="Mustercity", description="place")
}),
"CustomerInformationSchema":
api.model(
"get information request", {