from flask import request
from flask.globals import current_app
from flask_restx import Namespace, Resource, marshal
from sqlalchemy import desc
import app.models as models
from _orchest.internals import config as _config
from _orchest.internals.two_phase_executor import TwoPhaseExecutor, TwoPhaseFunction
from app import schema
from app.apis.namespace_runs import AbortPipelineRun
from app.connections import db, docker_client
from app.core.sessions import InteractiveSession
from app.errors import JupyterBuildInProgressException
from app.utils import register_schema
api = Namespace("sessions", description="Manage interactive sessions")
api = register_schema(api)
@api.route("/")
class SessionList(Resource):
@api.doc("fetch_sessions")
@api.marshal_with(schema.sessions)
def get(self):
"""Fetches all sessions."""
query = models.InteractiveSession.query
# TODO: why is this used instead of the Session.get() ?
# Ability to query a specific session given its `pipeline_uuid`
# through the URL (using `request.args`).
if "pipeline_uuid" in request.args and "project_uuid" in request.args:
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an 'AS IS' BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Endpoints to check manage notifications."""
from flask import request, jsonify
from flask_restx import Namespace
from flask_restx import Resource
from api.auth.auth import jwt
from api.services.sms import get_sms_service
api = Namespace('notifications', description='API for Sending Service BC Notifications')
@api.route('/sms')
class SmsNotification(Resource):
"""Notification resource."""
@jwt.requires_auth
def post(self):
"""Send notification."""
sms_payload = request.get_json(force=True)
get_sms_service().send(sms_payload)
return jsonify({})
add_catalog,
get_catalog_by_id,
update_catalog,
delete_catalog,
get_all_catalog_items,
get_all_catalog_items_by_catalog_id,
get_catalog_item_by_id,
add_catalog_item,
update_catalog_item,
delete_catalog_item,
get_all_sources,
find_items_by_source
)
catalogs_namespace = Namespace("catalogs")
catalog = catalogs_namespace.model(
"Catalog",
{
"id": fields.Integer(readOnly=True),
"name": fields.String(required=True),
"supplier": fields.String(required=True),
"created_date": fields.DateTime,
"sponsor_name": fields.String(required=True),
},
)
class CatalogsList(Resource):
@catalogs_namespace.marshal_with(catalog, as_list=True)
from six.moves.urllib.parse import urlparse
from flask import url_for, request, render_template, make_response
from flask_restx import Namespace
from rdflib.plugin import register
from rdflib.serializer import Serializer
from app.api.adapter.services.providers import ConfigurationManagementSingleton
from pyoslc.rest.resource import OslcResource
config_ns = Namespace(name='config',
description='Configuration Management',
path='/config')
register('config-xml', Serializer, 'pyoslc.serializers.configxml',
'ConfigurationSerializer')
@config_ns.route('')
class ConfigurationCatalog(OslcResource):
def get(self):
super(ConfigurationCatalog, self).get()
endpoint_url = url_for('{}.{}'.format(request.blueprint,
self.endpoint))
base_url = '{}{}'.format(request.url_root.rstrip('/'), endpoint_url)
catalog_url = urlparse(base_url).geturl()
catalog = ConfigurationManagementSingleton.get_catalog(catalog_url)
catalog.to_rdf(self.graph)
from flask import request
from flask_restx import Resource, Namespace
from .core import get_resource_lamdshtrans
from ....iomodels import input_def_lamdshtrans, output_def
ns_lamdsh = Namespace(
'others', description='Fetch/Compute other useful infos for lam-dashboard')
input_def = ns_lamdsh.model(*input_def_lamdshtrans)
output_def = ns_lamdsh.model(*output_def)
@ns_lamdsh.route("/lamdsh/gettrans", doc=False)
class GettransLamdsh(Resource):
'''This is a test'''
@ns_lamdsh.expect(input_def, validate=True)
@ns_lamdsh.marshal_with(output_def)
def post(self):
'''Get transcriptions(Original + EngTrans) from DB for lam-dashboard'''
return {'output': get_resource_lamdshtrans(request.json)}
@ns_lamdsh.errorhandler
def default_error_handler(error):
'''Default error handler'''
return {'message': str(error)}, getattr(error, 'code', 500)
from flask_jwt import current_identity, jwt_required
from flask_restx import Namespace, Resource, fields
from werkzeug.exceptions import Forbidden, NotFound
from jarr.api.common import (parse_meaningful_params, set_clustering_options,
set_model_n_parser)
from jarr.controllers import CategoryController
category_ns = Namespace('category',
path='/categor',
description='Category related operation')
parser = category_ns.parser()
model = category_ns.model("Category", {'id': fields.Integer(readOnly=True)})
set_clustering_options("category", model, parser)
parser_edit = parser.copy()
parser.add_argument('name',
type=str,
required=True,
nullable=False,
store_missing=False)
set_model_n_parser(model, parser_edit, 'name', str, nullable=False)
@category_ns.route('y')
class NewCategoryResource(Resource):
@staticmethod
@category_ns.expect(parser, validate=True)
@category_ns.response(201, 'Created')
@category_ns.response(400, 'Validation error')
@category_ns.response(401, 'Authorization needed')
@category_ns.marshal_with(model, code=201, description='Created')
from __future__ import division
from __future__ import absolute_import
from builtins import int
from builtins import str
from future import standard_library
standard_library.install_aliases()
import json
from flask import request
from flask_restx import Namespace, Resource, fields
from mozart import app, mozart_es
JOB_SPEC_NS = "job_spec"
job_spec_ns = Namespace(JOB_SPEC_NS,
description="Mozart job-specification operations")
CONTAINER_NS = "container"
container_ns = Namespace(CONTAINER_NS,
description="Mozart container operations")
HYSDS_IO_NS = "hysds_io"
hysds_io_ns = Namespace(HYSDS_IO_NS, description="HySDS IO operations")
HYSDS_IOS_INDEX = app.config['HYSDS_IOS_INDEX']
JOB_SPECS_INDEX = app.config['JOB_SPECS_INDEX']
JOB_STATUS_INDEX = app.config['JOB_STATUS_INDEX']
CONTAINERS_INDEX = app.config['CONTAINERS_INDEX']
@job_spec_ns.route('/list', endpoint='job_spec-list')
filter_parser,
get_arg,
measure_model,
preferences_model,
profile_model,
route_entity_model,
segment_entity_model,
segments_parser,
series_entity_model,
service_entity_model,
sync_model,
WrapEntity,
)
api = Namespace('bikebuds', 'Bikebuds API')
logging.info('Loading Bikebuds API')
@api.route('/activities')
class ActivitiesResource(Resource):
@api.doc('get_activities')
@api.marshal_with(activity_entity_model, skip_none=True, as_list=True)
def get(self):
user = auth_util.get_user(flask.request)
service = Service.get('strava', parent=user.key)
activities_query = ds_util.client.query(
kind='Activity', ancestor=service.key, order=['-start_date']
)
one_year_ago = datetime.datetime.now(
datetime.timezone.utc
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
# ==============================================================================
from pathlib import Path
from celery import shared_task
from flask import jsonify
from flask import make_response
from flask import request
from flask_restx import Namespace
from flask_restx import Resource
from elephant.config import DATASETS_DIR
from elephant.logging import logger
from elephant.tool import dataset as dstool
api = Namespace('dataset', description='Dataset APIs')
@shared_task()
def generate_dataset_task(input, output, is_uint16=False, divisor=1.,
is_2d=False):
dstool.generate_dataset(input,
output,
is_uint16,
divisor,
is_2d,
True)
@api.route('/check')
class Check(Resource):
#
import json
from flask import jsonify, make_response, request, current_app
from flask_restx import Namespace, Resource
from flask_jwt_extended import jwt_required, get_jwt_identity
from mash.mash_exceptions import MashException
from mash.services.api.v1.schema import (default_response, validation_error)
from mash.services.api.v1.routes.jobs import job_response
from mash.services.api.v1.schema.jobs.azure import azure_job_message
from mash.services.api.v1.utils.jobs import create_job
from mash.services.api.v1.utils.jobs.azure import validate_azure_job
api = Namespace('Azure Jobs', description='Azure Job operations')
validation_error_response = api.schema_model('validation_error',
validation_error)
azure_job = api.schema_model('azure_job', azure_job_message)
@api.route('/')
class AzureJobCreate(Resource):
@api.doc('add_azure_job', security='apiKey')
@jwt_required
@api.expect(azure_job)
@api.response(201, 'Job added', job_response)
@api.response(400, 'Validation error', validation_error_response)
@api.response(401, 'Unauthorized', default_response)
@api.response(422, 'Not processable', default_response)
def post(self):
"""
WHAT: A class which represents a view for all predicate related operations
WHY: Need to define input/output paths whether running in Docker or running directly on a Windows/Mac/Linux OS, paths would be different
ASSUMES: No user input
FUTURE IMPROVEMENTS: N/A
WHO: SL 2020-12-14
"""
from flask_restx import Resource, Namespace
from apis.v1_0.models.clsPredicates import clsPredicates
namespace = Namespace("predicates", description="Predicates Endpoints")
@namespace.route("/")
class clsPredicatesView(Resource):
"""
See header
"""
def get(self):
"""
HTTP GET request
* Returns biological predicates supported by this api
:return: Predicate view model
"""
return clsPredicates.return_accepted(), 200
from flask import request
from flask_accepts import accepts, responds
from flask_restx import Namespace, Resource
from flask.wrappers import Response
from typing import List
from .schema import FizzbazSchema
from .service import FizzbazService
from .model import Fizzbaz
from .interface import FizzbazInterface
api = Namespace("Fizzbaz",
description="A modular namespace within fizz") # noqa
@api.route("/")
class FizzbazResource(Resource):
"""Fizzbaz"""
@responds(schema=FizzbazSchema, many=True)
def get(self) -> List[Fizzbaz]:
"""Get all Fizzbaz"""
return FizzbazService.get_all()
@accepts(schema=FizzbazSchema, api=api)
@responds(schema=FizzbazSchema)
def post(self) -> Fizzbaz:
"""Create a Single Fizzbaz"""
return FizzbazService.create(request.parsed_obj)
class FeedDto:
ns = Namespace('feed', description='Feed Related operations')
from flask import Response, request
from database.models import API_Content, User
from flask_jwt_extended import jwt_required, get_jwt_identity
from flask_restx import Resource, Namespace, fields
from mongoengine.errors import FieldDoesNotExist, NotUniqueError, DoesNotExist, ValidationError, InvalidQueryError
from resources.errors import SchemaValidationError, MovieAlreadyExistsError, InternalServerError, \
UpdatingMovieError, DeletingMovieError, MovieNotExistsError
API_Content_NS = Namespace(
name="API_Content",
description="API_Content 리스트를 작성하기 위해 사용하는 API.",
)
api_content_fields = API_Content_NS.model(
'API_Content',
{ # Model 객체 생성
'api_name':
fields.String(
description='a API_Content', required=True, example="공공데이타날씨정보"),
'api_desc':
fields.String(description='The API_Content api_desc'),
'api_key':
fields.String(description='The API_Content api_key'),
'api_endpoint':
fields.String(description='The API_Content api_endpoint'),
'api_data_format':
fields.String(description='The API_Content api_data_format')
})
api_content_fields_with_id = API_Content_NS.inherit(
'API_Content With ID', api_content_fields,
import pickle
import pandas as pd
import logging
import json
from flask_restx import Namespace, Resource, fields
from flask import request
from apis.config import MODEL_ROOT
logger = logging.getLogger("werkzeug")
api = Namespace('inference', description='Namespace for inference')
personModel = api.model(
'PersonDiabetes', {
'Pregnancies': fields.String(required=True, example='2'),
'Glucose': fields.String(required=True, example='109'),
'BloodPressure': fields.String(required=True, example='92'),
'SkinThickness': fields.String(required=True, example='1'),
'Insulin': fields.String(required=True, example='1'),
'BMI': fields.String(required=True, example='42.7'),
'DiabetesPedigreeFunction': fields.String(required=True,
example='0.85'),
'Age': fields.String(required=True, example='54')
})
@api.route('/UCIDiabetes')
@api.doc(personModel)
@api.expect(personModel)
class Inference(Resource):
def post(self):
from typing import List
from flask import request
from flask.wrappers import Response
from flask_accepts import accepts, responds
from flask_restx import Namespace, Resource
from marshmallow import schema
from .interface import EfficiencyIndicatorsInterface
from .model import EfficiencyIndicators
from .schema import EfficiencyIndicatorsSchema
from .service import EfficiencyIndicatorsService
api = Namespace('EfficiencyIndicators',
description='Companies Efficiency Indicators')
@api.route('/')
class EfficiencyIndicatorsResource(Resource):
@responds(schema=EfficiencyIndicatorsSchema(many=True))
def get(self) -> List[EfficiencyIndicators]:
'''Get all companies debt indicators'''
return EfficiencyIndicatorsService.get_all()
@accepts(schema=EfficiencyIndicatorsSchema, api=api)
@responds(schema=EfficiencyIndicatorsSchema)
def post(self) -> EfficiencyIndicators:
'''Create a single company indicator'''
return EfficiencyIndicatorsService.create(request.parsed_obj)
docker_config = DockerConfig.query.filter_by(id=1).first()
docker_tracker = DockerChallengeTracker.query.all()
for i in docker_tracker:
if is_teams_mode():
name = Teams.query.filter_by(id=i.team_id).first()
i.team_id = name.name
else:
name = Users.query.filter_by(id=i.user_id).first()
i.user_id = name.name
return render_template("admin_docker_status.html",
dockers=docker_tracker)
app.register_blueprint(admin_docker_status)
kill_container = Namespace("nuke", description='Endpoint to nuke containers')
@kill_container.route("", methods=['POST', 'GET'])
class KillContainerAPI(Resource):
@admins_only
def get(self):
container = request.args.get('container')
full = request.args.get('all')
docker_config = DockerConfig.query.filter_by(id=1).first()
docker_tracker = DockerChallengeTracker.query.all()
if full == "true":
for c in docker_tracker:
delete_container(docker_config, c.instance_id)
DockerChallengeTracker.query.filter_by(
instance_id=c.instance_id).delete()
from datetime import datetime
from typing import Optional
from celery.contrib.abortable import AbortableAsyncResult
from flask import abort, current_app, request
from flask_restx import Namespace, Resource
from sqlalchemy import desc, func, or_
import app.models as models
from _orchest.internals.two_phase_executor import TwoPhaseExecutor, TwoPhaseFunction
from app import schema
from app.celery_app import make_celery
from app.connections import db
from app.utils import register_schema, update_status_db
api = Namespace("environment-builds",
description="Managing environment builds")
api = register_schema(api)
@api.route("/")
class EnvironmentBuildList(Resource):
@api.doc("get_environment_builds")
@api.marshal_with(schema.environment_builds)
def get(self):
"""Fetches all environment builds (past and present).
The environment builds are either PENDING, STARTED, SUCCESS,
FAILURE, ABORTED.
"""
environment_builds = models.EnvironmentBuild.query.all()
from flask_restx import fields
from flask_restx import Namespace
from flask_restx import reqparse
from flask_restx import Resource
from freshermeat.bootstrap import db
from freshermeat.models import Feed
from freshermeat.web.views.api.v2.common import auth_func
feed_ns = Namespace("feed", description="Feed related operations.")
# Argument Parsing
parser = reqparse.RequestParser()
parser.add_argument("feed_id", type=str, help="The id of the feed.")
parser.add_argument("page", type=int, default=1, location="args")
parser.add_argument("per_page", type=int, location="args")
# Response marshalling
feed = feed_ns.model(
"Feed",
{
"feed_id": fields.String(
description="The id of the feed.",
),
"link": fields.String(description="The link of the feed."),
"created_date": fields.DateTime(description="Created date."),
},
)
import hashlib
from flask_jwt_simple import (
create_jwt,
jwt_required,
get_jwt,
)
from flask_restx import Resource, Namespace, reqparse
from utils import Config, logger
ns_admin_login = Namespace("admin/login", description="로그인")
parser = ns_admin_login.parser()
parser.add_argument(
"Authorization",
type=str,
location="headers",
help="Bearer jwt token",
required=True,
)
@ns_admin_login.route("/")
class Login(Resource):
@ns_admin_login.doc("로그인하기", params={"username": "******", "password": "******"})
def post(self):
parser = reqparse.RequestParser()
parser.add_argument("username", type=str, help="username")
parser.add_argument("password", type=str, help="password")
args = parser.parse_args(strict=True)
from flask_restx import Namespace, Resource, fields
import http.client
from app.backend import services
import logging
logging.basicConfig(level=logging.DEBUG)
stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.DEBUG)
stream_handler.setFormatter(logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'))
oauth1_ns = Namespace('api', description='Twitter management')
oauth1_ns.logger.addHandler(stream_handler)
user_response = oauth1_ns.model('user_response', {
'id_str':fields.String(description='id_str'),
'screen_name':fields.String(description='screen_name'),
'location':fields.String(description='location'),
'friends_count':fields.Integer(description='friends_count'),
'followers_count': fields.Integer(description='followers_count')
})
user_responses = oauth1_ns.model('user_responses', {
'users':fields.List(fields.Nested(user_response))
})
import http.client
from datetime import datetime
from flask_restx import Namespace, Resource, fields
from thoughts_backend import config
from thoughts_backend.models import ThoughtModel
from thoughts_backend.token_validation import validate_token_header
from thoughts_backend.db import db
from flask import abort
api_namespace = Namespace('api', description='API operations')
def authentication_header_parser(value):
username = validate_token_header(value, config.PUBLIC_KEY)
if username is None:
abort(401)
return username
# Input and output formats for Thought
authentication_parser = api_namespace.parser()
authentication_parser.add_argument('Authorization',
location='headers',
type=str,
help='Bearer Access Token')
thought_parser = authentication_parser.copy()
thought_parser.add_argument('text',
type=str,
required=True,
from flask_restx import fields
from flask_restx import Namespace
users_namespace = Namespace("users")
user_readable = users_namespace.model(
"Existing-User",
{
"id": fields.Integer(readOnly=True),
"username": fields.String(required=True),
"email": fields.String(required=True),
},
)
user_writable = users_namespace.inherit(
"New-User", user_readable, {"password": fields.String(required=True)},
)
import dateutil.parser
import xmltodict
from botocore.exceptions import ClientError
from flask import request
from flask_restx import Namespace, Resource, fields
from flask_restx import reqparse
from core.data import ReturnDocument
from db import User, RepositoryException, Expense
from db.factory import create_repository
from settings import REPOSITORY_NAME, REPOSITORY_SETTINGS
# Database
repository = create_repository(REPOSITORY_NAME, REPOSITORY_SETTINGS)
api = Namespace('user', description='For managing users and friends')
query_user_fields = api.model(
'QueryUser',
{
'email': fields.String,
},
)
add_user_fields = api.model(
'AddUser',
{
'email': fields.String,
'name': fields.String
},
)
from src.queries.get_associated_user_wallet import get_associated_user_wallet
from src.queries.get_associated_user_id import get_associated_user_id
from src.queries.get_users_cnode import get_users_cnode, ReplicaType
from src.api.v1.helpers import abort_not_found, decode_with_abort, extend_activity, extend_favorite, extend_track, \
extend_user, format_limit, format_offset, get_current_user_id, make_full_response, make_response, search_parser, success_response, abort_bad_request_param, \
get_default_max, encode_int_id
from .models.tracks import track, track_full
from .models.activities import activity_model, activity_model_full
from src.utils.redis_cache import cache
from src.utils.redis_metrics import record_metrics
from src.queries.get_top_genre_users import get_top_genre_users
logger = logging.getLogger(__name__)
ns = Namespace('users', description='User related operations')
full_ns = Namespace('users', description='Full user operations')
user_response = make_response("user_response", ns, fields.Nested(user_model))
full_user_response = make_full_response(
"full_user_response", full_ns, fields.List(fields.Nested(user_model_full)))
def get_single_user(user_id, current_user_id):
args = {"id": [user_id], "current_user_id": current_user_id}
users = get_users(args)
if not users:
abort_not_found(user_id, ns)
user = extend_user(users[0])
return success_response(user)
from flask_restx import Namespace, Resource, fields, reqparse
from flask import make_response, send_file
import json
api = Namespace('payment_network',
description='Payment Network Graphic End Points')
validNetworkNames = [
"swift", "alipay", "currencyFair", "hifx", "moneyGram", "ofx", "paypal",
"transFast", "transferWise", "westernUnion", "worldRemit", 'xe'
]
api_params = api.parser()
# Look only in the querystring
api_params.add_argument('format',
required=False,
location='args',
help='lower case svg or png')
##### Simple Network to Graphic API
@api.route('/name/<networkname>')
class countryFlag(Resource):
@api.expect(api_params)
def get(self, networkname):
args = api_params.parse_args()
fileType = args['format']
if fileType is None or fileType not in ['png', 'svg']:
fileType = 'png'
networkName = networkname
if networkName not in validNetworkNames:
"""Metrics namespace module."""
from flask_restx import Namespace, Resource, fields, inputs, reqparse
from users_microservice import __version__
from users_microservice.controllers.metrics import all_metrics as all_metrics
api = Namespace(
"Metrics",
description="Metrics operations",
)
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"),
},
)
from flask import request
from flask_accepts import responds, accepts
from flask_login import current_user
from flask_restx import Namespace, Resource
from app.schemes.user_schema import GetUserSchema, PutUserSchema
from repositories import user_repository
from tools.auth_utils import login_required_user_api
ns = Namespace('user', description='User')
@ns.route('')
class UserItemResource(Resource):
@login_required_user_api
@responds(schema=GetUserSchema, status_code=200, api=ns)
def get(self):
user = user_repository.get_user_by_id(current_user.id)
return user
@login_required_user_api
@accepts(schema=PutUserSchema, api=ns)
@responds(status_code=204, api=ns)
def put(self):
schema = PutUserSchema()
result = schema.load(request.json)
user_repository.update_user(current_user.id, result)
@login_required_user_api
@responds(status_code=204, api=ns)
from flask_restx import Namespace
from .difficulty.config import namespaces as ns_difficulty
ns_hardness = Namespace('hardness',
description='hardness tools')
namespaces = [ns_hardness, *ns_difficulty]
from flask import request
from flask_restx import Namespace, Resource
from models.quote_repository import get_all_quotes, save_quote
ns = Namespace(
"quotes",
description=
"A space to store and retrieve quotes by users... Very useful indeed...")
def fix_quote(quote):
quote["_id"] = str(quote["_id"])
quote["created_at"] = str(quote["created_at"])
return quote
quote_parser = ns.parser()
quote_parser.add_argument("user", type=str, location="json", required=True)
quote_parser.add_argument("quote", type=str, location="json", required=True)
@ns.route("/")
class QuotesList(Resource):
def get(self):
all_quotes = get_all_quotes()
all_quotes = [fix_quote(quote) for quote in all_quotes]
return all_quotes
@ns.expect(quote_parser)
def post(self):
new_quote = quote_parser.parse_args()
