{ 'type': 'number', 'format': 'float' }
]
}
}
})
@app.route('/')
class Root(Resource):
async def get(self):
'''Note Route
This docstring will show up as the description and short-description
for the openapi docs for this route.
'''
return jsonify({"Note": "There exists a localhost:9000/openapi.json that can be helpful here"})
@app.expect(expected)
async def post(self):
'''Post Hello Route
Data should be sent through postman (but postman does not have HTTP/2, for that you need `curl --http2`) with HTTPS POST "1": { "foobar": "super", "baz": 5.56 }
'''
data = await request.get_json()
return jsonify(data)
if __name__ == "__main__":
app.run(host='localhost',
port=8080,
certfile='cert.pem',
keyfile='key.pem')
@app.route("/what_if", methods=["POST"])
class WhatIf(Resource):
async def post(self):
return "Calculating"
@app.route("/result", methods=["POST"])
class Result(Resource):
async def post(self):
return "result"
@app.errorhandler(Exception)
async def handle_exception(e):
if isinstance(e, HTTPException):
response = e.get_response()
response.data = json.dumps({
"code": e.code,
"name": e.name,
"description": e.description,
})
response.content_type = "application/json"
app.logger.error("HTTP Error 500")
return response
app.logger.error(e)
return await render_template("500_generic.html", e=e)
if __name__ == "__main__":
app.run()
return '',204
session.permanent = True
app.permanent_session_lifetime = datetime.timedelta(hours=1)
# session.permanent = False
# return '', 200
except:
traceback.print_exc()
return '', 401
@app.route('/session', methods=['GET'])
async def Session():
print('session',session)
return '',200
from Routes.Department import *
from Routes.Tasks import *
from Routes.Auth import *
from Routes.TaskHistory import *
from Routes.Employee import *
if __name__ == "__main__":
app.run(host='0.0.0.0', port=5000, debug=True)
#app.run(host='0.0.0.0', port=80)
app = Pint(__name__)
# Register Blueprints
app.register_blueprint(user)
app.register_blueprint(user_confirm)
load_dotenv('.env', verbose=True)
app.config.from_object('default_config')
app.config.from_envvar('APPLICATION_SETTINGS')
jwt = JWTManager(app)
@app.before_first_request
async def create_tables():
async with app.app_context():
db.create_all()
@jwt.token_in_blacklist_loader
def check_if_token_in_blacklist(decrypted_token):
jti = decrypted_token['jti']
return TokenBlacklist.is_jti_blacklisted(jti)
if __name__ == "__main__":
psw.init_app(app)
db.init_app(app)
asyncio.create_task(app.run())
exc = sys.exc_info()[1]
if exc:
exc.argument = self._get_action_from_name(exc.argument_name)
raise exc
# super(SrlArgumentParser, self).error(message)
# small restful API server running locally so my other bots can send messages
app = Pint(__name__, title='Srl Bot API')
@app.route('/api/message')
class Message(Resource):
async def post(self):
data = await request.get_json()
if 'auth' in data and data['auth'] == c.InternalApiToken:
if not client.in_channel(data['channel']):
abort(400, "Bot not in specified channel")
result = await client.message(data['channel'], data['message'])
return jsonify({"success": True})
else:
abort(401)
if __name__ == '__main__':
client = SrlBot(c.SRL_NICK, realname=c.SRL_NICK)
loop = asyncio.get_event_loop()
loop.create_task(orm.create_pool(loop))
loop.create_task(client.connect('irc.speedrunslive.com'))
loop.create_task(app.run(host='127.0.0.1', port=5000, loop=loop))
loop.run_forever()
a root ("/") endpoint.
Replies Hello! to all valid requests. Rejects all rate exceeding requests with
429 statius code.
"""
import os
from quart import Quart, redirect, url_for
from quart_openapi import Pint, Resource
from decorators.rate_limit import rate_limit
REQUEST_COUNT = os.getenv("REQUEST_COUNT", "1")
INTERVAL = os.getenv("INTERVAL", "5")
PROXY = Pint(__name__, title="Rate Limiting Proxy App")
@PROXY.route("/")
class RateLimitProxyRoot(Resource):
"""This route is used to limit the rate of the incoming requests to a
configured REQUEST_COUNT per INTERVAL. The configuration is read from
the environment.
"""
@rate_limit(int(REQUEST_COUNT), int(INTERVAL))
async def get(self):
"""Get request.
"""
return "Hello!"
if __name__ == "__main__":
PROXY.run(port=7070)
resp = await client.send_file('me', file.filename)
print(resp)
os.remove(file.filename)
return 'Done'
# async def main():
# await hypercorn.asyncio.serve(app, hypercorn.Config())
# By default, `Quart.run` uses `asyncio.run()`, which creates a new asyncio
# event loop. If we create the `TelegramClient` before, `telethon` will
# use `asyncio.get_event_loop()`, which is the implicit loop in the main
# thread. These two loops are different, and it won't work.
#
# So, we have to manually pass the same `loop` to both applications to
# make 100% sure it works and to avoid headaches.
#
# To run Quart inside `async def`, we must use `hypercorn.asyncio.serve()`
# directly.
#
# This example creates a global client outside of Quart handlers.
# If you create the client inside the handlers (common case), you
# won't have to worry about any of this, but it's still good to be
# explicit about the event loop.
if __name__ == '__main__':
app.run('localhost', port=5000, debug=True)
