def default_list_parser(namespace: Namespace) -> RequestParser: parser = namespace.parser() parser.add_argument("limit", type=int, required=False, help="number of items to include in response", location="args") parser.add_argument( "offset", type=int, required=False, help="number of items to offset from the start of response", location="args") return parser
#schema_source_model_schema = SCHEMAS_NS.schema_model('SchemaSource', { #}) VALIDATE_NS = Namespace('validate','Validation results namespace') wcv = fields.Wildcard(fields.Raw) validation_input_model = VALIDATE_NS.model('ValidationInput', { '*': wcv }) validation_model = VALIDATE_NS.model('Validation', { 'file': fields.String(required=True, description = 'The filename of the JSON which was validated, if it was available'), 'validated': fields.Boolean(required=True, description = "Validation result"), 'schema_id': fields.String(required=False, description = 'The id of the schema used to validate'), 'schema_hash': fields.String(required=False, description = 'The SHA1 hash of the normalized JSON Schema used to validate, in hexadecimal representation'), 'errors': fields.List(fields.Nested(schema_error_model),required=False, description = 'The list of detected errors when the JSON is processed'), }) #file_upload = reqparse.RequestParser() file_upload = VALIDATE_NS.parser() file_upload.add_argument('file', location='files', type=werkzeug.datastructures.FileStorage, # This line can be uncommented to support multiple uploads when # Swagger-UI fixes this case #action='append', required=True, help='JSON to be validated' )
login = namespace.model( "User", { "email": fields.String(required=True), "password": fields.String(required=True) }, ) refresh = namespace.model("Refresh", {"refresh_token": fields.String(required=True)}) tokens = namespace.clone("Access and Refresh Tokens", refresh, {"access_token": fields.String(required=True)}) status_parser = namespace.parser() status_parser.add_argument("Authorization", location="headers") class Register(Resource): @namespace.marshal_with(user_result) @namespace.expect(user_payload, validate=True) @namespace.response(201, "Success") @namespace.response(400, "User with given email already exists") def post(self): """Register and returns new user.""" payload = request.get_json() username = payload.get("username") email = payload.get("email") password = payload.get("password")
from jarr.api.common import get_ui_url from jarr.bootstrap import conf from jarr.controllers import UserController from jarr.lib import emails from jarr.lib.utils import utc_now from jarr.metrics import SERVER auth_ns = Namespace("auth", description="Auth related operations") model = auth_ns.model( "Login", { "access_token": fields.String(description="The token that must be place " "in the Authorization header"), }) login_parser = auth_ns.parser() login_parser.add_argument("login", type=str, store_missing=False) login_parser.add_argument("password", type=str, store_missing=False) login_init_recovery_parser = auth_ns.parser() login_init_recovery_parser.add_argument("login", type=str, required=True, store_missing=False) login_init_recovery_parser.add_argument("email", type=str, required=True, store_missing=False) login_recovery_parser = login_init_recovery_parser.copy() login_recovery_parser.add_argument("token", type=str, required=True,
from werkzeug.exceptions import UnprocessableEntity import opml from jarr.controllers import CategoryController, FeedController, UserController from jarr.lib.utils import utc_now opml_ns = Namespace('opml', description="Allows to export and import OPML files") model = opml_ns.model( 'OPML result', { 'created': fields.Integer(), 'failed': fields.Integer(), 'existing': fields.Integer(), 'exceptions': fields.List(fields.String()) }) parser = opml_ns.parser() parser.add_argument('opml_file', type=FileStorage, required=True) OK_GET_HEADERS = { 'Content-Type': 'application/xml', 'Content-Disposition': 'attachment; filename=feeds.opml' } @opml_ns.route('') class OPMLResource(Resource): @staticmethod @opml_ns.response(200, 'OK', headers=OK_GET_HEADERS) @jwt_required() def get(): user_id = current_identity.id
image_serializer = api.model( "Kind", { "id": fields.String(required=True), "name": fields.String(required=True), "image_1": fields.String(required=True, description="File Name 1"), "image_2": fields.String(required=True, description="File Name 2"), "image_3": fields.String(required=True, description="File Name 3"), "image_4": fields.String(required=True, description="File Name 4"), "image_5": fields.String(required=True, description="File Name 5"), "image_6": fields.String(required=True, description="File Name 6"), }, ) parser = api.parser() parser.add_argument("range", location="args", help="Pagination: default=[0,19]") parser.add_argument("sort", location="args", help='Sort: default=["name","ASC"]') parser.add_argument("filter", location="args", help="Filter default=[]") file_upload = reqparse.RequestParser() file_upload.add_argument("image_1", type=FileStorage, location="files", help="image_1") file_upload.add_argument("image_2", type=FileStorage,
from flask_restx import Namespace, Resource, reqparse, cors from database import History, db api = Namespace('calculator', description='Computes mathematical expressions', decorators=[cors.crossdomain(origin="*")]) calc_parser = api.parser() calc_parser.add_argument('expression', type=str, required=True, help="The mathematical expression to compute") @api.route('/calc') @api.expect(calc_parser) class Calculator(Resource): def post(self): args = calc_parser.parse_args() expression = args['expression'] try: computation = eval(expression) hist = History(expression=expression, result=computation) db.session.add(hist) db.session.commit() return {"result": computation} except:
from users_backend.models import UserModel from users_backend.db import db admin_namespace = Namespace('admin', description='Admin operations') model = { 'id': fields.Integer(), 'username': fields.String(), # DO NOT RETURN THE PASSWORD!!! 'creation': fields.DateTime(), } user_model = admin_namespace.model('User', model) user_parser = admin_namespace.parser() user_parser.add_argument('username', type=str, required=True, help='Username') user_parser.add_argument('password', type=str, required=True, help='Password') @admin_namespace.route('/users/') class UserCreate(Resource): @admin_namespace.expect(user_parser) @admin_namespace.marshal_with(user_model, code=http.client.CREATED) def post(self): ''' Create a new user '''
import base64 from flask import Response from flask_jwt import current_identity, jwt_required from flask_restx import Namespace, Resource, fields from jarr.api.common import (EnumField, parse_meaningful_params, set_clustering_options, set_model_n_parser) from jarr.controllers import (FeedBuilderController, FeedController, IconController) from jarr.lib.enums import FeedStatus, FeedType from jarr.lib.filter import FiltersAction, FiltersTrigger, FiltersType feed_ns = Namespace('feed', description='Feed related operations') url_parser = feed_ns.parser() url_parser.add_argument('url', type=str, required=True, nullable=False, store_missing=False) filter_model = feed_ns.model( 'Filter', { 'action': EnumField(FiltersAction), 'pattern': fields.String(), 'action on': EnumField(FiltersTrigger), 'type': EnumField(FiltersType), }) parser = feed_ns.parser() feed_build_model = feed_ns.model( 'FeedBuilder', { 'link':
from users_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 Users authentication_parser = api_namespace.parser() authentication_parser.add_argument('Authorization', location='headers', type=str, help='Bearer Access Token') login_parser = api_namespace.parser() login_parser.add_argument('username', type=str, required=True, help='username') login_parser.add_argument('password', type=str, required=True, help='password') @api_namespace.route('/login/') class UserLogin(Resource): @api_namespace.doc('login')
"images_amount": fields.Integer("Number of images"), "image_1": fields.String(required=True, description="File Name 1"), "image_2": fields.String(required=True, description="File Name 2"), "image_3": fields.String(required=True, description="File Name 3"), "image_4": fields.String(required=True, description="File Name 4"), "image_5": fields.String(required=True, description="File Name 5"), "image_6": fields.String(required=True, description="File Name 6"), "complete": fields.Boolean(description="Complete?"), "created_at": fields.DateTime(description="Creation date"), "modified_at": fields.DateTime(description="Last modification date"), "approved_at": fields.DateTime(description="Ready for sale date"), "prices": fields.Nested(price_fields), } parser = api.parser() parser.add_argument("range", location="args", help="Pagination: default=[0,19]") parser.add_argument("sort", location="args", help='Sort: default=["name","ASC"]') parser.add_argument("filter", location="args", help="Filter default=[]") @api.route("/") @api.doc("Show all kinds.") class KindResourceList(Resource): @marshal_with(kind_serializer_with_relations) @api.doc(parser=parser) def get(self): """List (Product)Kinds""" args = parser.parse_args() range = get_range_from_args(args) sort = get_sort_from_args(args)
from flask_restx import fields from flask_restx import Namespace sentiment_namespace = Namespace("sentiment") parser = sentiment_namespace.parser() parser.add_argument("Authorization", location="headers") sentiment_schema = sentiment_namespace.model( "Sentiment", { "id": fields.Integer(readOnly=True), "user_id": fields.Integer(required=True), "keyword": fields.String(required=True), }, ) update_sentiment_schema = sentiment_namespace.model( "Update Sentiment", { "id": fields.Integer(readOnly=True), "keyword": fields.String(required=True), }, )
#from flask_app.app.services.imageService import create_image from flask_app.app.services.logs import complex_file_handler from flask_app.app.database.schemas import PostSchema from flask_app.app.services.imageService import get_picture myNS = Namespace('my', 'Interacciones de usuarios entre sí. Follow y Chat.') myNS.logger.addHandler(complex_file_handler) print(myNS.logger.handlers) myNS.models[simpleUser.name] = simpleUser myNS.models[followModel.name] = followModel myNS.models[profilePicture.name] = profilePicture myNS.models[picture.name] = picture parser = myNS.parser() parser.add_argument('Authorization', location='headers', required=True) @myNS.route('/foll') class Follow(Resource): @myNS.expect(followModel, parser) @jwt_required() def patch(self): username_follower = get_jwt_identity() body = request.get_json() user_follower = get_user_by_id(username_follower) user_followed = get_user_by_username(body['user']['username']) foll = user_follows_to(user_follower, user_followed) print(foll) print(user_followed)
mod_list_values = api.model('ListValues', {'values': fields.List(fields.String)}) mod_list_match = api.model('ListMatch', { 'name': fields.String, 'value': fields.String, 'matched': fields.Boolean }) mod_list_values_paged = api.model( 'ListValuesPaged', { 'values': fields.Nested(mod_threat_value), 'pagination': fields.Nested(mod_pagination) }) list_parser = api.parser() list_parser.add_argument('data_type', location='args', required=False) list_parser.add_argument('organization', location='args', required=False) list_parser.add_argument('page', type=int, location='args', default=1, required=False) list_parser.add_argument('page_size', type=int, location='args', default=10, required=False) @api.route("")
from flask_restx import Namespace, Resource, fields from pleromanet.poker import repository, service api = Namespace('poker', description='') game_parser = api.parser() game_parser.add_argument('name', type=str, required=True, location='json') game_parser.add_argument('big_blind', type=int, required=True, location='json') game_parser.add_argument('small_blind', type=int, required=True, location='json') game_parser.add_argument('num_seats', type=int, required=True, location='json') @api.route('/games/') class GameList(Resource): def get(self): return service.get_games(), 200 @api.doc(parser=game_parser) def post(self): game_dict = game_parser.parse_args() return service.create_game(game_dict), 201 @api.route('/games/id=<string:game_id>') class Game(Resource): def get(self, game_id): return service.get_one_game(game_id), 200
from users_microservice.constants import DEFAULT_RESET_PWD_EMAIL, DEFAULT_RESET_PWD_LEN from users_microservice.exceptions import ( BlockedUser, EmailAlreadyRegistered, PasswordDoesNotMatch, UserDoesNotExist, ) from users_microservice.models import BlacklistToken, User, db from users_microservice.utils import FilterParam, generate_random_password api = Namespace( "Users", description="Users operations", ) auth_parser = api.parser() auth_parser.add_argument('Authorization', type=str, location='headers', required=True) @api.errorhandler(UserDoesNotExist) def handle_user_does_not_exist(_error: UserDoesNotExist): """Handle missing user errors.""" return {"message": "User does not exist"}, 404 @api.errorhandler(BlockedUser) def handle_blocked_user(_error: BlockedUser): """Handle blocked users."""
from datetime import datetime from flask_jwt_simple import jwt_required from flask_restx import Resource, Namespace, reqparse from google.cloud.firestore_v1 import CollectionReference, Query from engine.admin import add_qa, client from utils import KST ns_admin_add = Namespace("admin/qa", description="질문을 추가 합니다.") parser = ns_admin_add.parser() parser.add_argument( "Authorization", type=str, location="headers", help="Bearer jwt token", required=True, ) @ns_admin_add.route("/") class QA(Resource): @ns_admin_add.doc("새로운 질문을 추가합니다.", params={ "limit": "limit", "offset": "offset" }, parser=parser) def get(self): parser = reqparse.RequestParser()
'status': fields.Nested(mod_event_status), 'tags': fields.List(fields.String), 'observables': fields.List(fields.Nested(mod_observable_list)), 'case': fields.String, 'created_at': ISO8601(attribute='created_at'), 'modified_at': ISO8601(attribute='updated_at'), 'raw_log': AsDict, 'signature': fields.String }) mod_event_rule_name_only = api.model('EventRuleNames', { 'uuid': fields.String, 'name': fields.String }) event_rule_list_parser = api.parser() event_rule_list_parser.add_argument('page', type=int, location='args', default=1, required=False) event_rule_list_parser.add_argument('sort_by', type=str, location='args', default='created_at', required=False) event_rule_list_parser.add_argument('sort_direction', type=str, location='args', default='asc', required=False) event_rule_list_parser.add_argument('page_size', type=int, location='args', default=25, required=False) event_rule_list_parser.add_argument('page_size', location='args', required=False, type=int, default=25) event_rule_list_parser.add_argument('page', location='args', required=False, type=int, default=1) event_rule_list_parser.add_argument('rules', location='args', required=False, type=str, action='split') @api.route("") class EventRuleList(Resource): @api.doc(security="Bearer") @api.marshal_with(mod_event_rule_list_paged) @api.expect(event_rule_list_parser) @token_required
def test_parser(self): api = Namespace('test') assert isinstance(api.parser(), restx.reqparse.RequestParser)
'signature_fields': fields.List(fields.String), 'observable_fields': fields.List(fields.String), 'interval': fields.Integer(default=5, required=True, min=1), 'lookbehind': fields.Integer(default=5, required=True, min=1), 'mute_period': fields.Integer(default=5, required=True, min=1), 'skip_event_rules': fields.Boolean }, strict=True) mod_detection_list_paged = api.model( 'DetectionListPaged', { 'detections': fields.List(fields.Nested(mod_detection_details)), 'pagination': fields.Nested(mod_pagination) }) detection_list_parser = api.parser() detection_list_parser.add_argument('agent', location='args', type=str, required=False) detection_list_parser.add_argument('active', location='args', type=xinputs.boolean, required=False) detection_list_parser.add_argument('page', type=int, location='args', default=1, required=False) detection_list_parser.add_argument('page_size', type=int,
from flask import request from flask_restx import Namespace, Resource from joyuriz.service.image import ImageManager from joyuriz.service.model import ModelManager from joyuriz.service.cnn import CNN predict_ns = Namespace('Predict', path='/api/v1', description='predict') swagger_parser = predict_ns.parser() model = ModelManager(CNN, 'models/predict.pt') @predict_ns.route('/predict') class Predict(Resource): """ POST로 받은 이미지를 분류하는 API """ @predict_ns.doc(responses={ 200: 'OK', 204: 'Fail to find a face', 400: 'Bad Request', 500: 'Internal Server Error' }) @predict_ns.expect(swagger_parser) def post(self): if "image" not in request.files: raise ValueError input_image = request.files["image"].read() manager = ImageManager(input_image) tensor_image = manager.find_face().crop_image().to_tensor().get_image()
from flask_restx import Resource, Namespace, reqparse from werkzeug.datastructures import FileStorage from werkzeug.utils import secure_filename from app.utils import allowed_file, ALLOWED_EXTENSIONS ns = Namespace('upload-file', description='Загрузка фотографии') upload_parser = ns.parser() upload_parser.add_argument('file', type=FileStorage, location='files', required=True) parser = reqparse.RequestParser() parser.add_argument('file', required=True) @ns.route("") class UploadFile(Resource): @ns.expect(upload_parser) @ns.doc(responses={ 200: 'OK', 400: 'Invalid Argument', 500: 'Неизвестная ошибка' }) def post(self): """ Загрузка фотографии """
from flask_restx import Namespace, Resource, fields, reqparse from flask import make_response, send_file import json api = Namespace('identification', description='Identification Type End Points') validIdentificationCodes = [ 'lei', 'birthDate', 'australianBusinessNumber', 'phoneNumber', 'benefitsCard' ] 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 Entity Type to Graphic API @api.route('/code/<identificationcode>') class countryFlag(Resource): @api.expect(api_params) def get(self, identificationcode): args = api_params.parse_args() fileType = args['format'] if fileType is None or fileType not in ['png', 'svg']: fileType = 'png' identificationCode = identificationcode
from flask_restx import Resource, Namespace, reqparse, fields from flask_jwt_simple import jwt_required ns_notice = Namespace("service/notice", description="Service/Notice") parser = ns_notice.parser() parser.add_argument( "Authorization", type=str, location="headers", help="Bearer jwt token", required=True, ) NOTICE = None @ns_notice.route("/") class Bus(Resource): @ns_notice.doc( "태욱아 받아라", params={ }, ) def get(self): return NOTICE if NOTICE else None @ns_notice.doc( "공지 등록.", params={"notice": "question"}, parser=parser, )
from werkzeug.datastructures import FileStorage from flask import request from flask_restx import Namespace, Resource, fields from flask_jwt_extended import jwt_required, get_jwt_claims, get_jwt_identity from models.software import SoftwareModel from schemas.software import SoftwareSchema from user_functions.record_user_log import record_user_log from user_functions.validate_logo import allowed_file api = Namespace('software', description='Manage antiviruses') software_schema = SoftwareSchema() software_schemas = SoftwareSchema(many=True) upload_parser = api.parser() upload_parser.add_argument('logo', location='files', type=FileStorage, required=True, help='Software Logo') # location='headers' upload_parser.add_argument('name', location='form', type=str, required=True, help='Software Name') # location='headers' logo_parser = api.parser() logo_parser.add_argument('logo', location='files', type=FileStorage,
"last_error": fields.String(), "type": fields.String(enum=["feed", "categ", "all-categ"]), }) midle_panel_model = default_ns.model( "MiddlePanel", { "id": fields.Integer(), "feeds_id": fields.List(fields.Integer()), "main_article_id": fields.Integer(), "main_feed_title": fields.String(), "main_title": fields.String(), "main_date": fields.DateTime(), "main_link": fields.String(), "liked": fields.Boolean(default=False), "read": fields.Boolean(default=False), }) filter_parser = default_ns.parser() filter_parser.add_argument( "search_str", type=str, store_missing=False, help="if specify will filter list with the specified string") filter_parser.add_argument( "search_title", store_missing=False, type=inputs.boolean, default=True, help="if True, the search_str will be looked for in title") filter_parser.add_argument( "search_content", type=inputs.boolean, default=False,
login = auth_namespace.model( "User", { "email": fields.String(required=True), "password": fields.String(required=True) }, ) refresh = auth_namespace.model("Refresh", {"refresh_token": fields.String(required=True)}) tokens = auth_namespace.clone("Access and refresh_tokens", refresh, {"access_token": fields.String(required=True)}) parser = auth_namespace.parser() parser.add_argument("Authorization", location="headers") class Register(Resource): @auth_namespace.marshal_with(user) @auth_namespace.expect(full_user, validate=True) @auth_namespace.response(201, "Success") @auth_namespace.response(400, "Sorry. That email already exists.") def post(self): post_data = request.get_json() username = post_data.get("username") email = post_data.get("email") password = post_data.get("password") user = get_user_by_email(email)
from flask import request from flask_restx import fields, Resource, Namespace from werkzeug import FileStorage from libs.validate import Validate import ipfshttpclient import json import os api = Namespace('ipfs') upload_parser = api.parser() upload_parser.add_argument('file', location='files', type=FileStorage, required=True) conn = ipfshttpclient.connect('/dns4/ipfs.infura.io/tcp/5001/https') v = Validate() @api.route('/post_file') class post_file(Resource): def post(self): payload = v.read_requests(request) print(payload) cid = conn.add_bytes(payload['buffer']) return {'result': cid['Hash']}
def make_namespaces(api): cloudant_client = cloudant.get_client('MODEL_CATALOG') cos_client = cos.get_client() bucket = 'object-storage-mnist-model' result = cloudant_client.get_document(db='models', doc_id='mnist', revs=True).get_result() for num, rev in enumerate(result['_revisions']['ids'][::-1], start=1): try: fname = f'model_v{num}.pkl' ns = Namespace(f'v{num}', description=f'MNIST_v{num}') upload_parser = ns.parser() upload_parser.add_argument('image', location='files', type=FileStorage, required=True) cos_client.get_object(Bucket=bucket, Key=fname) @ns.route('/info') class Info(Resource): FNAME = fname BUCKET = bucket REVISION = f'{num}-{rev}' def get(self): '''Model info''' project_dir = current_app.config['PROJECT_DIR'] train_ds, test_ds = get_dataset(f'{project_dir}/data') X_test, y_test = test_ds.data[:].float( ), test_ds.targets[:] model_buf = io.BytesIO() cos_client.download_fileobj(Bucket=self.BUCKET, Key=self.FNAME, Fileobj=model_buf) model_buf.seek(0) model = pickle.load(model_buf) pipeline = make_pipeline(Scaler(), Unsqueeze(), model) score = pipeline.score(X_test, y_test) return { 'definition': cloudant_client.get_document( db='models', doc_id='mnist', rev=self.REVISION).get_result(), 'score': score } @ns.route('/predict') @ns.expect(upload_parser) class Predict(Resource): FNAME = fname BUCKET = bucket def post(self): '''Predict number''' args = upload_parser.parse_args() model_buf = io.BytesIO() cos_client.download_fileobj(Bucket=self.BUCKET, Key=self.FNAME, Fileobj=model_buf) model_buf.seek(0) model = pickle.load(model_buf) img_buf = io.BytesIO() args['image'].save(img_buf) uploaded_img = Image.open(img_buf) pipeline = make_pipeline(Preprocess(), Scaler(), Unsqueeze(), model) X = [uploaded_img] y_hat = pipeline.predict(X) return {'result': int(y_hat[0])} yield ns except cos_client.exceptions.NoSuchKey: pass
'organization': fields.String, 'name': fields.String, 'description': fields.String, 'members': fields.List(fields.String), 'permissions': fields.Nested(mod_permissions), 'created_by': fields.Nested(mod_user_list), 'created_at': ISO8601(attribute='created_at'), 'system_generated': fields.Boolean }) mod_role_list_paged = api.model('RolesPaged', { 'roles': fields.Nested(mod_role_list), 'pagination': fields.Nested(mod_pagination) }) role_list_parser = api.parser() role_list_parser.add_argument('organization', location='args', required=False) role_list_parser.add_argument( 'page', type=int, location='args', default=1, required=False) role_list_parser.add_argument( 'page_size', type=int, location='args', default=10, required=False) role_list_parser.add_argument( 'sort_by', type=str, location='args', default='created_at', required=False ) role_list_parser.add_argument( 'sort_direction', type=str, location='args', default='desc', required=False ) @api.route("") class RoleList(Resource):