import logging from flask import request from flask_restplus import Resource from app.api.bigquery.business_interactions import get_request_status, run_query, ndex from app.api.bigquery.serializers import query_request, query_status_response, query_response, ndex_request, ndex_response from app.api.bigquery.parsers import query_url_parser from app.api.restplus import api from app.database.models import TestModel from app import settings log = logging.getLogger(__name__) ns = api.namespace('interactions', description="""Mine the interaction profiles of various entities """) @ns.route('/ndex') class NDExSubmit(Resource): @ns.doc(model=ndex_response) @ns.expect(ndex_request) def post(self): log.info("%s" % (str(request.json), )) response = ndex(request.json) code = 200 if response['status'] == 'complete' else 404 return response, code @ns.doc(params={'request_id': 'The request id for a query'})
import logging #from flask_restplus import Resource, fields from neomodel.core import DoesNotExist from werkzeug.exceptions import BadRequest from quart import Response from app.api.restplus import api from app.models import User log = logging.getLogger(__name__) ns = api.namespace('users', description='Users') user = api.model('user', { 'id': fields.Integer(readOnly=True, description='The internal id of of a user'), 'user_id': fields.String(required=True, description='The user unique identifier')} ) @ns.route('/') @api.response(404, 'Users not found.') class UsersList(Resource): @api.marshal_list_with(user) def get(self): """ Returns a list of all users :return: list_of_users """ try:
import logging from flask import Response from flask_restplus import Resource, fields from neomodel.core import DoesNotExist from neomodel import MultipleNodesReturned from app.api.restplus import api from app.models import Browser log = logging.getLogger(__name__) ns = api.namespace('browsers', description='Browsers') browser = api.model('browser', { 'id': fields.Integer(readOnly=True, description='The internal id of the browser.'), 'type': fields.String(required=True, description='The type of the browser.'), 'version': fields.String(required=True, description='The version of the browser.') }) @ns.route('/') class BrowserList(Resource): @api.marshal_list_with(browser) def get(self): """ Returns a list with all browsers :return: list_of_browsers """ try:
from flask import request from flask_restplus import Resource from sqlalchemy.exc import IntegrityError from werkzeug.exceptions import BadRequest from app.api.restplus import api from app.api.serializers import user from app.extensions import db from app.models.User import User ns = api.namespace('users', description='Operations related to users') @ns.route('') class UsersCollection(Resource): @api.marshal_list_with(user) def get(self): """ Returns list of users """ return User.query.filter(User.delete_flag == 0).all(), 200 @api.response(201, 'User successfully created.') @api.expect(user) def post(self): """ Register a new user """ try: user = User(email=request.json.get('email')) db.session.add(user)
import logging from flask import Response from flask_restplus import Resource, fields from neomodel.core import DoesNotExist from app.api.restplus import api from app.models import Device log = logging.getLogger(__name__) ns = api.namespace('devices', description='Device') device = api.model('device', { 'id': fields.Integer(readOnly=True, description='The internal id of the application.'), 'family': fields.String(required=True, description='The family (e.g.: iOS, Android, Windowss, etc...) of the device.'), 'brand': fields.String(required=True, description='The brand of the device.'), 'model': fields.String(required=True, description='The model of the device.'), 'type': fields.String(required=True, description='The type of the device.'), 'is_touch_capable': fields.Boolean(required=True, description='Indicates if the device is touch capable.') }) @ns.route('/') class DevicesList(Resource): @api.marshal_list_with(device) def get(self): """ Return a list with all devices. :return: list_of_devices """
import logging from flask import request from flask_restplus import Resource from app.api.blog.business import create_blog_post, update_post, delete_post from app.api.blog.serializers import blog_post, page_of_blog_posts from app.api.blog.parsers import pagination_arguments from app.api.restplus import api from app.database.models import Post log = logging.getLogger(__name__) ns = api.namespace('blog/posts', description='Operations related to blog posts') @ns.route('/') class PostsCollection(Resource): @api.expect(pagination_arguments) @api.marshal_with(page_of_blog_posts) def get(self): """ Returns list of blog posts. """ args = pagination_arguments.parse_args(request) page = args.get('page', 1) per_page = args.get('per_page', 10) posts_query = Post.query posts_page = posts_query.paginate(page, per_page, error_out=False)
import logging from flask import request from flask_restplus import Resource from app.api.test.business import create_new_entry from app.api.test.serializers import entry from app.api.test.parsers import pagination_arguments from app.api.restplus import api log = logging.getLogger(__name__) ns = api.namespace('tests', description='Operations related to health tests') @ns.route('/') class TestsCollection(Resource): def get(self): """ Returns list of health tests """ tests = ['database is ok', 'api-1 is ok', 'api-2 is ok'] return tests @api.expect(entry) def post(self): """ Creates a new entry """ create_new_entry(request.json)
import logging from flask import Response from flask_restplus import Resource, fields from neomodel.core import DoesNotExist from app.api.restplus import api, base_reponse from app.models import Session log = logging.getLogger(__name__) ns = api.namespace('sessions', description='Sessions') session = api.model('session', { 'id': fields.Integer(readOnly=True, description='The internal id of of a session.'), 'session_id': fields.String(required=True, description='The session id.'), 'ip_address': fields.String(required=True, description='A list of IP addresses ' 'used during the session.'), 'start': fields.DateTime(required=True, description='The date and time when the session ' 'started.'), 'end': fields.DateTime(required=True, description='The date and time when the session ended.'), 'timeout': fields.DateTime(required=True, description='The date and time when the session timedout.') }) # TODO - Define endpoints that return sessions that started, ended and timedout in a date/time range, used a given ip address @ns.route('/') class SessionsList(Resource): @api.marshal_list_with(session) def get(self): """
import logging from flask import request from flask_restplus import Resource from app.api.blog.business import create_category, delete_category, update_category from app.api.blog.serializers import category, category_with_posts from app.api.restplus import api from app.database.models import Category log = logging.getLogger(__name__) ns = api.namespace('blog/categories', description='Operations related to blog categories') @ns.route('/') class CategoryCollection(Resource): @api.marshal_list_with(category) def get(self): """ Returns list of blog categories. """ categories = Category.query.all() return categories @api.response(201, 'Category successfully created.') @api.expect(category) def post(self): """ Creates a new blog category. """
import logging from flask import request, abort from flask_restplus import Resource from app.api.visitor.serializers import logvisit_location from app.api.restplus import api from app import User from app.api.visitor.business import getLastLocation log = logging.getLogger(__name__) ns = api.namespace('tracking', path='/visitor', description='Operations related to visits') parser = api.parser() auth_token_help = 'API Authentication token <token_auth>' parser.add_argument('token_auth', required=True, help=auth_token_help, type=str, location='headers') # create copy of parser and add payload, for POST and PUT methods parser_payload = parser.copy() parser_payload.add_argument('Payload', required=True, help='JSON Payload', type='list', location='json')
from flask_restplus import Resource from app.api.bigquery.business_interactions import get_request_status, run_query, ndex from app.api.bigquery.serializers import query_request, query_status_response, query_response, ndex_request, ndex_response from app.api.bigquery.parsers import query_url_parser from app.api.restplus import api from app.database.models import TestModel from app import settings from app.api.bigquery.endpoints.bglite import ns as lilgim from app.api.bigquery.endpoints.biggim import ns as biggim from app.api.bigquery.endpoints.bigclam import ns as bigclam log = logging.getLogger(__name__) ns = api.namespace( 'results', description="""Retrieve (or send to NDEX) the results of queries """) @ns.route('/ndex') class NDExSubmit(Resource): @ns.doc(model=ndex_response) @ns.expect(ndex_request) def post(self): """Push a query result to NDEX""" log.info("%s" % (str(request.json), )) response = ndex(request.json) code = 200 if response['status'] == 'complete' else 404 return response, code
from flask import request from flask_restplus import Resource from app.api.bigquery.business_interactions import get_request_status, run_bigclam_g2g_query, run_bigclam_g2d_query, ndex from app.api.bigquery.serializers import bigclam_query_request, query_status_response, query_response, ndex_request, ndex_response from app.api.bigquery.parsers import bigclam_query_url_parser from app.api.restplus import api from app.database.models import TestModel from app import settings log = logging.getLogger(__name__) ns = api.namespace( 'bigclam', description= """Associations between genomic aberrations, gene knockdowns and drug response in cell lines.""" ) @ns.route('/g2d/query') class BigclamQuery(Resource): @ns.response(400, "Bad query request.") @ns.response(200, "OK") @ns.doc(model=query_response) @ns.expect(bigclam_query_url_parser, validate=False) def get(self): """Genomic aberrations in INPUT genes lead to sensitivity to OUTPUT drugs.""" log.info("Initiating query") results = run_bigclam_g2d_query(request.values.to_dict()) log.info("Query submission finished")
import logging from flask import request from flask_restplus import Resource from app.api.helpers.business import create_product, update_product, delete_product from app.api.helpers.serializers import products, page_of_products from app.api.restplus import api from app.database.models import Products from app.api.orders.parser import pagination_arguments import simplejson log = logging.getLogger(__name__) ns = api.namespace('products/prod1', description='Operations related to prod1') @ns.route('/') class ProductCollection(Resource): # @api.expect(pagination_arguments) # @api.marshal_with(page_of_orders) @api.marshal_list_with(products) def get(self): """ Returns list of orders. * test with markdown """ # product = Products.query.filter_by(product='prod1').all() return Products.query.all() # args = pagination_arguments.parse_args(request)
from flask_restplus import Resource from app.api.restplus import api from app.api.serializers import message from flask_pymongo import PyMongo ns = api.namespace('Message', description='Message operations') mongo = PyMongo() @ns.route('/') class Message_list(Resource): @ns.doc('list all messages') def get(self): """ Displays all available messages """ documents = [doc for doc in mongo.db.messages.find({}, {'_id': False})] return documents, 200 @ns.doc('create_message') @ns.expect(message) @ns.response(201, '') def post(self): """ Create a new message """ mongo.db.messages.insert({'Message': api.payload}) return "", 201 @ns.doc('delete_message')
from flask_restplus import Resource, reqparse import logging from datetime import datetime from app.api.restplus import api from app.define import status from app.db.database import get_session from app.decorators.auth import jwt_authenticate from app.models.auth import AuthUser from app.encrypt.encrypt import encrypt_jwt, encrypt_sha from app.response import response as resp logger = logging.getLogger(__name__) ns = api.namespace("auth", description="Endpoints for user auth") parser = reqparse.RequestParser() parser.add_argument("username", required=True) parser.add_argument("password", required=True) @ns.route("/login") class Login(Resource): def post(self): try: parsed = parser.parse_args() except: return resp.error("username, password must be specified")
import logging from flask import Response from flask_restplus import Resource, fields from neomodel.core import DoesNotExist from app.api.restplus import api from app.models import OS log = logging.getLogger(__name__) ns = api.namespace('os', description='OS') os = api.model( 'os', { 'id': fields.Integer(readOnly=True, description='The internal id of of an OS.'), 'family': fields.String(required=True, description='The family of the OS.'), 'version': fields.String(required=True, description='The version of the OS.') }) # TODO - Define endpoints that return sessions that started, ended and timedout in a date/time range, used a given ip address @ns.route('/') class SessionsList(Resource): @api.marshal_list_with(os) def get(self): """
import logging from flask import Response from flask_restplus import Resource, fields from neomodel.core import DoesNotExist from app.api.restplus import api from app.models import Tenant log = logging.getLogger(__name__) ns = api.namespace('tenants', description='Tenant') tenant = api.model( 'tenant', { 'id': fields.Integer(readOnly=True, description='The internal id of the tenant.'), 'tenant_id': fields.String(required=True, description='The tenant id.'), }) @ns.route('/') class TenantsList(Resource): @api.marshal_list_with(tenant) def get(self): """ Return a list with all tenants. :return: list_of_tenants """
import logging from flask import request from flask_restplus import Resource from app.api.bigquery.business_interactions import run_bglite_gt2g_query from app.api.bigquery.serializers import bglite_query_request, query_status_response, query_response, ndex_request, ndex_response from app.api.bigquery.parsers import bglite_query_url_parser from app.api.restplus import api from app.database.models import TestModel from app import settings ns = api.namespace('lilgim', description="""Simplified interface to BigGIM""") log = logging.getLogger(__name__) @ns.route('/query') class BGLiteQuery(Resource): @ns.response(400, "Bad query request.") @ns.response(200, "OK") @ns.doc(model=query_response) @ns.expect(bglite_query_url_parser, validate=False) def get(self): """Find tissue-specific correlated genes""" log.info("Initiating query") results = run_bglite_gt2g_query(request.values.to_dict()) log.info("Query submission finished") if results['status'] == 'error': log.debug("Error in query %s" % (results)) return results, 400 else:
from flask_restplus import Resource, marshal from app.api.bigquery.serializers import table_response, column_response, substudy_response, study_response, study_response_test, table_response_short, unique_tissue_list, tissue_substudy from app.api.bigquery.parsers import query_url_parser from app.api.bigquery.business_metadata import * from app.api.restplus import api from app.database.helpers import populate_database from app.database.models import * from app import settings from app.database import db import requests import json log = logging.getLogger(__name__) ns = api.namespace('metadata', description="""Access the metadata for available datasets. """) @ns.route('/table') class MetadataTableResources(Resource): @ns.marshal_with(table_response_short) def get(self): """Retrieve list of available tables""" tables = get_table() return tables, 200 @ns.response(404, "Table not found") @ns.response(200, "OK") @ns.doc(params={'table_name': 'the name of a biqquery table'})
import logging from flask import Response from flask_restplus import Resource, fields from neomodel.core import DoesNotExist from app.api.restplus import api from app.models import ApplicationInstance log = logging.getLogger(__name__) ns = api.namespace('applications_instances', description='Applications Instances') application_instance = api.model( 'applications_instances', { 'id': fields.Integer(readOnly=True, description='The internal id of the application.'), 'application_id': fields.String( required=True, description= 'The id of the appication instance represented by the logical id (LID).' ) }) @ns.route('/') class ApplicationsInstanceList(Resource): @api.marshal_list_with(application_instance)
from flask import request from flask_restplus import Resource from werkzeug.exceptions import BadRequest, NotFound from app.api.events import EventResource from app.api.restplus import api from app.api.serializers import signup, signup_detail from app.api.users import UserAccount from app.extensions import db from app.models.Signup import Signup from app.tasks.email import send_async_email ns = api.namespace('signups', description='Operations related to events') @ns.route('') class SignupsCollection(Resource): @api.marshal_list_with(signup_detail) def get(self): """ Returns all events Returns all registered events for a specific user """ user_email = request.args.get('email') if user_email: user = UserAccount.get_user(user_email) if user: return self.setInfo( Signup.query.filter(Signup.user_id == user.id).all()), 200 else: raise BadRequest("user is not existing.")
from sqlalchemy.orm import load_only import logging from datetime import datetime from app.define import status from app.api.restplus import api from app.decorators.auth import jwt_authenticate from app.models.auth import AuthUser from app.db.database import get_session from app.encrypt.encrypt import encrypt_sha from app.response import response as resp from app.utils.validate import check_username, check_password, check_email logger = logging.getLogger(__name__) ns = api.namespace("users", description="Endpoints for user") parser_create = reqparse.RequestParser() parser_create.add_argument("username", type=str, required=True) parser_create.add_argument("password", type=str, required=True) parser_create.add_argument("first_name", type=str, required=True) parser_create.add_argument("last_name", type=str, required=True) parser_create.add_argument("email", type=str, required=True) parser_update = reqparse.RequestParser() parser_update.add_argument("password", type=str, required=True) parser_update.add_argument("new_password", type=str) parser_update.add_argument("first_name", type=str) parser_update.add_argument("last_name", type=str) parser_update.add_argument("email", type=str)
import os import logging import h5py import numpy as np from flask import jsonify, current_app as app from flask_restplus import Resource, reqparse from app.api.restplus import api from app.utils import response as resp ns = api.namespace("timeseries", description="Endpoint for time seies data") parser = reqparse.RequestParser() parser.add_argument("model_name", type=str, required=True) parser.add_argument("start_date", type=int, required=True) parser.add_argument("end_date", type=int, required=True) @ns.route("/portfolio-performance/<item>") class PortfolioPerformance(Resource): __available_item_list = ["return", "tvr", "cum_return"] def post(self, item): try: parsed = parser.parse_args() except: return resp.error("model_name, start_date, end_date must be specified") print parsed
import logging from flask import Response from flask_restplus import Resource, fields from neomodel.core import DoesNotExist from app.api.restplus import api from app.models import Application log = logging.getLogger(__name__) ns = api.namespace('applications', description='Application') application = api.model( 'application', { 'id': fields.Integer(readOnly=True, description='The internal id of the application.'), 'name': fields.String( required=True, description= 'The name of the appication represented by the logical id (LID) prefix.' ) }) @ns.route('/') class ApplicationsList(Resource): @api.marshal_list_with(application) @api.doc(model=application)
import logging from flask import Response from flask_restplus import Resource, fields from neomodel.core import DoesNotExist from app.api.restplus import api from app.models import Environment log = logging.getLogger(__name__) ns = api.namespace('environments', description='Environment') environment = api.model( 'environment', { 'id': fields.Integer(readOnly=True, description='The internal id of the application.'), 'server': fields.String( required=True, description='The server where the environment is deployed.'), 'type': fields.String( required=True, description= 'The type of the environment (e.g.: OP, ST, MT, or DEMO).') }) @ns.route('/')
""" Contains endpoints for API """ import time import datetime import requests from flask import request from flask_restplus import Resource, fields from werkzeug.exceptions import BadRequest from app.api.restplus import api from app.api.io_logic import get_sites_from_io, update_sites_in_io ns_sites = api.namespace('sites', description='Operations with sites') ns_monitoring = api.namespace('monitoring', description='Monitoring operations') site = api.model('Site', {'url': fields.String(required=True, description='URL')}) site_update = api.model( 'Site to update', { 'url': fields.String(required=True, description='URL'), 'new_url': fields.String(required=True, description='URL'), }) site_status = api.model( 'Site to monitor', { 'url': fields.String(required=True, description='URL'), 'last_status': fields.String(description='Last known status'), 'last_checked': fields.DateTime(description='Last update'), })
import logging from flask import request from flask_restplus import Resource from app.api.bigquery.business_interactions import get_request_status, run_query, ndex from app.api.bigquery.serializers import query_request, query_status_response, query_response, ndex_request, ndex_response from app.api.bigquery.parsers import query_url_parser from app.api.restplus import api from app.database.models import TestModel from app import settings log = logging.getLogger(__name__) ns = api.namespace('biggim', description="""Comprehensive querying of gene to gene interactions under different tissue types.""") @ns.route('/query') class InteractionsQuery(Resource): @ns.response(400, "Bad query request.") @ns.response(200, "OK") @ns.doc(model=query_response) @ns.expect(query_url_parser, validate=False) def get(self): """Submit a new query request.""" log.info("Initiating query") results = run_query(request.values.to_dict()) log.info("Query submission finished") if results['status'] == 'error': log.debug("Error in query %s" % (results)) return results, 400