def app():
app = flask.Flask("nandy-io-speech-api")
app.mysql = mysql.MySQL()
app.redis = redis.StrictRedis(host=os.environ['REDIS_HOST'], port=int(os.environ['REDIS_PORT']))
app.channel = os.environ['REDIS_CHANNEL']
if os.path.exists("/var/run/secrets/kubernetes.io/serviceaccount/token"):
app.kube = pykube.HTTPClient(pykube.KubeConfig.from_service_account())
else:
app.kube = pykube.HTTPClient(pykube.KubeConfig.from_url("http://host.docker.internal:7580"))
api = flask_restful.Api(app)
api.add_resource(Health, '/health')
api.add_resource(PersonCL, '/person')
api.add_resource(PersonRUD, '/person/<int:id>')
api.add_resource(TemplateCL, '/template')
api.add_resource(TemplateRUD, '/template/<int:id>')
api.add_resource(AreaCL, '/area')
api.add_resource(AreaRUD, '/area/<int:id>')
api.add_resource(AreaA, '/area/<int:id>/<action>')
api.add_resource(ActCL, '/act')
api.add_resource(ActRUD, '/act/<int:id>')
api.add_resource(ActA, '/act/<int:id>/<action>')
api.add_resource(ToDoCL, '/todo')
api.add_resource(ToDoRUD, '/todo/<int:id>')
api.add_resource(ToDoA, '/todo/<int:id>/<action>')
api.add_resource(RoutineCL, '/routine')
api.add_resource(RoutineRUD, '/routine/<int:id>')
api.add_resource(RoutineA, '/routine/<int:id>/<action>')
api.add_resource(TaskA, '/routine/<int:routine_id>/task/<int:task_id>/<action>')
return app
import requests
from flask import jsonify
import flask_restful
from project import app
from project.restfulapi import blueprints
from project.restfulapi.session.simple.flask_session import Login
api = flask_restful.Api(blueprints[__name__], prefix="/session/oauth/google")
@api.route('/login')
class OAuth_Google_Login(Login):
def check_values(self, request_values):
if 'id_token' in request_values:
return True, ''
else:
message = 'You need to add an id_token as a parameter. For example, ?id_token=XYZ123'
return False, message
def validate(self, request_values):
id_token = request_values.get('id_token')
google_url = app.config.get('GOOGLE_URL')
path = 'tokeninfo'
url = '/'.join(s.strip('/') for s in [google_url, path])
params = { 'id_token': id_token }
r = requests.get(url=url, params=params).json()
if 'error_description' in r:
# Token not valid
return False
elif r['aud'] == app.config.get('GOOGLE_CLIENT_ID'):
import flask
import flask_restful
import utils.predict
from routes import index, stat
app = flask.Flask(__name__)
api = flask_restful.Api(app, catch_all_404s=True)
api.add_resource(index.Index, '/')
api.add_resource(stat.StatAPI, '/stat/<string:symbol>')
if __name__ == '__main__':
app.run()
def test_api_prefix(self):
app = Mock()
app.configure_mock(**{'record.side_effect': AttributeError})
api = flask_restful.Api(app, prefix='/foo')
self.assertEquals(api.prefix, '/foo')
import http
from datetime import datetime
import flask
import flask_restful
from flask_restful import Resource
from webresultserver.database import db
from webresultserver.models.item import TestItem, ItemState
from webresultserver.models.pytest_session import PytestSession
api_blueprint = flask.Blueprint('api', __name__)
api = flask_restful.Api(api_blueprint)
class AddPytestSession(flask_restful.Resource):
@staticmethod
def post():
new_pytest_session = PytestSession(start_time=datetime.now())
db.session.add(new_pytest_session)
db.session.commit()
return new_pytest_session.id
class AddTestItem(flask_restful.Resource):
@classmethod
def post(cls, session_id, nodeid):
cls._ensure_item_not_exist(nodeid, session_id)
new_test_item = TestItem(session_id=session_id,
nodeid=nodeid,
state=ItemState.DID_NOT_START)
from flask import Blueprint import flask_restful as restful from . import authrntication, posts, users, comments, errors api = restful.Api(prefix='/api/v1') # api.add_resource(users.UserInfoResource, '/user') api.add_resource(users.RegistResource, "/regist/") api.add_resource(users.SessionResource, "/login/") api.add_resource(posts.PostResource, "/post/") api.add_resource(posts.CommentResource, "/comment/") # api.add_resource(posts.ArticleResource, "/article/<pid>")
import flask_marshmallow
import flask_restful
import importlib
import lime_endpoints
import lime_endpoints.endpoints
import logging
import pkgutil
URL_PREFIX = '/lime-mud'
logger = logging.getLogger(__name__)
bp = lime_endpoints.endpoints.create_blueprint('lime_mud',
__name__,
URL_PREFIX,
static_folder='static')
api = flask_restful.Api(bp)
ma = flask_marshmallow.Marshmallow(bp)
def register_blueprint(app, config=None):
for loader, module_name, is_pkg in pkgutil.walk_packages(__path__):
if module_name.endswith('_test'):
continue
module_fullname = '{}.{}'.format(__name__, module_name)
logger.info('Loading {}'.format(module_fullname))
importlib.import_module(module_fullname)
app.register_blueprint(bp)
return bp
import flask_restful
from project import blueprints
api = flask_restful.Api(blueprints[__name__], prefix="/blueprint")
@api.route('/helloworld')
class HelloWorld(flask_restful.Resource):
def get(self):
return {'hello': 'world'}
"""a mock predictor service for the jiminy project"""
import flask
import flask_restful as flaskr
import jsonschema as js
app = flask.Flask(__name__)
api = flaskr.Api(app)
ratings_store = {}
rankings_store = {}
class ServerInfo(flaskr.Resource):
def get(self):
return {
'application': {
'name': 'jiminy-mock-predictor',
'version': '0.0.0'
}
}
rating_request_schema = {
"type": "object",
"properties": {
"user": {
"type": "string"
},
"products": {
"type": "array",
"minItems": 1,
"""The main driver and entrypoint for the Wayfare API.""" import argparse import flask_restful import flask_sqlalchemy from flask import Flask DB_URI = 'sqlite:///./main.db' app = Flask(__name__) # pylint: disable=C0103 app.config['SQLALCHEMY_DATABASE_URI'] = DB_URI db = flask_sqlalchemy.SQLAlchemy(app) # pylint: disable=C0103 # These imports are here to prevent errors from missing circular imports from wayfare.models import Location # pylint: disable=C0413 from wayfare.models import Status # pylint: disable=C0413 from wayfare.models import TimeRange # pylint: disable=C0413 from wayfare.models import User # pylint: disable=C0413 from wayfare.models import Ride # pylint: disable=C0413 from wayfare.models import Passenger # pylint: disable=C0413 # Necessary for sqlite db.drop_all() db.create_all() api = flask_restful.Api(app, catch_all_404s=True) # pylint: disable=C0103
# Import flask dependencies
from flask import Flask, Blueprint, request
import flask_restful
API_VERSION_V1 = 1
API_VERSION = API_VERSION_V1
API_URL_PREFIX = '/api/cisco-automation'
# Define the blueprint
cisco_automation = Blueprint('cisco_automation', __name__)
# Define RESTful API for routing
api_cisco_automation = flask_restful.Api(app=cisco_automation,
prefix=API_URL_PREFIX)
class BuildingList(flask_restful.Resource):
def post(self):
# No args - for now info will be from folder or hard coded in code, since info might be from
# API or Database
return {"test-3": "test-3"}
class FloorList(flask_restful.Resource):
def post(self):
# TODO: parse args - Building ID
return {"test-2": "test-2"}
import sklearn.linear_model as skl
# modules in the py folder:
import core.pgdb as pgdb
import core.sktkr as sktkr
import core.kerastkr as kerastkr
# I should connect to the DB
db_s = 'postgres://*****:*****@127.0.0.1/tkrapi'
conn = sql.create_engine(db_s).connect()
homeDir = os.environ['HOME']
input = homeDir + '\\data\\input\\'
# I should ready flask_restful:
application = fl.Flask(__name__)
api = fr.Api(application)
# I should fill lists which users want frequently:
with open(input + 'years.txt') as fh:
years_l = fh.read().split()
with open(input + 'tkrlist.txt') as fh:
tkrlist_l = fh.read().split()
class Demo11(fr.Resource):
"""
This class should be a simple syntax demo.
"""
def get(self):
my_k_s = 'hello'
import flask_restful
from flask import Blueprint
from .resource import customer
api_bp = Blueprint('service_c', __name__)
api = flask_restful.Api(api_bp)
SERVICE_C_VERSION = 1
api.add_resource(customer.CustomerListResource, '/customer')
api.add_resource(customer.CustomerResource, '/customer/<tax_id>')
def setUp(self) -> None:
self._app = Flask(__name__)
self._api = flask_restful.Api(self._app)
# -*- coding: utf-8 -*-
from flask import Flask, Blueprint
import flask_restful
API_VERSION_V1_0 = 1.0
API_VERSION = API_VERSION_V1_0
api_v1_0_bp = Blueprint('api_v1_0', __name__)
api_v1_0 = flask_restful.Api(api_v1_0_bp)
class HelloWorld(flask_restful.Resource):
def get(self):
return {
'hello': 'world',
'version': API_VERSION,
}
api_v1_0.add_resource(HelloWorld, '/helloworld')
from radio.common.utils import EncodeError
from radio.common.utils import allowed_file_extension
from radio.common.utils import encode_file
from radio.common.utils import filter_default_webargs
from radio.common.utils import get_metadata
from radio.common.utils import get_song_or_abort
from radio.common.utils import insert_song
from radio.common.utils import make_api_response
from radio.common.utils import parser
from radio.common.utils import request_status
from radio.database import Queue
from radio.database import Song
from radio.database import User
blueprint = Blueprint("songs", __name__)
api = rest.Api(blueprint)
# TODO: break this file up
@db_session
def query_songs(query: Optional[str], user: Optional[User] = None) -> Query:
songs: Query
src = user.favourites if user else Song
if query:
query = query.lower()
songs = select(
s for s in src
if query in s.artist.lower() or query in s.title.lower())
else:
songs = src.select()
from flask import Blueprint
import flask_restful
from flask import Blueprint, request, jsonify
from core.lib.foundation.base_controller import BaseController
from core.lib.foundation import custom_logger
LOG = custom_logger.getLogger(__name__)
thoughworks_blueprint = Blueprint('thoughtwork',
__name__,
url_prefix='/api/v1.0/thoughtwork')
application_api = flask_restful.Api(thoughworks_blueprint)
#Order Controller
class FoodieController(BaseController):
def get(self):
from services.thoughtworks.restuarant_manager import FoodieManager
return FoodieManager().get_all_restuarants()
application_api.add_resource(FoodieController, '/foodie/')
class FoodieSearchController(BaseController):
def get(self, rest_name):
try:
from services.thoughtworks.restuarant_manager import FoodieManager
return FoodieManager().get_by_name(rest_name)
except Exception as ex:
from flask import Flask, Blueprint
import flask_restful
from marshmallow_jsonapi import Schema, fields
from marshmallow import validate
API_VERSION_V1 = 1
API_VERSION = API_VERSION_V1
example_api_v1_bp = Blueprint('api_v1', __name__)
example_api_v1 = flask_restful.Api(example_api_v1_bp)
class HelloWorldSchema(Schema):
id = fields.Str(dump_only=True)
hello = fields.String()
version = fields.Integer()
class Meta:
type_ = 'hello_world'
class HelloWorld(flask_restful.Resource):
def get(self):
api_info = dict(hello='world', version=API_VERSION)
schema = HelloWorldSchema()
result = schema.dump(api_info)
return result
example_api_v1.add_resource(HelloWorld, '/hello')
from tweetapi.resources.Registration import Registration
from tweetapi.resources.Tweet import Tweet
from tweetapi.resources.Comment import Comment, CommentTable
from tweetapi.resources.Image import Image
from tweetapi.resources.RelationshipAPI import RelationshipAPI
from tweetapi.resources.UserApi import UserApi
app = Flask(__name__)
app.config.from_pyfile('config.py')
db.init_app(app)
with app.app_context():
db.create_all()
api = restful.Api(app)
api.add_resource(Login, '/login')
api.add_resource(Logout, '/logout')
api.add_resource(Registration, '/registration')
api.add_resource(UserApi,
'/users/<int:user_id>')
api.add_resource(Tweet,
'/users/<int:user_id>/tweet', # POST, GET
'/users/<int:user_id>/tweet/<int:tweet_id>', # DELETE
'/users/<int:user_id>/friends/tweet', # GET
'/tweet/<int:tweet_id>', # GET
'/tweet') # GET
api.add_resource(Comment,
'/tweet/<int:tweet_id>/comment', # POST, GET
'/tweet/<int:tweet_id>/comment/<int:comment_id>', # DELETE
'/comment/<int:comment_id>',) # GET
from flask import Flask
import flask_restful
from flask_cors import CORS
from ManagerSystem.apis.AManager import MSManager
from ManagerSystem.apis.AStocks import MSStocks
from ManagerSystem.apis.AProducts import MSProduct
from ManagerSystem.apis.AOrder import MSOrder
from ManagerSystem.apis.ACotegory import MSCategory
from ManagerSystem.apis.MSApproval import MSApproval
from ManagerSystem.apis.AOther import AOther
from ManagerSystem.apis.ACoupons import MSCoupons
sg = Flask(__name__)
CORS(sg, resources=r'/*')
api = flask_restful.Api(sg)
# r'/*' 是通配符，让本服务器所有的URL 都允许跨域请求
api.add_resource(MSManager, "/sharp/manager/user/<string:manager>")
api.add_resource(MSStocks, "/sharp/manager/stock/<string:stock>")
api.add_resource(MSProduct, "/sharp/manager/product/<string:product>")
api.add_resource(MSOrder, "/sharp/manager/order/<string:order>")
api.add_resource(MSCategory, "/sharp/manager/category/<string:category>")
api.add_resource(MSApproval, "/sharp/manager/approval/<string:approval>")
api.add_resource(AOther, "/sharp/manager/other/<string:other>")
api.add_resource(MSCoupons, "/sharp/manager/card/<string:card>")
'''
if __name__ == '__main__':
sg.run('0.0.0.0', 443, debug=False, ssl_context=(
def __init__(self,name):
super(ConferenceApplication,self).__init__(name)
self.recognizer = DnnRecognizer.DnnRecognizer()
#self.recognizer = DlibRecognizer.DlibRecognizer()
application = ConferenceApplication(__name__)
application.debug = True
class RegexConverter(werkzeug.routing.BaseConverter):
def __init__(self, url_map, *items):
super(RegexConverter, self).__init__(url_map)
self.regex = items[0]
application.url_map.converters['regex'] = RegexConverter
api = rest.Api(application)
class FilesResource(rest.Resource):
def get(self,path,extension):
return flask.send_file("templates/" + path + "." + extension)
class ImageReceiver(rest.Resource):
def readImage():
if(flask.request.headers.get('content-type') == 'multipart/form-data'):
return flask.request.files['file'].read()
else:
print(flask.request.headers)
for key in flask.request.values.keys():
if(key.startswith('data:')):
########### BASE IMPORTS ###############################
from flask import Flask, Response
import base64
import flask_restful as restful
from flasgger import Swagger
######### ENVIRONMENT CONFIGS ###########################
from configs.readconfig import configp
app = Flask(__name__)
apy = restful.Api(app)
from controllers.single_message import WhatsAppSingleMessage
apy.add_resource(WhatsAppSingleMessage, '/api/v0.1/send_single_message')
from controllers.broadcast_message import WhatsAppBroadcastMessage
apy.add_resource(WhatsAppBroadcastMessage, '/api/v0.1/send_broadcast_message')
from controllers.listen_message import WhatsAppMessageListener
apy.add_resource(WhatsAppMessageListener, '/api/v0.1/listen_new_message')
from controllers.add_new_contact import WhatsAppNewContactListener
apy.add_resource(WhatsAppNewContactListener, '/api/v0.1/add_new_contact')
if __name__ == '__main__':
app.run(host='0.0.0.0', debug=True, port=5000, threaded=True)
#app.run(debug=True, threaded=True)
import flask
from flask import Flask, jsonify, request
from flask_restful import reqparse
from datetime import datetime
import flask_restful
import mariadb
import json
import uuid
app = Flask(__name__)
# app.config["DEBUG"] = True
api = flask_restful.Api(app)
config = {
'host': '127.0.0.1',
'port': 3306,
'user': '******',
'password': '******',
'database': 'mydb'
}
class Delivery(flask_restful.Resource):
def __init__(self):
self.conn = mariadb.connect(**config)
self.cursor = self.conn.cursor()
def get(self):
sql = '''select delivery_id, order_json, status, created_at
from delivery_status order by id desc'''
def test_api_base(self):
app = Mock()
api = flask_restful.Api(app)
self.assertEquals(api.urls, {})
self.assertEquals(api.prefix, '')
self.assertEquals(api.default_mediatype, 'application/json')
# -*- coding: utf-8 -*-
from __future__ import absolute_import
from flask import Blueprint
import flask_restful as restful
from .routes import routes
from .validators import security
@security.scopes_loader
def current_scopes():
return []
bp = Blueprint('v5', __name__, static_folder='static')
api = restful.Api(bp, catch_all_404s=True)
for route in routes:
api.add_resource(route.pop('resource'), *route.pop('urls'), **route)
def test_api_delayed_initialization(self):
app = Flask(__name__)
api = flask_restful.Api()
api.init_app(app)
api.add_resource(HelloWorld, '/', endpoint="hello")
def test_url_for(self):
app = Flask(__name__)
api = flask_restful.Api(app)
api.add_resource(HelloWorld, '/ids/<int:id>')
with app.test_request_context('/foo'):
self.assertEqual(api.url_for(HelloWorld, id=123), '/ids/123')
def test_api_prefix(self):
app = Mock()
api = flask_restful.Api(app, prefix='/foo')
self.assertEquals(api.prefix, '/foo')
# encoding: utf-8
import requests
import flask_restful as restful
external_route = "http://httpbin.org/get"
api = restful.Api()
class Hello(restful.Resource):
def get(self):
response = requests.get(external_route)
result = {
"data": None,
"success": False
}
status = response.status_code
if status == 200:
result["data"] = response.json()
result["success"] = True
return api.make_response(result, status)
import flask
import bcrypt
import flask_restful as rest
from pymongo import MongoClient
app = flask.Flask(__name__)
api = rest.Api(app)
# connect to mongodb and create database and corresponding collections
client = MongoClient("mongodb://db:27017")
db = client.SentencesDatabase
users = db['Users']
def user_match(username, password, method):
user = users.find({'Username': username})
if method == 'register':
if user.count() > 0:
return 303
else:
return 200
else:
if user.count() > 0:
if user[0]['Password'] == bcrypt.hashpw(password.encode('utf-8'), user[0]['Password']):
return 200
else:
return 301
else:
return 302
