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()