import falcon
from signup import signup
from login import login
from activeprj import gPrj
from falcon.http_status import HTTPStatus
#gunicorn -b 0.0.0.0:5000 auth_signup:api --reload &
class HandleCORS(object):
def process_request(self, req, resp):
resp.set_header('Access-Control-Allow-Origin', '*')
resp.set_header('Access-Control-Allow-Methods', '*')
resp.set_header('Access-Control-Allow-Headers', '*')
resp.set_header('Access-Control-Max-Age', 1728000) # 20 days
if req.method == 'OPTIONS':
raise HTTPStatus(falcon.HTTP_200, body='\n')
#wsgi_app = api = falcon.API(middleware=[HandleCORS() ])
api = falcon.API(middleware=[HandleCORS()])
signup = signup()
login = login()
gprj = gPrj()
api.add_route('/api/v1/signup', signup)
api.add_route('/api/v1/login', login)
api.add_route('/api/v1/getAllProj', gprj)
def create_api(
cfg: attrdict.AttrDict,
schema: graphene.Schema,
scoped_session: sqlalchemy.orm.scoped_session,
logger_level: str,
):
"""Creates a Falcon API and adds resources for the GraphQL endpoint.
Args:
cfg (attrdict.Attrdict): The application configuration loaded with the
methods under the `config.py` module.
schema (graphene.Schema): An instance of the Graphene schema to expose
via the GraphQL endpoint.
scoped_session (sqlalchemy.orm.scoped_session): A SQLAlchemy
scoped-session that will be used to perform the interaction with
the SQL database.
logger_level (str): The logger level to be set in the Falcon resource
classes.
Returns:
falcon.api.API: The instantiate Falcon API.
"""
# Create logger.
logger = create_logger(
logger_name=__name__,
logger_level=logger_level
)
# Create the API.
api = falcon.API(
middleware=[
# Instantiate and add the CORS middleware.
MiddlewareCors(logger_level=logger_level),
# Instantiate and add the Auth0 authentication middleware.
MiddlewareAuth0(
auth0_domain=cfg.auth0.domain,
auth0_audience=cfg.auth0.audience,
auth0_jwks_url=cfg.auth0.jwks_url,
logger_level=logger_level,
),
],
)
msg_fmt = "Initializing API resources."
logger.info(msg_fmt)
# Add the GraphQL route.
api.add_route(
uri_template="/graphql",
resource=ResourceGraphQlSqlAlchemy(
cfg=cfg,
schema=schema,
scoped_session=scoped_session,
)
)
msg_fmt = "API initialization complete."
logger.info(msg_fmt)
return api
from wsgiref import simple_server
import falcon
from . import handlers
from .middleware import ResponseLoggerMiddleware
app = falcon.API(middleware=[ResponseLoggerMiddleware()])
"""
Messages URL"s
"""
app.add_route("/messages/{message_id:int}", handlers.MessageDetailResource())
"""
Thread URL"s
"""
app.add_route("/threads", handlers.ThreadListResource())
app.add_route("/threads/{thread_id:int}", handlers.ThreadDetailResource())
app.add_route("/threads/users/{user_id:int}",
handlers.ThreadUserListResource())
app.add_route("/threads/{thread_id:int}/messages",
handlers.ThreadMessageListResource())
"""
Alert URL's
"""
app.add_route("/alerts/{user_id:int}", handlers.AlertsResource())
"""
Health Check
"""
app.add_route("/shc", handlers.HealthCheckResource())
if __name__ == "__main__":
def main():
APP = falcon.API()
APP.add_route('/nlp', GcloudNlpResource())
httpd = simple_server.make_server('0.0.0.0', 8000, APP)
httpd.serve_forever()
print(config)
else:
resp.status = '401'
def on_delete(req, resp):
if req.context['auth']:
challenge = req.get_param('challenge')
competition = req.get_param('competition')
if not challenge or not competition:
resp.status = '400'
return
problemdir = os.path.abspath(
os.path.join(config['root'], competition, challenge))
else:
resp.status = '401'
class AuthMiddleware(object):
def __init__(self, secret):
self.secret = secret
def process_resource(self, req, resp, resource, params):
req.context['auth'] = req.get_header('Authorization') == self.secret
app = falcon.API(middleware=[
AuthMiddleware(os.environ['SHELL_DEPLOY_SECRET']),
MultipartMiddleware()
])
app.add_route('/challenge', ChallengeLoader)
def build_application(runner_fn=None):
application = falcon.API()
runner = build_runner() if runner_fn is None else runner_fn()
add_api_routes(application, runner)
return application
# on ne retourne les coordonnées Lambert que si on est en zone Lambert93
if y > -357823.2365 and x > 6037008.6939 and y < 1313632.3628 and x< 7230727.3772:
data['x'] = int(x)
data['y'] = int(y)
geojson = {"type":"Feature",
"properties":data,
"params":geonym.getParams(),
"geocode":geo,
"reverse":rev,
"geometry":{"type":"Polygon","coordinates":[[[data['west'],data['south']],[data['east'],data['south']],[data['east'],data['north']],[data['west'],data['north']],[data['west'],data['south']]]]}}
resp.body = json.dumps(geojson, sort_keys=True, indent=4, separators=(',', ': '))
resp.set_header('Content-type','application/json')
else:
resp.status = falcon.HTTP_400
resp.set_header('Content-type','text/html')
resp.body = "README dispo sur <a href='https://github.com/geonym/geonymapi'>https://github.com/geonym/geonymapi</a>"
def on_get(self, req, resp, query=None):
self.getGeonym(req, resp, query);
# Falcon.API instances are callable WSGI apps.
app = falcon.API(middleware=[HeaderMiddleware()])
# Resources are represented by long-lived class instances
g = GeonymResource()
# things will handle all requests to the matching URL path
app.add_route('/{query}', g)
from app.resources.harvester import PolkascanStartHarvesterResource, PolkascanStopHarvesterResource, \
PolkascanStatusHarvesterResource, PolkascanProcessBlockResource, \
PolkaScanCheckHarvesterTaskResource, SequenceBlockResource, PolkascanBacktrackingResource, PolkascanAccountBalance, \
PolkascanSyncAccountId
from app.resources.tools import ExtractMetadataResource, ExtractExtrinsicsResource, \
HealthCheckResource, ExtractEventsResource
# Database connection
engine = create_engine(DB_CONNECTION,
echo=DEBUG,
isolation_level="READ_UNCOMMITTED")
session_factory = sessionmaker(bind=engine, autoflush=False, autocommit=False)
# Define application
app = falcon.API(middleware=[
ContextMiddleware(),
SQLAlchemySessionManager(session_factory)
])
# Application routes
app.add_route('/healthcheck', HealthCheckResource())
app.add_route('/start', PolkascanStartHarvesterResource())
app.add_route('/stop', PolkascanStopHarvesterResource())
app.add_route('/status', PolkascanStatusHarvesterResource())
app.add_route('/process', PolkascanProcessBlockResource())
app.add_route('/sequence', SequenceBlockResource())
app.add_route('/task/result/{task_id}', PolkaScanCheckHarvesterTaskResource())
app.add_route('/tools/metadata/extract', ExtractMetadataResource())
app.add_route('/tools/extrinsics/extract', ExtractExtrinsicsResource())
app.add_route('/tools/events/extract', ExtractEventsResource())
def _build_app():
import falcon
app = falcon.API()
return app
def client(resource):
app = falcon.API()
app.add_route('/', resource)
return testing.TestClient(app)
def client():
api = falcon.API()
api.add_route('/api/parse/train', TrainParseResource())
client = falcon.testing.TestClient(api)
return client
def get_webhook_app(self):
app = falcon.API()
self.on_get = self._on_get
self.on_post = self._on_post
app.add_route("/", self)
return app
import falcon
import resources
from falcon_cors import CORS
# cors = CORS(allow_origins_list=['http://localhost:8100', 'http://192.168.0.202:8100'],
# allow_methods_list=['POST', 'PUT', 'GET'], allow_headers_list=['Content-Type'])
cors = CORS(allow_all_origins=True,
allow_all_methods=True,
allow_all_headers=True)
api = application = falcon.API(middleware=[cors.middleware])
resources.add_routes(api)
def create_app():
app = falcon.API()
app.add_route('/', index)
app.add_route('/storagerooms', storagerooms)
return app
question = formatter.format_question(insight, lang)
questions.append(question.serialize())
response['questions'] = questions
response['status'] = "found"
resp.media = response
cors = CORS(allow_all_origins=True,
allow_all_headers=True,
allow_all_methods=True)
api = falcon.API(middleware=[
cors.middleware,
MultipartMiddleware(),
DBConnectionMiddleware()
])
# Parse form parameters
api.req_options.auto_parse_form_urlencoded = True
api.add_route('/api/v1/insights/{barcode}', ProductInsightResource())
api.add_route('/api/v1/insights/random', RandomInsightResource())
api.add_route('/api/v1/insights/annotate', AnnotateInsightResource())
api.add_route('/api/v1/insights/import', InsightImporterResource())
api.add_route('/api/v1/predict/ingredients/spellcheck',
IngredientSpellcheckResource())
api.add_route('/api/v1/products/dataset', UpdateDatasetResource())
api.add_route('/api/v1/webhook/product', WebhookProductResource())
api.add_route('/api/v1/images/import', ImageImporterResource())
api.add_route('/api/v1/images/predict', ImagePredictorResource())
api.add_route('/api/v1/questions/{barcode}', ProductQuestionsResource())
try:
template = self.jinja_env.get_template(template_name)
except TemplateNotFound:
raise falcon.HTTPNotFound(
title='Template not found',
description='No such template: "{}"'.format(template_name)
)
try:
variables = json.loads(req.params.get('content', '{}'))
except json.JSONDecodeError:
raise falcon.HTTPBadRequest(
title='Failed to decode "content" parameter',
description='Value of query parameter "content" is not JSON deserializable'
)
resp.body = template.render(**variables)
resp.status = falcon.HTTP_OK
app = falcon.API(middleware=JSONParamConsolidationMiddleware())
app.add_route('/{template_name}', RenderTemplateResponder())
if __name__ == '__main__':
httpd = simple_server.make_server(host='localhost', port=8000, app=app)
print('Running on http://localhost:8000')
try:
httpd.serve_forever()
except KeyboardInterrupt:
print('Shutting down...')
httpd.shutdown()
def client_predictv1():
api = falcon.API(middleware=TestMiddleware())
api.add_route('/api/parse/v1/predict', PredictionResource_V1())
client = falcon.testing.TestClient(api)
return client
base = base64.b64decode(encoded)
return base
def get_face_encondings(self, image, req):
unknown_image = face_recognition.load_image_file(BytesIO(image))
unknown_encoding = face_recognition.face_encodings(unknown_image)
return unknown_encoding
def compare_faces(self, unknown_encoding, req):
comp = face_recognition.compare_faces([biden_encoding], unknown_encoding[0])
return comp
def save_to_storage(self, image, filename, req):
"""
Send binary file to storage.
"""
storage.upload_fileobj(BytesIO(image), filename)
app = falcon.API(middleware=[
MatchResultLoggingMiddleware(),
])
resources = ImageDetectionResource()
app.add_route('/', resources)
if __name__ == '__main__':
run_simple('0.0.0.0', 5000, app, use_reloader=True, use_debugger=True)
def set_access_control(req, resp, params):
resp.set_header('Access-Control-Allow-Origin', '*')
resp.set_header('Access-Control-Allow-Headers',
'Snap-Server-Authorization, Authorization')
resp.set_header('Access-Control-Allow-Methods', 'GET, POST')
resp.set_header('Allow', 'GET, POST')
sql_engine = sqlengine.create_engine('sqlite:///snap.sqlite', echo=False)
sql_connection = sql_engine.connect()
Session = sessionmaker(bind=sql_engine)
Base.metadata.create_all(sql_engine)
app = falcon.API(before=[set_access_control],
media_type='application/xml; charset=utf-8')
app.add_sink(raise_unknown_url)
app.add_route('/', NoMethod())
app.add_route('/{method}', UnknownMethod())
app.add_route('/addStudent', AddStudent())
app.add_route('/addTeacher', AddTeacher())
app.add_route('/changePassword', ChangePassword())
app.add_route('/createAssignment', CreateAssignment())
app.add_route('/createCourse', CreateCourse())
app.add_route('/createProject', CreateProject())
app.add_route('/createUser', CreateUser())
app.add_route('/enroll', Enroll())
app.add_route('/getProjectByName', GetProjectByName())
app.add_route('/getRevision', GetRevision())
import falcon
from falcon_cors import CORS
from project.controller import *
from project.model.models import *
cors = CORS(
# allow_origins_list=[
# ],
allow_all_headers=True,
allow_all_origins=True,
allow_methods_list=['GET', 'POST', 'OPTIONS'])
app = falcon.API(middleware=[cors.middleware])
# app = falcon.API()
# User APIs
# Branch
app.add_route("/branch/auth/sign-up", BranchSignup())
app.add_route("/branch/auth/login", BranchLogin())
app.add_route("/branch/customer/add", AddCustomer())
app.add_route("/branch/customer/list", CustomerListing())
# Branch
app.add_route("/head/auth/sign-up", HeadSignup())
app.add_route("/head/auth/login", HeadLogin())
import falcon
from upskill.resources.file import FileResource
from upskill.resources.files_summary import FilesSummaryResource
from upskill.resources.healthcheck import HealthcheckResource
from upskill.auth import AuthorizationMiddleware
middlewares = [AuthorizationMiddleware()]
api = falcon.API(middleware=middlewares)
api.add_route('/', FilesSummaryResource())
api.add_route('/files', FilesSummaryResource())
api.add_route('/files/{filename}', FileResource())
api.add_route('/healthcheck', HealthcheckResource())
import json
import falcon
api = application = falcon.API()
class Resource(object):
def on_get(self, req, resp):
resp.body = json.dumps({"msg": "falcon!"})
resp.status = falcon.HTTP_200
resource = Resource()
api.add_route('/', resource)
########################################################################################################################
# BEGIN imports for Enterprise Version
########################################################################################################################
########################################################################################################################
# END imports for Enterprise Version
########################################################################################################################
# https://github.com/lwcolton/falcon-cors
# https://github.com/yohanboniface/falcon-multipart
cors = CORS(allow_all_origins=True,
allow_credentials_all_origins=True,
allow_all_headers=True,
allow_all_methods=True)
api = falcon.API(middleware=[cors.middleware, MultipartMiddleware()])
########################################################################################################################
# Routes for System Configuration
########################################################################################################################
api.add_route('/combinedequipments',
combinedequipment.CombinedEquipmentCollection())
api.add_route('/combinedequipments/{id_}',
combinedequipment.CombinedEquipmentItem())
api.add_route('/combinedequipments/{id_}/equipments',
combinedequipment.CombinedEquipmentEquipmentCollection())
api.add_route('/combinedequipments/{id_}/equipments/{eid}',
combinedequipment.CombinedEquipmentEquipmentItem())
api.add_route('/combinedequipments/{id_}/meters',
combinedequipment.CombinedEquipmentMeterCollection())
return jsonify(result)
def _process(self, img, resp):
fname = img.filename
with open(fname, 'wb') as out:
out.write(img.file.read())
resp.body = self._run_model(fname)
resp.status = falcon.HTTP_200
os.remove(fname)
def on_post(self, req, resp):
img = req.get_param('image')
if img is None:
resp.body = jsonify({'success': False, 'error': 'Image not found'})
return
try:
self._process(img, resp)
except Exception:
ex_type, ex_value, ex_traceback = sys.exc_info()
resp.body = jsonify({'success': False, 'error': f'{ex_type.__name__}: {ex_value}'})
tasks = set(os.environ.get('CEEVEE_TASKS', 'dummy').split(','))
models = {task: MODELS[task]() for task in tasks}
app = falcon.API(middleware=[MultipartMiddleware()])
for task, model in models.items():
app.add_route(f'/{task}', BaselineServer(model))
class UIResource:
def on_get(self, req, res):
res.content_type = 'text/html'
res.body = html_body
class SynthesisResource:
def on_get(self, req, res):
if not req.params.get('text'):
raise falcon.HTTPBadRequest()
res.data = synthesizer.synthesize(req.params.get('text'))
res.content_type = 'audio/wav'
synthesizer = Synthesizer()
api = falcon.API()
api.add_route('/synthesize', SynthesisResource())
api.add_route('/', UIResource())
if __name__ == '__main__':
from wsgiref import simple_server
parser = argparse.ArgumentParser()
parser.add_argument('--checkpoint',
required=True,
help='Full path to model checkpoint')
parser.add_argument('--port', type=int, default=4000)
#Colab laboratory 사용 도중 9000포트를 사용하면 Address already in use Error 발생
#해결 방법 : !lsof -i :<port> 명령어 입력을 통해 사용중이지 않은 포트 번호를 찾는다. 그 번호로 바꿨다.
#9000포트 -> 4000포트
parser.add_argument(
'--hparams',
import falcon_jsonify
import json
import resources.hero as hero
import resources.guild as guild
import resources.search as search
import resources.pigeoncoop as pcoop
import resources.pigeon as pigeon
import resources.userAuth as auth
from falcon_cors import CORS
from pymongo import MongoClient
cors = CORS(allow_all_origins=True)
application = falcon.API(middleware=[
falcon_jsonify.Middleware(help_messages=True), cors.middleware
])
#TODO Edit <USR> and <PASSWORD> before deploy
#TODO Edit Change TestLibrary to GreatLibrary before deploy
DB_REF = MongoClient(
"mongodb://<USR>:<PASSWORD>@cluster0-shard-00-00-ygomb.mongodb.net:27017,cluster0-shard-00-01-ygomb.mongodb.net:27017,cluster0-shard-00-02-ygomb.mongodb.net:27017/TestLibrary?ssl=true&replicaSet=Cluster0-shard-0&authSource=admin"
).GreatLibrary
#image_collection = images.Collection(storage_path)
#image = images.Item(storage_path)
#application.add_route('/images', image_collection)
#application.add_route('/images/{name}', image)
auth.login_provider_item_builders.append(builder)
if hasattr(mod, 'get_module_middlewares'):
for mw in mod.get_module_middlewares():
module_middlewares.append(mw)
app_middlewares = [
RequestMiddleware(),
SQLAlchemySessionMiddleware(),
]
app_middlewares.extend(module_middlewares)
log.info('Initialize Falcon WSGI application object.')
# Set default media type, used as value for the Content-Type
# header in responses.
wsgiapp = falcon.API(media_type='application/json; charset=utf-8',
middleware=app_middlewares)
# Let Falcon not automatically consume the request body stream,
# and decode form data. Do this manually, in the corresponding
# request handlers.
wsgiapp.req_options.auto_parse_form_urlencoded = False
# TODO(jp): make sure that URLPREFIX is documented to be required to start
# with a slash, and not to end with a slash.
assert config['URLPREFIX'].startswith('/')
assert not config['URLPREFIX'].endswith('/')
class RetryTransactions:
"""Retry Falcon responders that raise retryable database exceptions."""
def __init__(self, resource):
class ItemsResource:
def on_get(self, req, resp):
params = req.params
print(params)
items = {'msg': params['msg'], 'Valence': 0.5, 'Arousal': 0.45}
resp.status = falcon.HTTP_200
resp.content_type = 'text/plain'
resp.body = json.dumps(items, ensure_ascii=False)
class CORSMiddleware:
def process_request(self, req, resp):
resp.set_header('Access-Control-Allow-Origin', '*')
resp.set_header('Access-Control-Allow-Methods', '*')
resp.set_header('Access-Control-Allow-Headers', '*')
resp.set_header('Access-Control-Max-Age', 1728000)
api = falcon.API(middleware=[CORSMiddleware()])
#api = falcon.API()
api.add_route('/prediction_api', ItemsResource())
if __name__ == "__main__":
from wsgiref import simple_server
httpd = simple_server.make_server("127.0.0.1", 8000, api)
httpd.serve_forever()
import os
import falcon
import redis
def transform(req):
zipcode = req.get_param('zip', required=True)
date = req.get_param('date', required=True)
hour = req.get_param('hour', required=True)
return f'{zipcode}.{date}:{hour}'
class SunScreenerResource:
def on_get(self, req, resp):
key = transform(req)
resp.status = falcon.HTTP_200
resp.body = (r.get(key))
r = redis.from_url(os.environ.get("REDIS_URL"))
r.set('78701.20180608:0600', '0')
app = falcon.API()
sunscreener = SunScreenerResource()
app.add_route('/', sunscreener)
# ?zip=78701&date=20180608&hour=0600
def make_api(self):
"""Create falcon api
"""
api = falcon.API()
return api
