def create_restful_namespace(self, name: str, description: str) -> Namespace: current_app.logger.debug(f"Creating the {name} Namespace") # create and set up namespace ns = Namespace(name, description=description) response_env = ns.model(response_envelope.get("name"), response_envelope.get("fields")) meta_env = ns.model(meta_envelope.get("name"), meta_envelope.get("fields")) links_env = ns.model(links_envelope.get("name"), links_envelope.get("fields")) get_entity_model = ns.clone(f"get_entity_model", response_envelope, {"data": fields.Raw}) get_entity_list_model = ns.clone( f"get_entity_list_model", response_envelope, { "data": fields.List(fields.Raw), "_meta": fields.Nested(meta_env), "_links": fields.Nested(links_env), }, ) self._ns = ns return ns
def test_clone_with_multiple_parents(self): api = Namespace("test") grand_parent = api.model("GrandParent", {}) parent = api.model("Parent", {}) api.clone("Child", grand_parent, parent, {}) assert "Child" in api.models assert "Parent" in api.models assert "GrandParent" in api.models
def test_inherit_from_multiple_parents(self): api = Namespace("test") grand_parent = api.model("GrandParent", {}) parent = api.model("Parent", {}) api.inherit("Child", grand_parent, parent, {}) assert "GrandParent" in api.models assert "Parent" in api.models assert "Child" in api.models
def test_clone_with_multiple_parents(self): api = Namespace('test') grand_parent = api.model('GrandParent', {}) parent = api.model('Parent', {}) api.clone('Child', grand_parent, parent, {}) assert 'Child' in api.models assert 'Parent' in api.models assert 'GrandParent' in api.models
def test_inherit_from_multiple_parents(self): api = Namespace('test') grand_parent = api.model('GrandParent', {}) parent = api.model('Parent', {}) api.inherit('Child', grand_parent, parent, {}) assert 'GrandParent' in api.models assert 'Parent' in api.models assert 'Child' in api.models
def test_clone(self): api = Namespace("test") parent = api.model("Parent", {}) api.clone("Child", parent, {}) assert "Child" in api.models assert "Parent" in api.models
def test_clone(self): api = Namespace('test') parent = api.model('Parent', {}) api.clone('Child', parent, {}) assert 'Child' in api.models assert 'Parent' in api.models
def set_resp(namespace: Namespace, model: Model = None): data = fields.Nested(model) return namespace.model( model.name + "-response", { 'status': fields.Integer(description='status'), 'message': fields.String(description='message'), 'data': data if data else fields.Raw })
def init_models(self, namespace: flask_restx.Namespace): """ Create flask-restx models that can be used to marshall results (and document service). :param namespace: Flask-RestX API or namespace. """ self.json_post_model = namespace.model( f"{self.table_or_collection.__name__}_PostRequestModel", post_request_fields(self.table_or_collection, namespace), ) self.json_put_model = namespace.model( f"{self.table_or_collection.__name__}_PutRequestModel", put_request_fields(self.table_or_collection, namespace), ) self.get_response_model = namespace.model( f"{self.table_or_collection.__name__}_GetResponseModel", get_response_fields(self.table_or_collection, namespace), ) self.get_history_response_model = namespace.model( f"{self.table_or_collection.__name__}_GetHistoryResponseModel", get_history_response_fields(self.table_or_collection, namespace), ) if self.audit: self.get_audit_response_model = namespace.model( f"{self.table_or_collection.__name__}_GetAuditResponseModel", get_audit_response_fields(self.table_or_collection, self.history, namespace), ) self.get_model_description_response_model = namespace.model( f"{self.table_or_collection.__name__}_GetDescriptionResponseModel", get_description_response_fields(self.table_or_collection), )
def test_inherit(self): authorizations = { 'apikey': { 'type': 'apiKey', 'in': 'header', 'name': 'X-API-KEY' } } api = Namespace('test', authorizations=authorizations) parent = api.model('Parent', {}) api.inherit('Child', parent, {}) assert 'Parent' in api.models assert 'Child' in api.models assert api.authorizations == authorizations
def test_inherit(self): authorizations = { "apikey": { "type": "apiKey", "in": "header", "name": "X-API-KEY" } } api = Namespace("test", authorizations=authorizations) parent = api.model("Parent", {}) api.inherit("Child", parent, {}) assert "Parent" in api.models assert "Child" in api.models assert api.authorizations == authorizations
from werkzeug.security import safe_str_cmp from flask_jwt_extended import create_refresh_token, create_access_token from flask_restx import Resource, Namespace, fields from src.models.user import UserModel ns = Namespace("users", description="Users resource.") user_schema = ns.model( "User", dict(id=fields.Integer(readonly=True, description="User unique id."), username=fields.String(required=True, description="User name."), password=fields.String(required=True, description="User password."))) @ns.route("/") class Users(Resource): @ns.doc("list_users") @ns.marshal_list_with(user_schema, skip_none=True) def get(self): return [user.as_dict() for user in UserModel.get_all()] @ns.doc("create_user") @ns.expect(user_schema) @ns.marshal_with(user_schema, skip_none=True) def post(self): user = UserModel(username=ns.payload.get('username'), password=ns.payload.get('password')) user.save() return user.as_dict(), 201
from flask import Blueprint, request, jsonify from http import HTTPStatus from sqlalchemy import exc, or_ from project.extensions import bcrypt from project.modules.utils import authenticate from project.modules.users.models import Users from flask_restx import Resource, Namespace, fields from project.modules.utils import authenticate_restful api = Namespace("Authentication", description="Authentication related operations") login_model = api.model( 'Login', { "email": fields.String(required=True, description="User email for login"), "password": fields.String(required=True, description="Password for login") }) @api.route('/login') class Login(Resource): @api.expect(login_model, validate=True) def post(self): post_data = api.payload response_object = {'status': 'fail', 'message': 'Invalid payload'} if not post_data: return response_object, HTTPStatus.BAD_REQUEST email = post_data.get('email')
from freshermeat.models import User user_ns = Namespace("user", description="User related operations.") # Argument Parsing parser = reqparse.RequestParser() parser.add_argument("user_id", type=str, help="The id of the user.") parser.add_argument("login", type=str, help="The login of the user.") parser.add_argument("page", type=int, default=1, location="args") parser.add_argument("per_page", type=int, location="args") # Response marshalling user = user_ns.model( "User", { "user_id": fields.String(description="The id of the user.", ), "login": fields.String(description="The login of the user."), }, ) user_list_fields = user_ns.model( "UsersList", { "metadata": fields.Raw( description= "Metada (number of page, current page, total number of items)."), "data": fields.List(fields.Nested(user), description="List of items."), }, )
from flask_restx import Namespace, Resource, fields api = Namespace('test', description='TEST related operations') testserver = api.model( "TEST Server", { "id": fields.String(required=True, description="Server ID"), "name": fields.String(required=True, description="Server Name"), "address": fields.String(required=True, description="Server Address") }, ) SERVERS = [ { "id": "test01", "name": "test01.net.windwave.tc", "address": "10.255.5.10" }, ] @api.route("/") class TESTServerList(Resource): @api.doc("list_servers") @api.marshal_list_with(testserver) def get(self): return SERVERS
from flask_jwt_extended import create_access_token, create_refresh_token, jwt_refresh_token_required from marshmallow import ValidationError from models.user_model import User, UserSchema from models.user_roles_model import UserRole, UserRoleSchema from user_functions.user_role_manager import UserPrivilege api = Namespace('login', description='Log in') user_schema = UserSchema() users_schema = UserSchema(many=True) user_role_schema = UserRoleSchema() my_user_model = api.model('Login', { 'id_no': fields.Integer(required=True, description='ID Number'), 'password': fields.String(required=True, description='Password') }) @api.route('') class Login(Resource): @api.doc('login_user') @api.expect(my_user_model) def post(self): '''Log in user''' data = api.payload if not data: abort(400, 'No input data detected') id_no = data['id_no']
from flask_restx import Resource, Namespace, fields from flask import request import json from application.service.CarService import CarService # noqa from core.domain.dto.CarInsertRequestDTO import CarInsertRequestDTO from core.domain.dto.CarUpdateRequestDTO import CarUpdateRequestDTO from core.domain.dto.CarInsertResponseDTO import CarInsertResponseDTO from os import environ api = Namespace('Car Dealer', description='Car Dealer Services') # definição de modelo que será validado ao receber post modelInsert = api.model( 'CarModelInsert', { 'name': fields.String, 'type': fields.String, 'year': fields.Integer, 'isNew': fields.Boolean }) # definição de modelo que será validado ao receber put modelUpdate = api.model( 'CarModelUpdate', { 'name': fields.String, 'type': fields.String, 'year': fields.Integer, 'isNew': fields.Boolean }) hostName = environ.get('SERVER_HOST', 'localhost')
from utils import list_keys from .handling import generate_yara_rule from handlers import git_handler from database.operations import update_rule, get_rule, get_rules from handlers.config_handler import CONFIG from handlers.log_handler import create_logger api = Namespace('core', description='Core API') log = create_logger(__name__) yara_metadata_model = api.model("YARA-Metadata", { "identifier": fields.String(required=True, pattern=r"([a-zA-Z]([a-z0-9])+)"), "value": fields.String(required=True, pattern=r'.*'), "value_type": fields.String(required=True, pattern=r'str|int|bool'), }) yara_string_model = api.model("YARA-String", { "identifier": fields.String(required=True, pattern=r"([a-zA-Z]([a-z0-9])+)"), "value": fields.String(required=True, pattern=r'.*'), "value_type": fields.String(required=True, pattern=r'str|int|bool'), "string_type": fields.String(required=True, pattern=r'text|hex|regex'), "modifiers": fields.List( fields.String( required=True, pattern=r"nocase|wide|ascii|xor|base64(wide)?(?'base64_alphabet'.*)?|fullword|private") ), "modifier_str": fields.String( required=True,
from flask import request from flask_restx import Resource, Namespace from .core import get_resource_modelsdshknn from ....iomodels import input_def_modelsdshneig, output_def_modelsdshneig ns_modelsdsh = Namespace( 'others', description='Fetch/Compute other useful infos for models-dashboard') input_def = ns_modelsdsh.model(*input_def_modelsdshneig) output_def = ns_modelsdsh.model(*output_def_modelsdshneig) @ns_modelsdsh.route("/modelsdsh/neighbors") class KnnlamdshOthers(Resource): '''This is a test''' @ns_modelsdsh.expect(input_def, validate=True) @ns_modelsdsh.marshal_with(output_def) def post(self): '''Fetch/Compute knn vector for a specific resource for models-dashboard''' return get_resource_modelsdshknn(request.json) @ns_modelsdsh.errorhandler def default_error_handler(error): '''Default error handler''' return {'message': str(error)}, getattr(error, 'code', 500)
from storages import Storage from utils.scan import get_scan_by_uuid from utils.scan import validate_schedule from .authorizers import token_required from .parsers import Parser api = Namespace("scan") RRULE_WEEKDAY_LIST = ["MO", "TU", "WE", "TH", "FR", "SA", "SU"] ScanResultGetResponseSchema = api.model( "Scan Result Get Response", { "host": fields.String(required=True), "port": fields.String(required=True), "name": fields.String(required=True), "description": fields.String(required=True), "severity": fields.String(required=True), }, ) ScanGetResponseSchema = api.model( "Scan Get Response", { "uuid": fields.String(required=True, attribute=lambda scan: scan["uuid"].hex), "name": fields.String(required=True), "description": fields.String(required=True), "target":
from project.api.users.crud import ( get_all_users, get_user_by_email, add_user, get_user_by_id, update_user, delete_user, ) users_namespace = Namespace("users") user = users_namespace.model( "User", { "id": fields.Integer(readOnly=True), "username": fields.String(required=True), "email": fields.String(required=True), "created_date": fields.DateTime, }, ) class UsersList(Resource): @users_namespace.marshal_with(user, as_list=True) def get(self): """Returns all users.""" return get_all_users(), 200 @users_namespace.expect(user, validate=True) @users_namespace.response(201, "<user_email> was added!") @users_namespace.response(400, "Sorry. That email already exists.")
mood_mappings = {'Indifferent': {'Western', 'War', 'Biography', 'Family'}, 'Sad and Rejected': {'Musical', 'Comedy', 'Romance'}, 'Flirty': {'Musical', 'Drama', 'Fantasy', 'Romance'}, 'Energetic and Excited': {'Thriller', 'Musical', 'Crime', 'Drama', 'Fantasy', 'Adventure', 'Sci-Fi', 'Action', 'Comedy' }, 'Stressed': {'Animation'}, 'Weird': {'Film-Noir', 'Crime', 'Drama', 'Horror', 'Mystery'} } api = Namespace('Movies', 'Search for Movies and get Movie details', '/movies') film_summary = api.model('Film Summary', {'movieID': fields.Integer, 'title': fields.String, 'year': fields.Integer, 'rating': fields.String(description = 'Average rating out of 5') } ) search_results = api.model('Search Results', {'data': fields.List(fields.Nested(film_summary)), 'count': fields.Integer(description = 'The total number of search results') } ) parser = reqparse.RequestParser() parser.add_argument('page_size', 10, type = int) parser.add_argument('page_index', required = True, type = int) parser.add_argument('name', '') parser.add_argument('description', '')
""" Movies Endpoint """ from flask import request from flask_restx import Namespace, Resource, fields from service.movies import Movies NS = Namespace('movies', description='Operations related to movies') MOVIE = NS.model( 'Movie', { 'title': fields.String(required=True, description='Movie title', example='Django Unchained'), 'genre': fields.String( required=True, description='Movie type', example='Drama/Action') }) @NS.route("") class MoviesCollection(Resource): """ Movies Collection methods """ def get(self): """ Returns list of movies """ return Movies().get_all() @NS.expect(MOVIE) def post(self): """ Creates a movie """ return Movies().create_one(request.get_json())
from flask_restx import Namespace, Resource, fields, reqparse, inputs api = Namespace('apis', description='Google Cloud Platform APIs') apimodel = api.model( 'Api', { 'api': fields.String(required=True, description='API service name'), 'title': fields.String(required=True, description='API title'), 'description': fields.String(description='API description'), 'preApproved': fields.Boolean(required=True, description='Is API pre-approved for use'), }) apis = [] class Apis: def get_namespace(config): for _name, _api in config['approvedApis']['approved'].items(): apis.append({ 'api': _name, 'title': _api['title'], 'description': _api['description'], 'preApproved': True, }) for _name, _api in config['approvedApis']['holdForApproval'].items(): apis.append({ 'api': _name,
from flask import request from flask_restx import Resource, Namespace from .core import get_knn_resourcesmetadata from ....iomodels import input_def_knn_res, output_def ns_lamdsh = Namespace('others', description='Fetch/Compute doc2vec vector') input_def = ns_lamdsh.model(*input_def_knn_res) output_def = ns_lamdsh.model(*output_def) @ns_lamdsh.route("/lamdsh/knnlamdsh", doc=False) class KnnlamdshOthers(Resource): '''This is a test''' @ns_lamdsh.expect(input_def, validate=True) @ns_lamdsh.marshal_with(output_def) def post(self): '''Fetch/Compute knn doc2vec vector for a specific resource for lam-dashboard''' tmp = get_knn_resourcesmetadata(**request.json) # print(tmp) return {'output': tmp} @ns_lamdsh.errorhandler def default_error_handler(error): '''Default error handler''' return {'message': str(error)}, getattr(error, 'code', 500)
import platform from flask import request from flask_restx import fields, Namespace, Resource respond_namespace = Namespace( 'respond', description='Provides operations that generate a simple response.') copy_cat_model = respond_namespace.model( 'Respond', {'response': fields.String(description='The string provided.')}) @respond_namespace.route('<string>') class Copycat(Resource): @respond_namespace.marshal_with(copy_cat_model) def get(self, string: str): return { 'response': string, } platform_model = respond_namespace.model('Host', { 'hostname_or_ip': fields.String( description='The computer’s network name (may not be fully qualified!) or its ip address.' \ 'An empty string is returned if the value cannot be determined.' ), 'system': fields.String( description='Returns the system/OS name, such as "Linux", "Darwin", ' \ '"Java", "Windows". An empty string is returned if the' \ 'value cannot be determined.'
from flask_restx import Namespace, Resource, fields from datetime import datetime from src.api.users.models import User from src.api.users.crud import ( # isort:skip get_all_users, get_user_by_email, add_user, get_user_by_id, update_user, delete_user, get_all_deliveries, get_delivery_by_id, add_delivery, update_delivery_status, delete_delivery, ) users_namespace = Namespace("users") user = users_namespace.model( "User", { "id": fields.Integer(readOnly=True), "username": fields.String(required=True), "email": fields.String(required=True), "created_date": fields.DateTime, }, ) user_post = users_namespace.inherit("User post", user, {"password": fields.String(required=True)}) class UsersList(Resource): @users_namespace.marshal_with(user, as_list=True) def get(self): """Returns all users.""" return get_all_users(), 200
model_recipe = api.model( 'recipe', { 'nextId': fields.Integer(required=True, description='The next identifier;'), 'payload': fields.List( fields.Nested( api.model( 'recipe_payload', { 'recipe_id': fields.Integer(required=True, description='Recipe idenifier'), 'name': fields.String(required=True, description='Recipe name'), 'tags': fields.List( fields.Nested( api.model( 'tag list', { 'tag_name': fields.String(required=True, description='tag name'), 'tag_group': fields.String(required=True, description='tag group'), }))), 'duration': fields.Float }))) })
from flask_restx import Namespace, Resource, fields api = Namespace("cats", description="Cats related operations") cat = api.model( "Cat", { "id": fields.String(required=True, description="The cat identifier"), "name": fields.String(required=True, description="The cat name"), }, ) CATS = [ {"id": "felix", "name": "Felix"}, ] @api.route("/") class CatList(Resource): @api.doc("list_cats") @api.marshal_list_with(cat) def get(self): """List all cats""" return CATS @api.route("/<id>") @api.param("id", "The cat identifier") @api.response(404, "Cat not found") class Cat(Resource): @api.doc("get_cat")
from flask_restx import Namespace, Resource, fields api = Namespace('teams', description='Project teams') team = api.model( 'Team', { 'id': fields.String(required=True, description='Team id'), 'title': fields.String(required=True, description='Team title'), 'description': fields.String(description='Team description'), }) teams = [] class Teams: def get_namespace(config): for _id, _team in config['config']['projectGroups'].items(): teams.append({ 'id': _id, 'title': _team['title'], 'description': _team['description'], }) return api @api.route('/') class TeamsList(Resource): @api.doc('list_teams') @api.marshal_list_with(team)