def routes(app):
"""
Generate all the views and blueprints and corresponding endpoints.
Args:
app: Flask current app
"""
api = Api(app=app,
version="1.0",
title="Service API",
description="All the APIs of {{ cookiecutter.project_name }}")
namespace = api.namespace("{{ cookiecutter.project_name }}")
# APPLYING THE ROUTES
namespace.add_resource(HelloWorldApiView,
'/api/v1/hello/',
endpoint='hello-world')
from server.bo.Customer import Customer
from server.bo.Account import Account
from server.bo.Transaction import Transaction
from SecurityDecorator import secured
app = Flask(__name__)
""" CORS muss hier definiert werden und der Präfix unsere Ressourcen auch
CORS(app, resources=r'/bank/*')
"""
"""Modell aufbauen, das die Datenstruktur beschreibt,
auf deren Basis Clients und Server Daten austauschen. Grundlage hierfür ist das Package flask-restx."""
api = Api(app, version='1.0', title='HOLMA API',
description='Eine rudimentäre Demo-API für Listenerstellung.')
"""Namespaces"""
Listingapp = api.namespace('app', description="Funktionen der App")
"""Unsere BOs werden hier nach und nach definiert,
zu den methoden (api.model/api.inherit) findet man mehr auf der Flask Seite unter Response marshalling
https://flask-restplus.readthedocs.io/en/stable/marshalling.html?highlight=nested#nested-field """
bo = api.model('BusinessObject', {
'name': fields.String(attribute='_name', description='Name eines Objekts'),
'id': fields.Integer(attribute='_id', description='Der Unique Identifier eines Business Object'),
'creation_date' : fields.Integer(attribute='_creation_date',
description='Erstellungsdatum des BOs, wird durch Unix Time Stamp ermittlet')
})
"""mit attribute='' wird gerenamed"""
group = api.inherit('Group', bo, {
'owner_id': fields.Integer(attribute='_owner', description='Unique Id des Kontoinhabers'),
from dotenv import load_dotenv, find_dotenv
from waitress import serve
import os
app = Flask(__name__)
app.wsgi_app = ProxyFix(app.wsgi_app)
api = Api(
app,
version='1.0',
title='Temperature Guesser',
description=
'A simple temperature guesser application which uses watson machine learning service',
)
ns = api.namespace('temp', description='Temperature operations')
temp = api.model(
'Temp', {
'id':
fields.Integer(readonly=True,
description='The tempearture unique identifier'),
'time':
fields.Integer(required=True, description='Request time'),
'humidity':
fields.Integer(required=True, description='Request time'),
'value':
fields.Float(required=True, description='The temperature')
})
from mintersdk.shortcuts import to_pip, to_bip
from werkzeug.datastructures import FileStorage
from api.logic.core import generate_and_save_wallet
from api.models import RewardCampaign, RewardIcon
from api.upload import images
from config import YOUTUBE_APIKEY, YYY_PUSH_URL
from helpers.misc import uuid
from minter.helpers import TxDeeplink, find_gas_coin
from minter.tx import estimate_custom_fee, send_coin_tx
from providers.minter import get_first_transaction
from providers.nodeapi import NodeAPI
bp_rewards = Blueprint('rewards', __name__, url_prefix='/api/rewards')
api = Api(bp_rewards, title="Rewards API", description="YYY Rewards API")
ns_campaign = api.namespace('campaign', description='Campaign operations')
ns_action = api.namespace('action', description='User actions')
action_mdl = ns_campaign.model(
'Action', {
'type':
fields.String(enum=[
'youtube-subscribe', 'youtube-comment', 'youtube-like',
'youtube-watch'
]),
'reward':
fields.Float,
'link':
fields.String,
})
parser_campaign_create = reqparse.RequestParser(trim=True, bundle_errors=True)
from indra.ontology.bio import bio_ontology
from indra.pipeline import AssemblyPipeline, pipeline_functions
from indra.preassembler.custom_preassembly import *
logger = logging.getLogger('rest_api')
logger.setLevel(logging.DEBUG)
# Create Flask app, api, namespaces, and models
app = Flask(__name__)
api = Api(app,
title='INDRA REST API',
description='REST API for INDRA webservice')
CORS(app)
preassembly_ns = api.namespace('Preassembly',
'Preassemble INDRA Statements',
path='/preassembly/')
sources_ns = api.namespace('Sources',
'Get INDRA Statements from various sources',
path='/')
assemblers_ns = api.namespace('Assemblers',
'Assemble INDRA Statements into models',
path='/assemblers/')
ndex_ns = api.namespace('NDEx', 'Use NDEx service', path='/')
indra_db_rest_ns = api.namespace('INDRA DB REST',
'Use INDRA DB REST API',
path='/indra_db_rest/')
databases_ns = api.namespace('Databases',
'Access external databases',
path='/databases/')
"host": "c5abe484-83a8-407e-92f8-b3be0f8f0afe-bluemix.cloudantnosqldb.appdomain.cloud",
"iam_apikey_description": "Auto-generated for key 1547206e-bf1b-466e-b797-7afabfc9b29e",
"iam_apikey_name": "apiaccess",
"iam_role_crn": "crn:v1:bluemix:public:iam::::serviceRole:Manager",
"iam_serviceid_crn": "crn:v1:bluemix:public:iam-identity::a/4a35fbbd385a17dc3178b6dc66949178::serviceid:ServiceId-c6da6f0d-c24c-4d28-b15e-ea426501b8d1",
"url": "https://c5abe484-83a8-407e-92f8-b3be0f8f0afe-bluemix.cloudantnosqldb.appdomain.cloud",
"username": "******"
}
client = Cloudant.iam(
api_access['username'],
api_access['apikey'],
connect=True
)
product_ns = api.namespace('product', description='User CIR Product Operations')
#Define the API models we will use (these will show up in the Swagger Specification)
rating = api.model('Rating', {
'efficiency': fields.Integer(required=False, description='The efficiency-in-use rating (0-9, where 0 is best) of this item'),
'energy': fields.Float(required=False, description='The energy (J) to produce this item'),
'CO2': fields.Float(required=False, description='The CO2 released (Kg) to produce this item'),
'otherGG': fields.Float(required=False, description='The other green house gases released (Kg) to produce this item'),
'water': fields.Float(required=False, description='The volume of water (litres) to produce this item'),
'plastic': fields.Float(required=False, description='The amout of plastic (Kg) included in this item'),
'lifetime': fields.Float(required=False, description='The expected lifetime (years) of this item'),
'recyclability': fields.Integer(required=False, description='The recyclability rating (0-9, where 0 is best) of this item'),
'repairability': fields.Integer(required=False, description='The Right to Repair rating (0-9, where 0 is best) of this item')
})
from durable.lang import statechart, state, when_all, to, m, post, assert_fact
from flask_restx import Api, fields, Resource
from flask import Flask
app = Flask(__name__)
api = Api(app, version='1.0', title='Data API', description='A simple Data Storing API', )
lw = api.namespace('Fee by location', description='CRUD operations')
location_wise_info = api.model('location_wise', {'location': fields.String("Location Name")})
with statechart('data'):
with state('info'):
with state('PILANI'):
@to('process')
@when_all(m.location == 'PILANI')
def pilani_schools(c):
global fees
fees = {"BIRLA SCHOOL": 30000,
"GOYAL SCHOOL": 22000,
"RK ACADEMY": 24000
}
print(fees)
@lw.route('/')
class LocationWise(Resource):
@lw.expect(location_wise_info)
def post(self):
assert_fact('data', api.payload)
return 'fees: ' + str(fees)
required=True,
help="YAML file",
)
wireviz_blueprint = Blueprint("wireviz-web", __name__)
api = Api(
app=wireviz_blueprint,
version=__version__,
title="WireViz-Web",
description="A wrapper around WireViz for bringing it to the web. "
"Easily document cables and wiring harnesses.",
doc="/doc",
catch_all_404s=True,
)
ns = api.namespace("", description="WireViz-Web REST API")
@ns.route("/render")
class RenderRegular(Resource):
@api.expect(file_upload)
@ns.produces(["image/png", "image/svg+xml"])
def post(self) -> Response:
"""
Receive a "multipart/form-data" file upload request with filename "yml_file".
The "Accept" request header will determine the response image type.
Examples
========
::
from marshmallow import Schema, fields as FM
from sqlalchemy import (Text
) # you can add another table column type if you need
from flask_migrate import Migrate
# THIS CODE IS DERIVATED FROM THE EXAMPLE OF Flask-RESTX EXTENSION
app = Flask(__name__)
api = Api(
app,
version='1.0',
title='TodoMVC API',
description='A simple TodoMVC API with Flask and SQLAlchemy',
)
ns = api.namespace('todos', description='TODO operations')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///database.sqlite3'
db = SQLAlchemy(app)
todo = api.model(
'Todo', {
'id':
fields.Integer(readOnly=True,
description='The task unique identifier'),
'task':
fields.String(required=True, description='The task details')
})
class TodoDAO(db.Model):
from flask import Flask, Response
from flask_restx import Api, fields, Resource
from rbac_type2.rbac_build.__init__ import has_permissions, has_roles, get_current_user
from rbac_type2.rbac_build.model_example import UserMixin, RoleMixin
app = Flask(__name__)
api = Api(app, version='1.0', title='Rbac', description='RBAC POC')
ns = api.namespace('rbac', description="role based access control")
data = api.model('rbac_info', {'user_id': fields.String('user_id')})
class Role(RoleMixin):
def __repr__(self):
return 'Role:{} Permission:{}'.format(self.name, self.perm)
class User(UserMixin):
def __repr__(self):
return '{}'.format(self.roles)
Manager = Role(name='Manager', perm=['Read', 'Write'])
Employee = Role(name='Employee', perm=['Read'])
Client = Role(name='Client', perm=['Read'])
#Employee.add_parent(Manager)
vipin = User(roles=[Manager])
from server.bo.ListEntry import ListEntry
from server.bo.Retailer import Retailer
from server.bo.Article import Article
from server.db.ArticleMapper import ArticleMapper
from server.bo.ShoppingList import ShoppingList
from server.bo.FavoriteArticle import FavoriteArticle
from server.db.FavoriteArticleMapper import FavoriteArticleMapper
import json
app = Flask(__name__)
CORS(app, resources=r'/shopping/*', supports_credentials=True)
api = Api(app)
"""
Namespaces:
"""
shopping_v1 = api.namespace('shopping', description='iKaufa App V1')
testing = api.namespace('testing', description='Namespace for testing')
"""
Transferable structure:
"""
bo = api.model(
'BusinessObject', {
'id': fields.Integer(attribute='_id', description="unique bo id"),
})
"""
Business Objects: Group, ListEntry, user, retailer, report, article, shoppinglist and favourite articles
"""
group = api.inherit(
'Group', bo, {
'name':
fields.String(attribute='name', description="A groups name"),
from flask import Flask, jsonify, make_response, request
from flask_restx import Api, Resource, fields
from pandas import DataFrame
from app.src.predict import Predict
from app.utils.enumerations import Directory
app = Flask(__name__)
api = Api(app=app, version="1.0", title="Iris Classifier", description="Predict iris type based on data")
name_space = api.namespace("predict", description="Predict Iris type.")
model = api.model("Prediction params",
{"sepal_length": fields.List(fields.Float, required=True,
description="Sepal Length"),
"sepal_width": fields.List(fields.Float, required=True,
description="Sepal Width"),
"petal_length": fields.List(fields.Float, required=True,
description="Petal Length"),
"petal_width": fields.List(fields.Float, required=True,
description="Petal Width")})
@name_space.route("/")
class PredictIris(Resource):
@staticmethod
@name_space.doc(responses={200: "Prediction successful",
400: "Invalid prediction parameters",
500: "Prediction failed"})
@name_space.expect(model)
from flask import Blueprint
from flask_restx import Api
api_v2 = Blueprint('api_v2', __name__)
api = Api(api_v2,
version='2.0',
title="TODOISM API",
description="My TODOISM API")
ns = api.namespace("", description="Item and Auth Operations")
from todoism.apis.v2 import auth, resources
#creating an instance of the devlopment configurations in our app
app.config.from_object(DevelopmentConfiguration)
#Instanciating my library imports to my app
db = SQLAlchemy(app)
ma = Marshmallow(app)
#instanciating my Api
api = Api(app, version="1.0", title="Agendas Api", description="Api to manage agendas")
#Namespacing - used to classify your routes endpoints
ns_users = api.namespace("user", description="Perform user operations")
ns_agenda = api.namespace("agenda", description="Perform agenda operations")
ns_login = api.namespace("login", description="Perform login operations")
#Api Models
user = api.model('users', {
"username": fields.String(required=True, description="The user's username"),
"email": fields.String(required=True, description="The user's email"),
"password": fields.String(required=True, desciption="the user's password")
})
agenda = api.model('agenda', {
"title": fields.String(required=True, description="The title of the agenda"),
"description": fields.String(required=True, description="The description for the agenda title")
})
import Const
import CSVHandler as csvh
import FuncUtils as fu
import QueryHandler as qh
import os
import argparse
import json
################# FLASK SERVER #################
app = Flask(__name__, root_path=Const.ROOT_PATH + Const.FLASK_ROOT_PATH)
#app = Flask(__name__, template_folder="web/templates", static_folder="web/static") #ONLY FOR LOCAL USE
api = Api(app)
ns = api.namespace('', description='APIs to communicate with server')
csv_parser = api.parser()
csv_parser.add_argument(Const.FILE, type=file, location=Const.FILE)
query_parser = api.parser()
query_parser.add_argument(Const.ID, type=str)
query_parser.add_argument(Const.FILE, type=str)
query_parser.add_argument(Const.EPSILON, type=float)
query_parser.add_argument(Const.QUERY, type=str)
@app.route('/' + Const.INDEX, methods=['GET'])
def index():
return render_template(Const.INDEX + '.html')
app = Flask(__name__)
app.config.SWAGGER_UI_DOC_EXPANSION = "list"
app.config.SWAGGER_UI_OPERATION_ID = True
app.config.SWAGGER_UI_REQUEST_DURATION = True
api = Api(app,
version="1.0",
title="Simple API",
description="My Simple API, returning XML or JSON.",
prefix="/v1",
contact_email="root@localhost",
contact="root@localhost",
contact_url="http://localhost")
ns = api.namespace("hello", description="hello namespace")
@ns.route("/")
class HelloWorld(Resource):
@ns.produces(["application/json", "application/xml"])
def get(self):
if request.headers.get("Accept", None) == "application/xml":
return {"hello": "xml"}
else:
return {"hello": "json"}
if __name__ == "__main__":
app.run(debug=False)
from flask import Flask
from flask_restx import Resource, Api
from random import choice
import json
app = Flask(__name__)
api = Api(app, version='0.1', title='GeoBDT Mock API',
description='Mock API para o GeoBDT',
)
ns = api.namespace('BDT', description='Endpoint para gerar o BDT')
def bdt_aleatorio():
with open('data/bdts_json.json') as f:
t = f.read()
return choice(json.loads(t))
@ns.route('/geoBdt')
class GeoBdt(Resource):
def post(self):
return bdt_aleatorio()
def get(self):
return bdt_aleatorio()
if __name__ == '__main__':
# Opening libraries
from flask_restx import Api, Resource, reqparse
from requests.api import request
from werkzeug.middleware.proxy_fix import ProxyFix
from config import app, CRAWLER_CURR
from util import Currency_UPD, CoreMan
# Creating api
app.wsgi_app = ProxyFix(app.wsgi_app)
api = Api(app,
title='Currency-Crawler-API',
version='0.0.1 alpha',
description='Backend to craw for currency, store data and request')
# Namespaces (just to order)
ns1 = api.namespace('Crawler', description='Crawler Operation')
ns2 = api.namespace('Data', description='Data operations')
ns3 = api.namespace('Core', description='TheCore data handler')
# Parser objects
query_data_parser = reqparse.RequestParser()
query_data_parser.add_argument('currency', help = 'Currency Request', location = 'query', \
choices = CRAWLER_CURR, required = True)
core_store = reqparse.RequestParser()
core_store.add_argument('Temp',
help='Core Temp',
location='form',
required=True)
core_store.add_argument('Humidity',
help='Core Humidity',
"""
In dem folgenden Abschnitt bauen wir ein Modell auf, das die Datenstruktur beschreibt,
auf deren Basis Clients und Server Daten austauschen. Grundlage hierfür ist das Package flask-restx.
"""
api = Api(app, version='1.0', title='BankBeispiel API',
description='Eine rudimentäre Demo-API für doppelte Buchführung in Banken.')
"""Anlegen eines Namespace
Namespaces erlauben uns die Strukturierung von APIs. In diesem Fall fasst dieser Namespace alle
Bank-relevanten Operationen unter dem Präfix /bank zusammen. Eine alternative bzw. ergänzende Nutzung
von Namespace könnte etwa sein, unterschiedliche API-Version voneinander zu trennen, um etwa
Abwärtskompatibilität (vgl. Lehrveranstaltungen zu Software Engineering) zu gewährleisten. Dies ließe
sich z.B. umsetzen durch /bank/v1, /bank/v2 usw."""
banking = api.namespace('bank', description='Funktionen des BankBeispiels')
"""Nachfolgend werden analog zu unseren BusinessObject-Klassen transferierbare Strukturen angelegt.
BusinessObject dient als Basisklasse, auf der die weiteren Strukturen Customer, Account und Transaction aufsetzen."""
bo = api.model('BusinessObject', {
'id': fields.Integer(attribute='_id', description='Der Unique Identifier eines Business Object'),
})
"""Users, Customers, Accounts & Transactions sind BusinessObjects..."""
user = api.inherit('User', bo, {
'name': fields.String(attribute='_name', description='Name eines Benutzers'),
'email': fields.String(attribute='_email', description='E-Mail-Adresse eines Benutzers'),
'user_id': fields.String(attribute='_user_id', description='Google User ID eines Benutzers')
})
)
model = api.model(
"Auth",
{
"username":
fields.String(required=True, description="Nome de usuário."),
"password":
fields.String(
required=True,
description="Senha de acesso do usuário.",
),
},
)
namespace = api.namespace("auth")
parser = namespace.parser()
parser.add_argument("Authorization",
location="headers",
required=True,
help="Bearer <JWT>")
class UserRegisterAPI(Resource):
"""
Realiza o cadastro do usuário no banco.
"""
@api.doc(
responses={
201: "User registered",
202: "User already exists.",
from flask_restx import Api, Resource
from flask_cors import CORS
api_resources = Blueprint("api_resources", __name__)
CORS(api_resources)
authorizations = {
'apikey': {
'type': 'apiKey',
'in': 'header',
'name': 'Authorization'
}
}
api_call = Api(title="AUDIO FILE SERVER API DOC",
doc="/doc",
description="This was written by Ewanfo Lucky Peter",
authorizations=authorizations,
security='apikey')
api_call.init_app(api_resources)
#########################################
#AUDIO API NAMESPACE#####
#########################################
audio_file_api_call = api_call.namespace("Audio File Endpoints", path="/")
from app.views import audio_api_resources, errors
from flask import Flask, request
from flask_restx import Api, Resource, fields
flask_app = Flask(__name__)
app = Api(app = flask_app,
version = "1.0",
title = "Name Recorder",
description = "Manage names of various users of hte application")
name_space = app.namespace('names', description='Manage names')
model = app.model('Name Model',
{'name': fields.String(required = True,
description="Name of the person",
help="Name cannot be blank.")})
list_of_names = {}
@name_space.route("/")
class MainClass(Resource):
def get(self):
return {
"status": "Got new data"
}
def post(self):
return {
"status": "Posted new data"
}
@name_space.route("/<int:id>")
class MainClass(Resource):
######################
# API
# See SRS: S.7.R.3.D.1
######################
api = Api(
APP,
version="0.0.0",
title="AutoTrade API",
doc="/api",
description="Official API for AutoTrade",
)
trading_sessions_ns = api.namespace("trades_sessions",
description="trading session operations")
TRADING_SESSION = api.model(
"trading_sessions",
{
"session_id":
fields.Integer(required=False,
description="id of the trading session"),
"ticker":
fields.String(required=True, description="name of the stock"),
"is_paused":
fields.Boolean(default=False),
"is_finished":
fields.Boolean(default=False),
"start_time":
fields.DateTime(),
def create_app(i2cbus=I2CBusIo()):
attach_exit_handler(i2cbus)
config_logging()
logging_application_banner()
app = Flask(__name__, static_folder='./static')
CORS(app)
api = Api(
app,
version='1.0',
title='I2C Microserverice',
description='A description of a microserverice',
)
device_ns = api.namespace('api/device',
description='I2C Device operations')
i2c_session_provider = I2CSessionProvider(i2cbus)
device_bus = AtlasScientificDeviceBus(i2c_session_provider)
models = device_ns.add_device_models()
device_ns.add_device_errors()
@app.before_request
def log_request_info():
app.logger.debug('\n[%s] %s\nBody:\n%s', request.method, request.path,
request.get_data())
@app.route('/<path:path>', methods=['GET'])
def static_proxy(path):
return send_from_directory(app.static_folder, path)
@app.route('/', methods=['GET'])
def redirect_to_index():
return send_from_directory(app.static_folder, 'index.html')
@device_ns.route('/')
class DeviceList(Resource):
@device_ns.marshal_list_with(models.device_info)
def get(self):
device_bus.get_known_devices()
i2c_devices = []
for device in device_bus.get_known_devices():
device_info = device.get_device_info()
i2c_devices.append({
'device_type': device_info.device_type,
'firmware_version': device_info.version,
'address': device_info.address,
'vendor': device_info.vendor,
})
return i2c_devices
@device_ns.route('/<int:address>/sample')
@device_ns.doc(params={'address': 'An I2C Address of a device'})
class DeviceSample(Resource):
@device_ns.marshal_list_with(models.device_sample)
def get(self, address):
device = device_bus.get_device_by_address(address)
return device.read_sample([]), 200
@device_ns.marshal_list_with(models.device_sample)
@device_ns.expect(models.device_sample_compensation)
def post(self, address):
device = device_bus.get_device_by_address(address)
compensation_factors = models.device_compensation_factors_schema.load_request(
request)
return device.read_sample(compensation_factors), 200
@device_ns.route('/<int:address>/sample/output')
class DeviceSampleOutput(Resource):
@device_ns.marshal_list_with(models.device_sample_output)
def get(self, address):
device = device_bus.get_device_by_address(address)
supported_outputs = device.get_supported_output_measurements()
enabled_outputs = set(
m.unit_code for m in device.get_enabled_output_measurements())
sample_outputs = []
for sample_output in supported_outputs:
sample_outputs.append({
'symbol': sample_output.symbol,
'unit': sample_output.unit,
'value_type': sample_output.value_type,
'is_enable': sample_output.unit_code in enabled_outputs,
'unit_code': sample_output.unit_code
})
return sample_outputs
@device_ns.expect(models.set_device_sample_outputs)
def post(self, address):
device = device_bus.get_device_by_address(address)
device.set_enabled_output_measurements(request.json)
return '', 200
@device_ns.route('/<int:address>/sample/compensation')
class DeviceSampleCompensation(Resource):
@device_ns.expect(models.device_sample_compensation)
def post(self, address):
compensation_factors = models.device_compensation_factors_schema.load_request(
request)
device = device_bus.get_device_by_address(address)
device.set_measurement_compensation_factors(compensation_factors)
return '', 200
@device_ns.route('/<int:address>/sample/calibration')
class DeviceSampleCalibration(Resource):
@device_ns.expect(models.device_sample_calibration)
def put(self, address):
calibration_point = models.device_calibration_point_schema.load_request(
request)
device = device_bus.get_device_by_address(address)
device.set_calibration_point(calibration_point)
return '', 200
@device_ns.route('/<int:address>/configuration')
class DeviceConfiguration(Resource):
@device_ns.expect(models.device_configuration_parameter)
def post(self, address):
configuration_parameter = models.device_configuration_parameter_schema.load_request(
request)
device = device_bus.get_device_by_address(address)
device.set_configuration_parameter(configuration_parameter)
return '', 200
return app
the_scanner: scanner_device.Scanner
exif_tag_func: Callable[
[pathlib.Path, MetaData, Callable[[pathlib.Path], None]], None]
# Web server
app = Flask(__name__)
socketio = SocketIO(app)
# REST API
api = Api(app,
version='1.0',
title='RoboScan API',
description='RoboScan API',
doc="/doc/",
base_url='/')
ns = api.namespace('scanner', description='Scanner API')
file_details = api.model(
'File',
{'name': fields.String(required=True, description='The file name')})
file_operation_result = api.model(
'FileOperationResult', {
'count':
fields.Integer(required=True,
description='The number of files modified'),
})
status_model = api.model('Status', {
'success':
fields.Boolean(description="True if the operation is succesful"),
from flask import Flask, request, Response
from flask_restx import Api, Resource, fields
import pandas as pd
from Transform import Transform
from Dbase import Dbase
import sqlite3
from flask import jsonify
from flask_cors import CORS
import os
app = Flask(__name__)
api = Api(app, title='Case Itaú API', description='Kaique Pedronio Novi')
api = api.namespace('', description='Operações Residencias e Média de preços')
@api.route('/residencias')
class GetResidencias(Resource):
@api.param('neighbourhood_group')
def get(self):
conn = sqlite3.connect('CaseItau.sqlite3')
cursor = conn.cursor()
neighbourhood_group = request.args.get('neighbourhood_group')
df = pd.read_sql_query(
"SELECT * FROM residencias WHERE neighbourhood_group =?",
conn,
params=[neighbourhood_group])
conn.commit()
conn.close()
oauth.register(
name="github",
client_id="f6bb4947b9ea704db22c",
client_secret="13cf0ab911a187d56e23e3fb1d86660432d6e589",
access_token_url="https://github.com/login/oauth/access_token",
access_token_params=None,
authorize_url="https://github.com/login/oauth/authorize",
authorize_params=None,
api_base_url="http://api.github.com/",
client_kwargs={"scope": "user:email"},
)
s = URLSafeTimedSerializer(app.secret_key)
ns = api.namespace("todos", description="TODO operations")
# https://stackoverflow.com/questions/49226806/python-check-for-a-valid-email
def is_valid_email(email):
if len(email) > 7:
return bool(
re.match("^.+@(\[?)[a-zA-Z0-9-.]+.([a-zA-Z]{2,3}|[0-9]{1,3})(]?)$",
email))
@jwt.user_claims_loader
def add_claims_to_access_token(identity):
return identity
from flask_jwt_extended import JWTManager
from flask_jwt_extended import (create_access_token, create_refresh_token,
jwt_required, jwt_refresh_token_required,
get_jwt_identity, get_raw_jwt)
from datetime import timedelta
import random
app = Flask(__name__)
app.secret_key = 'mysupersecretkey'
api = Api(
app,
version='1.0',
title='My API Boilerplate',
description='My API Boilerplate',
)
ns = api.namespace('api/v1', description='Example.')
app.config['JWT_SECRET_KEY'] = 'jwt-secret-string'
app.config['JWT_TOKEN_LOCATION'] = 'headers'
app.config['JWT_HEADER_NAME'] = 'X-Example-access-token'
app.config['JWT_HEADER_TYPE'] = ''
app.config['JWT_ACCESS_TOKEN_EXPIRES'] = timedelta(minutes=15)
app.config['JWT_REFRESH_TOKEN_EXPIRES'] = timedelta(minutes=15)
app.config['JWT_BLACKLIST_ENABLED'] = True
app.config['JWT_BLACKLIST_TOKEN_CHECKS'] = ['access', 'refresh']
jwt = JWTManager(app)
blacklist = set()
devices = {
'routers': {
language = mafields.String()
framework = mafields.String()
@post_load
def create_language(self, data, **kwargs):
return Language(**data)
"""
###############################################################################
api = Api(
app,
version='1.0',
title='Data API',
description='A simple Data Storing API',
)
ns = api.namespace('language', description='CRUD operations')
a_language = api.model(
'Language', {
'id': fields.Integer("user_id"),
'language': fields.String("the language."),
'framework': fields.String("The framework")
})
languages = []
# python = {'language': 'python', 'id': 1}
python = TheLanguage(id=1, language='python', framework='Flask')
checkpoint = True
if not checkpoint:
languages.append(python)
db.session.add(python)
db.session.commit()
class OxfsApi(object):
def __init__(self, oxfs_fuse):
self.oxfs_fuse = oxfs_fuse
def cleanf(self, path):
'''clear the file attributes cache, file cache.'''
self.oxfs_fuse.attributes.remove(path)
cachefile = self.oxfs_fuse.cachefile(path)
if os.path.exists(cachefile):
os.unlink(cachefile)
return True
def cleand(self, path):
'''clear the directories cache, 1st level file cache.'''
entries = self.oxfs_fuse.directories.fetch(path)
if entries:
self.oxfs_fuse.directories.remove(path)
for name in entries:
self.cleanf(os.path.join(path, name))
return True
def clear(self):
'''clear all attributes, directories cache.'''
self.oxfs_fuse.attributes.cache.clear()
self.oxfs_fuse.directories.cache.clear()
shutil.rmtree(self.oxfs_fuse.cache_path)
os.makedirs(self.oxfs_fuse.cache_path)
return True
def fetchd(self, path):
return True, json.dumps(self.oxfs_fuse.directories.fetch(path))
def run(self, port):
self.thread = threading.Thread(target=self.start_service,
args=(port, ))
self.thread.daemon = True
self.thread.name = 'apiserver'
self.thread.start()
def set_flask_env(self):
name = 'FLASK_ENV'
if name not in os.environ:
os.environ[name] = 'development'
def start_service(self, port):
apiserver = self
self.app = Flask(__name__)
self.app.wsgi_app = ProxyFix(self.app.wsgi_app)
self.api = Api(self.app,
version='1.0',
title='Oxfs Api',
description='The Oxfs Api')
# Response model
fs_namespace = self.api.namespace('fs', description='fs operations')
status_model = self.api.model('Status', {
'status': fields.Boolean,
'data': fields.String
})
# Request arguments
string_args = self.api.parser()
string_args.add_argument('path', required=True, help='absolute path')
# Api
@fs_namespace.route('/reload')
@fs_namespace.expect(string_args)
class Reload(Resource):
@fs_namespace.marshal_with(status_model, envelope='data')
def post(self):
args = string_args.parse_args()
path = apiserver.oxfs_fuse.remotepath(args['path'])
status = (apiserver.cleanf(path), apiserver.cleand(path))
return {'status': False not in status, 'data': path}
@fs_namespace.route('/clear')
class Clear(Resource):
@fs_namespace.marshal_with(status_model, envelope='data')
def delete(self):
status = apiserver.clear()
return {'status': True, 'data': 'success'}
@fs_namespace.route('/directories')
@fs_namespace.expect(string_args)
class Directories(Resource):
@fs_namespace.marshal_with(status_model, envelope='data')
def get(self):
args = string_args.parse_args()
path = apiserver.oxfs_fuse.remotepath(args['path'])
status, data = apiserver.fetchd(path)
return {'status': status, 'data': data}
self.set_flask_env()
self.app.run(port=port, debug=False)
