__schema_type__ = ['string', 'null'] __schema_example__ = 'nullable string' class PrivateString(fields.String): def format(self, value): return None api = Namespace('connections', description='Connection related operations') dto = api.model( 'connection', { 'id': fields.Integer(readonly=True, example=1), 'name': fields.String(required=True, example='arbitrary-unique-name'), 'type': fields.String(required=True, example='s3'), 'bucket': OptionalString(required=False, example='my-bucket-name'), 's3_access_key_id': OptionalString(required=False, example='KJRHJKHWEIUJDSJKDC2J'), 's3_secret_access_key': OptionalString(required=False, example='jksldASDLASdak+asdSDASDKjasldkjadASDAasd'), 's3_region': OptionalString(required=False, example='us-west-2'), 's3_aws_session_token': OptionalString(required=False, example='you session token'),
#pylint: disable=unused-argument from flask import g, jsonify, abort, send_file from flask_restplus import Resource, fields from pyinfraboxutils.ibflask import auth_required, check_job_belongs_to_project from pyinfraboxutils.ibrestplus import api from pyinfraboxutils.storage import storage ns = api.namespace('api/v1/projects/<project_id>/jobs', description='Job related operations', tag="test") limits_model = api.model( 'LimitsModel', { 'cpu': fields.Integer(min=1, attribute='cpu'), 'memory': fields.Integer(min=128, attribute='memory') }) dependency_model = api.model( 'DependencyModel', { 'on': fields.List(fields.String), 'job': fields.String, 'job-id': fields.String }) resource_model = api.model('ResourceModel', {'limits': fields.Nested(limits_model)}) job_model = api.model( 'JobModel', { 'id': fields.String,
@api.route('/with-query-string') class Temps(Resource): @api.expect(example3_parser) def get(self): """List images""" example3_parser = reqparse.RequestParser() example3_parser.add_argument('q') args = example3_parser.parse_args() query_string_value = args.get('q') return {'query_string_value': city_value} example4_fields = api.model('MyModel', { 'name': fields.String, 'age': fields.Integer(min=0) }) # GET does not support fields. @api.route('/with-fields') class Temps(Resource): @api.expect(example4_fields) def post(self): """ Documentation for the method goes here """ payload = api.payload return {'name': payload['name'], 'age': str(payload['age'])}
from app.common import (logging) # using namespace to organized all the routing related to car_details into single level ns_cars = Namespace('cars', description='namespace for the cars data') # restplus model for marshalling with the database records car_model = ns_cars.model( 'Cars', { 'chassis_no': fields.String(required=True, example='12345A'), 'make': fields.String(required=True, example='Nissan'), 'model': fields.String(required=True, example='Micra'), 'year': fields.Integer(required=True, example='2004'), 'id': fields.Integer(required=True, example='101'), 'last_updated': fields.DateTime(required=True, example='2018-02-09 10:11:11'), 'price': fields.Float(required=True, example='500.0') }) # restplus model for considering 'model' and 'make' for finding average price price_model = ns_cars.model( 'Average_Price', { 'make': fields.String(required=True, example='Nissan'), 'model': fields.String(required=True, example='Micra') })
api = Namespace('basket', description='Customer Basket/Checkout System') RABBIT_USER = os.getenv('RABBIT_USER', 'guest') RABBIT_PASSWORD = os.getenv('RABBIT_PASSWORD', 'guest') RABBIT_HOST = os.getenv('RABBIT_HOST', '127.0.0.1') RABBIT_PORT = os.getenv('RABBIT_PORT', '5672') amqp_uri = 'amqp://{}:{}@{}:{}'.format(RABBIT_USER, RABBIT_PASSWORD, RABBIT_HOST, RABBIT_PORT) CONFIG_RPC = {'AMQP_URI': amqp_uri} basket_item = api.model( 'Basket Item', dict(product_id=fields.Integer(required=True), product_name=fields.String(), unit_price=fields.Float(), old_unit_price=fields.Float(), quantity=fields.Integer)) basket = api.model( 'Basket', dict(buyer_id=fields.String(required=True), items=fields.List(fields.Nested(basket_item)))) checkout_basket = api.model( 'BasketCheckout', dict(buyer_id=fields.String(), buyer=fields.String(), city=fields.String(required=True),
'Symptom', { 'name': fields.String( required=True, example='Fatigue', description='Symptom name'), }) allData = api.model( 'data', { 'symptoms': fields.List(fields.Nested(symptom)), 'sex': fields.String(required=False, example='female', description='male, female, other'), 'age': fields.Integer(readOnly=True, example=32, description='The users age') }) model = joblib.load('model_rf.pkl') mlb = joblib.load('mlb_simple.pkl') def loadFeatures(): filein = open('features_rf.txt', 'r') featureList = [] for feature in filein: if (feature.rstrip('\n') in featureList): print feature featureList.append(feature.rstrip('\n')) return featureList
* Licence: MIT, see LICENSE ''' from flask_restplus import fields from src.api.apiConfig import api from src.api.fitcrack.endpoints.package.responseModels import job_model from src.api.fitcrack.responseModels import pagination, host_short_model, package_short_model, boincHost_model, \ user_model page_of_hosts_model = api.inherit( 'Page of hosts', pagination, {'items': fields.List(fields.Nested(boincHost_model))}) jobWithPackage_model = api.inherit( 'Job with package', job_model, {'job': fields.Nested(package_short_model, attribute='package')}) boincHostDetail_model = api.model( 'Host detail boinc', { 'id': fields.Integer(readOnly=True, required=False), 'domain_name': fields.String(), 'p_model': fields.String(), 'user': fields.Nested(user_model), 'os_name': fields.String(), 'fc_host': fields.Nested(host_short_model), 'active': fields.Boolean(), 'workunits': fields.List(fields.Nested(jobWithPackage_model)), 'jobs': fields.List(fields.Nested(package_short_model)) })
import logging ns = api.namespace('ping', description="Run ping tests") host = api.model( 'host', { 'hostname': fields.String(description='Hostname', example='edge_node1'), 'ip': fields.String(description='IP of Host', example='10.0.0.1') }) host_list = api.model( 'hosts', { 'threads_num': fields.Integer(description='Number of threads to run ping with', example=1, default=1), 'seconds': fields.String(description='seconds to run each ping for', example='4'), 'hosts': fields.List(fields.Nested(host)) }) @ns.route('') class PingList(Resource): @api.doc(responses={200: 'Everything ok', 201: 'No known hosts'}) def get(self): """ Returns dict of latencies to known hosts """
"This API provides endpoints such as Historical and Forecast in combination with and[or] without parameters" ) weatherAPI = Namespace('HistoricalWeather', description='Historical Weather') api.add_namespace(weatherAPI) parser = reqparse.RequestParser() parser.add_argument('DATE') parser.add_argument('TMAX') parser.add_argument('TMIN') postModel = api.model( 'AccountModel', { 'DATE': fields.String(required=True, description='Date in YYYYMMDD format'), 'TMAX': fields.Integer(required=True, description='Max temp'), 'TMIN': fields.Integer(required=True, description='Min temp'), }) args1 = { 'DATE': fields.String(required=True, description='Date in YYYYMMDD format'), 'TMAX': fields.Integer(required=True, description='Max temp'), 'TMIN': fields.Integer(required=True, description='Min temp') } class WeatherApplication(Resource): def get(self): return "/Historical/ , /Historical/'<DATE>' and /Forecast/'<DATE>' as GET Requests \n /Historical/ with date as POST and Delete Requests"
'ingredients': fields.List(fields.Nested(ingredient_model)) }) categories_model = api.model( 'categories_model', { 'categories': fields.List(fields.Nested(category_ingredient_model)), }) ingredients_recipe_model = api.model( 'ingredients_recipe_model', { 'name': fields.String(required=True, example='Cheese'), 'quantity': fields.String(required=True, example='500 grams') }) recipe_id_model = api.model( 'recipe_id_model', {'recipe_id': fields.Integer(required=True, min=0)}) tag_model = api.model( 'tag_model', {'tag': fields.String(required=True, example='Breakfast')}) tags_model = api.model('tags_model', {'tags': fields.List(fields.Nested(tag_model))}) ingredients_tags_model = api.model( 'ingredients_tags_model', { 'ingredients': fields.List(fields.Nested(ingredient_model)), 'tags': fields.List(fields.Nested(tag_model)) }) recipe_name_tags_model = api.model( 'recipe_name_tags_model', {
min_length=3, max_length=32, description='MQTT username'), 'password': fields.String(required=True, min_length=3, max_length=32, description='MQTT password'), 'server': fields.String(required=True, min_length=3, max_length=64, default='93.118.34.190', description='MQTT server address'), 'port': fields.Integer( required=True, default=1883, description='MQTT server port'), 'keep_alive': fields.Integer( required=True, default=60, description='MQTT keep alive') }) mqtt_account_patch = api.model( 'MQTT account patch', { 'username': fields.String(required=False, min_length=3, max_length=32, description='MQTT username'), 'password': fields.String(required=False, min_length=3,
from flask import request from flask_restplus import Namespace, Resource, fields from http import HTTPStatus namespace = Namespace('entities', 'Entities fake endpoints') entity_model = namespace.model( 'Entity', { 'id': fields.Integer(readonly=True, description='Entity identifier'), 'name': fields.String(required=True, description='Entity name') }) entity_list_model = namespace.model( 'EntityList', { 'entities': fields.Nested( entity_model, description='List of entities', as_list=True), 'total_records': fields.Integer(description='Total number of entities', ), }) entity_example = {'id': 1, 'name': 'Entity name'} @namespace.route('') class entities(Resource): '''Get entities list and create new entities''' @namespace.response(500, 'Internal Server error') @namespace.marshal_list_with(entity_list_model) def get(self): '''List with all the entities'''
# Scan result structure scan_result = api.model( 'ScanResultStructure', { 'req': fields.String(description=u'Requirement ShortName'), 'result': fields.Nested( api.model( 'ScanResult', { 'status': fields.String( description= u'Requirement fulfilled? (PASSED/FAILED/ERROR/IN_PROGRESS)' ), 'confidenceLevel': fields.Integer(description=u'Value in percent'), 'message': fields.String(description=u'Result message') })), }) ### Scanning class @api.route('/scanapi/tests', methods=['POST']) class Scan(Resource): @api.doc(responses={200: 'Test result'}) @api.expect(scan_definition) @api.marshal_list_with(scan_result) def post(self): request_params = api.payload target_url = request_params['testProperties']['appUrl']
from cleanup import clean_images IMAGE_DIR = "{}/api/static/cleaned-images".format(os.getcwd()) # flask app configuration app = Flask(__name__, static_folder='static') api = Api(app, doc="/swagger/") # image gnerator generator = ImageGenerator() UPLOAD_DIRECTORY = "./api/static/images" fields = api.model( 'NewPokemonImageRequestBody', { 'id1': fields.Integer(description='pokedex id', required=True, min=1), 'id2': fields.Integer(description='pokedex id', required=True, min=1), }) @api.route("/home") class Home(Resource): @api.doc("home") def get(self): return jsonify("Welcome to PokeMate image generator!") @api.route("/image-generator") class Generator(Resource): @api.doc(model='NewPokemonImageRequestBody') def post(self):
from controller.book_copy_checker import BookCopyChecker from controller.note_checker import NoteChecker ns = Namespace('books', description='Book operations') note_marshaller = ns.model( 'Note', { 'note_title': fields.String(required=True, description='Unique title of note'), 'note': fields.String(required=True, description='Note about a book.') }) return_note_marshaller = ns.inherit('ReturnNote', note_marshaller, { 'book_id': fields.Integer(description='Book id note is associated with.') }) amend_note_marshaller = ns.model( 'AmendNote', { 'note': fields.String(required=True, description='Text of note to be amended.') }) author_marshaller = ns.model( 'Author', { 'author_id': fields.Integer(required=False, description='Id for an author record'), 'first_name': fields.String(required=True, description='First name of an author'), 'last_name':
from flask_restplus import fields from rest_api_demo.api.restplus import api authn_role = api.model( 'AuthnRole', { 'id': fields.Integer(required=True, description='The id of the user'), 'role_name': fields.String(required=True, description='The name of the role') }) authn_account_request = api.model( 'Account', { 'id': fields.Integer(readonly=True, description='The unique identifier of an account'), 'account_name': fields.String(required=True, description='Account title'), }) authn_orgunit_request = api.model( 'Organizational Unit', { 'id': fields.Integer(readonly=True, description='The unique identifier of an orgunit'), 'account_id': fields.Integer(required=True, description='Account associated with org unit'), 'orgunit_name': fields.String(required=True, description='Organizational Unit title'), })
from flask_restplus import fields from lost.api.api import api template_element = api.model( 'Template element', { 'peN': fields.Integer(description="Number of element."), 'peOut': fields.List(fields.Integer, description='Elements output.'), 'datasource': fields.Raw(), 'script': fields.Raw(), 'annoTask': fields.Raw(), 'loop': fields.Raw(), 'dataExport': fields.Raw(), }) template = api.model( 'Template', { 'id': fields.Integer(readOnly=True, description="The identifier of the pipeline template."), 'description': fields.String(readOnly=True, description="The description of the pipeline template."), 'author': fields.String(readOnly=True, description="The author of the pipeline template."), 'namespace': fields.String(readOnly=True, description="The namespace of the pipeline template."), 'name': fields.String(readOnly=True, description="The name of the pipeline template."),
from automoticz.utils import rest from . import namespace as api wsdevices_reguest = api.model('WS devices GET request', { 'access_token': rest.access_token_field, }) base_model = api.model('WS Device GET base response', rest.response_base) WSCommand_model = api.model( 'WS Command model', { 'description': fields.String(description='Command description'), 'name': fields.String(description='Command name'), 'id': fields.String(description='Command ID'), 'device_id': fields.Integer(description='Device ID'), }) WSState_model = api.model( 'WS State model', { 'value': fields.String(description='State value'), 'description': fields.String(description='State description'), 'name': fields.String(description='State name'), 'id': fields.String(description='State ID'), }) WSDevice_list_item = api.model( 'WS Device list item', { 'id': rest.wsdevice_id_field, 'name': rest.wsdevice_name_field, 'description': rest.wsdevice_description_field,
placebp = Blueprint('place', __name__) ns_place = Namespace( 'similar', description='Get places with simlar Revenue,Tax,Expenditures etc.,') api = Api(placebp, version='1.0', title='TruthTree ML API', description='APIs supported by ML') api.add_namespace(ns_place) year_range = ns_place.model( 'Year range', { 'start': fields.Integer(default=1977, description="Starting year"), 'end': fields.Integer(default=2016, description="Ending year") }) PlaceSingle = ns_place.model( 'Similar places for single attribute', { 'id': fields.Integer(required=True, description="Place ID"), 'place_type': fields.Integer( required=True, description="Type of place, Ex. state(0), county(1), city(2)"), 'attribute': fields.Integer(required=True, description="Attribute ID"), 'normalize_by': fields.Integer(
from app.utils import get_logger, auth from . import base_query_fields, ARLResource, get_arl_parser ns = Namespace('site', description="站点信息") logger = get_logger() base_search_fields = { 'site': fields.String(required=False, description="站点URL"), 'hostname': fields.String(description="主机名"), 'ip': fields.String(description="ip"), 'title': fields.String(description="标题"), 'http_server': fields.String(description="Web servers"), 'headers': fields.String(description="headers"), 'finger.name': fields.String(description="指纹"), 'status': fields.Integer(description="状态码"), 'favicon.hash': fields.Integer(description="favicon hash"), 'task_id': fields.String(description="任务 ID"), } base_search_fields.update(base_query_fields) @ns.route('/') class ARLSite(ARLResource): parser = get_arl_parser(base_search_fields, location='args') @auth @ns.expect(parser) def get(self): """
'dateUpdated': fields.DateTime() }) a_user = api.model( 'user', { 'name': fields.Nested(a_user_name), 'details': fields.Nested(a_user_details), 'auth': fields.Nested(a_auth) }) A_USER_EMPLOYEE = api.model( 'User Employee', { 'name': fields.Nested(a_user_name), 'details': fields.Nested(a_user_details), # 'username': fields.String(), 'webUrl': fields.String() }) a_user_details = api.model( 'users', { 'id': fields.Integer(), 'name': fields.Nested(a_user_name), 'auth': fields.Nested(a_auth_hashed), 'details': fields.Nested(a_user_details), 'timestamp': fields.Nested(a_user_timestamp) }) A_USER_EMPLOYEE_PASSWORD = api.model('User Password', {'password': fields.String()})
from flask_restplus import fields from cortex.api import api_manager pagination = api_manager.model( 'A page of results', { 'page': fields.Integer(description='Number of this page of results'), 'pages': fields.Integer(description='Total number of pages of results'), 'per_page': fields.Integer(description='Number of items per page of results'), 'total': fields.Integer(description='Total number of results'), })
) # A NameSpace is a top level collection of paths. The only namespace in this applicaton is Addresses ns = api.namespace( 'Addresses', description='APIs for validating and obtaining maling address info.') # Models are schema definitions for JSON objects passed into and out of operations in bodies. # There are two approaches to defining a model. 1) api.model, 2) JSON Schema. # https://json-schema.org/ # Data returned in the body of a verification check. address = api.model( 'Address', { 'delivery_point_parcode': fields.Integer(required=True, description='Barcode number identifying mail point'), 'street': fields.String(required=True, description='Street name'), 'city': fields.String(required=True, description='City name'), 'state': fields.String(required=True, description='State name'), 'zipcode': fields.String(required=True, description='State name'), 'more fields': fields.String(required=True, description='Blah, blah ...') }) # Information about an individual zipcode returns in a zipcode lookup. zipcode_info = api.model( 'ZipCodeInfo', {
from random import * from flask import Flask, redirect, render_template, request, url_for from flask_restplus import Resource, Api, fields from table import UserTable flask_app = Flask(__name__) api = Api(app=flask_app, version='1.0', title='WP User API', description='WP User API Site') ns = api.namespace('userapi', description='Main APIs') user_model = api.model( 'UserModel', { 'id': fields.Integer( required=True, description="user ID", help="BIGINT(20) UNSIGNED"), 'user_login': fields.String( required=True, description="login ID", help="VARCHAR(60)"), 'user_pass': fields.String( required=True, description="login PW", help="VARCHAR(64) MD5"), 'user_nicename': fields.String( required=True, description="user Nice Name", help="VARCHAR(50)"), 'user_email': fields.String( required=True, description="user Email", help="VARCHAR(100)"), 'display_name': fields.String(required=True, description="user Display Name",
from flask import request from flask_restplus import Namespace, Resource, fields, reqparse from .utils import clean_data, SingleResource, db from app.models import Song, Album, Artist, Genre api = Namespace("songs", description="Endpoint to query a Songs") serializer = api.model("song",{ "id" : fields.String(description="Public ID of Song", attribute="public_id", readonly=True), "name" : fields.String(description="Name of Song"), "url" : fields.String(description="URL ID of Song"), "year" : fields.Integer(description="Year of Song", min=1960), "track number": fields.Integer(description="Number of Track in Album", attribute="track_number"), "featuring": fields.List(fields.String, description="Artists featured on Song"), "album": fields.String(description="Album song belongs to"), "genre": fields.String(description="Genre song belongs to"), "artist": fields.String(description="Artists of Song"), "reviews": fields.List(fields.String, description="Reviews of Song", readonly=True), }) parser = reqparse.RequestParser() parser.add_argument("name", type=str, help="Name of Song", location="form") parser.add_argument("url", type=str, help="URL of Song resource", location="form") parser.add_argument("year", type=int, help="Year Song was released", location="form") parser.add_argument("track number", type=int, help="Track Number of Song if in an Album", dest="track_number", location="form") parser.add_argument("album", type=str, help="Album name if Song is in an Album", location="form") parser.add_argument("artist", type=str, help="Artist of Song", location="form") parser.add_argument("genre", type=str, help="Genre Song belongs to", location="form") parser.add_argument("featuring", type=str, help="List of Artists featured on Song", action="append", location="form")
class MinerDto: namespace = Namespace('miner', description='miner related operations') miner = namespace.model( 'miner', { 'id': fields.String(required=False, description="the miners UUID"), 'name': fields.String(required=False, description="name of the miner set by the user"), 'user_id': fields.String( required=False, description="user id of the user that the miner belongs to"), }) share = namespace.model( 'share', { 'miner_id': fields.String(required=False, description="the miners UUID"), 'gpu_no': fields.Integer( required=True, description="the gpu that the share was generated on"), 'time': fields.DateTime( required=True, description="the time at which the share was generated"), 'type': fields.String(enum=[enum.name for enum in ShareType], description="invalid, valid or stale"), }) share_aggregate = namespace.model( 'share_aggregate', { 'start': fields.DateTime( required=True, description="the time at which the aggregation starts"), 'duration': fields.Integer( required=True, description="the length of the aggregation period, in minutes" ), 'gpu_no': fields.Integer( required=True, description="the gpu that the share was generated on"), 'valid': fields.Integer(required=False, description="# of shares generated of this type"), 'invalid': fields.Integer(required=False, description="# of shares generated of this type"), }) health = namespace.model( 'health', { 'miner_id': fields.String(required=False, description="the miners UUID"), 'gpu_no': fields.Integer( required=True, description="the gpu that the share was generated on"), 'time': fields.DateTime( required=True, description="the time at which the share was generated"), 'temperature': fields.Integer(required=False, description="the gpus temperature in C"), 'power': fields.Integer(required=False, description="the gpus power usage in watts"), 'hashrate': fields.Float(required=False, description="the gpus hashrate in megahash"), }) class StatsQuerySchema(Schema): start = fields.DateTime(required=False) end = fields.DateTime(required=False)
from flask_restplus import fields from blog_app.api import api blog_article = api.model( 'Blog Article', { 'id': fields.Integer(readOnly=True, description='unique identifier for an article'), 'title': fields.String(required=True, description='article title'), 'content': fields.String(required=True, description='article content'), 'category_id': fields.Integer(attribute='category_id'), 'pub_date': fields.Integer(attribute='pub_date'), }) pagination = api.model( 'A page of results', { 'page': fields.Integer( description='number of the current page of the results'), 'pages': fields.Integer(description='total number of pages of results'), 'per_page': fields.Integer(description='number of articles per page of results') }) category = api.model(
###################################################################### # Configure Swagger before initilaizing it ###################################################################### api = Api(app, version='1.0.0', title='Pet Demo REST API Service', description='This is a sample server Pet store server.', default='pets', default_label='Pet shop operations', doc='/' # default also could use doc='/apidocs/' # prefix='/api' ) # Define the model so that the docs reflect what can be sent pet_model = api.model('Pet', { 'id': fields.Integer(readOnly=True, description='The unique id assigned internally by service'), 'name': fields.String(required=True, description='The name of the Pet'), 'category': fields.String(required=True, description='The category of Pet (e.g., dog, cat, fish, etc.)'), 'available': fields.Boolean(required=True, description='Is the Pet avaialble for purchase?') }) # query string arguments pet_args = reqparse.RequestParser() pet_args.add_argument('category', type=str, required=False, help='List Pets by category') ###################################################################### # Special Error Handlers ######################################################################
from typing import List from flask import current_app from flask_jwt_extended import jwt_required from flask_restplus import Namespace, fields, Resource from flask_sqlalchemy_session import current_session from app.models import District api = Namespace('districts', description='(Проверку на цикличность дистриктов не делал)', decorators=[jwt_required]) district_model = api.model( 'District', { 'district_id': fields.Integer(), 'name': fields.String(), 'parent_district_id': fields.Integer(), }) district_payload_model = api.model('District Payload', { 'name': fields.String(), 'parent_district_id': fields.Integer(), }) district_tree_model = api.model( 'District Tree', { 'districts_tree': fields.List( fields.Nested( api.model(
from flask_restplus import fields from mtm.api.restplus import api # Chart item object used in endpoint responses chartItemResponseModel = api.model( 'ChartItem', { 'rank': fields.Integer( required=True, description='Rank position of the song', example=1), 'startDate': fields.Date(required=True, description='Rank position of the song'), 'endDate': fields.Date(required=True, description='Rank position of the song'), 'songId': fields.String(readOnly=True, description='Unique identifier of a song', example='1'), 'song.name': fields.String(readOnly=True, description='Unique identifier of a song', example='Bad Romance'), 'song.artist': fields.String(readOnly=True, description='Unique identifier of a song', example='Lady Gaga'), }) # Response wrapper for list of chart item objects chartResponseModel = api.inherit( 'Chart response', {'data': fields.List(fields.Nested(chartItemResponseModel))})