async def test_connection_pool_recycling_connections(self): v = Vibora() address, port = '127.0.0.1', 65530 with Session(prefix=f'http://{address}:{port}', timeout=3, keep_alive=True) as client: v.run( host=address, port=port, block=False, verbose=False, necromancer=False, workers=1, debug=False, ) self.assertEqual((await client.get('/')).status_code, 404) v.clean_up() wait_server_offline(address, port, timeout=30) v.run( host=address, port=port, block=False, verbose=False, necromancer=False, workers=1, debug=False, ) self.assertEqual((await client.get('/')).status_code, 404)
async def test_connection_pool_recycling_connections(): v = Vibora() address, port = "127.0.0.1", 65530 async with Session(prefix=f"http://{address}:{port}", timeout=3, keep_alive=True) as client: v.run(host=address, port=port, block=False, necromancer=False, workers=1, debug=False, startup_message=False) assert (await client.get("/")).status_code == 404 v.clean_up() wait_server_offline(address, port, timeout=30) v.run(host=address, port=port, block=False, necromancer=False, workers=1, debug=False, startup_message=False) assert (await client.get("/")).status_code == 404
from vibora import Vibora from vibora.responses import Response from vibora.static import StaticHandler app = Vibora(static=StaticHandler( paths=['/your_static_dir', '/second_static_dir'])) @app.route('/') async def home(): return Response(b'123') if __name__ == '__main__': app.run(debug=False, port=8888)
import sys from multiprocessing import cpu_count from vibora import Vibora, Response app = Vibora() @app.route('/') async def home(): return Response(b'Naked!') if __name__ == '__main__': app.run(host=sys.argv[1], workers=cpu_count(), debug=False, port=int(sys.argv[2]))
returnParams = { 'callbackResponseID': callbackResponseID, 'msg': 'Response from the MPO process called' } printx("[3a] calling {callbackURL}") async with aiohttp.ClientSession() as session: async with session.post(callbackURL, data=json.dumps(returnParams)) as r: responseStr = await r.text() printx("[3b] Callback endpoint returned:") def printx(strtoPrint): print(strtoPrint) # pass def dummy(): pass if __name__ == '__main__': if len(sys.argv) > 1: print("Setting serverURLPath") serverURLPath = sys.argv[1] try: print("Run webserver - workers=1") app.run(host="0.0.0.0", port=8001, workers=1) except: print("Run webserver") app.run(host="0.0.0.0", port=8001)
# corpus = parse.unquote(corpus) # parse.unquote(parse.quote('中文')) # _ = jieba.lcut(corpus) # return JsonResponse({'中国': _}) # @app.route('/', methods=['POST']) # async def home(request: Request): # uploaded_files = [] # for file in (await request.files): # print(file) # file.save('/tmp/' + str(uuid.uuid4())) # print(f'Received uploaded file: {file.filename}') # uploaded_files.append(file.filename) # return JsonResponse(uploaded_files) # @app.route('/') # async def home(request: Request): # print(dict(request.args)) # return Response(f"Name: {request.args['name']}") @app.route('/poetry/<corpus>', methods=['GET'] ) # @app.route(re.compile('/product/(?P<product_id>[0-9]+)')) async def page(corpus: str): corpus = parse.unquote(corpus) # parse.unquote(parse.quote('中文')) _ = p.gen(start_words=corpus).split() return JsonResponse({'中国': _}) if __name__ == '__main__': app.run(host='0.0.0.0', port=5000, workers=4, debug=True)
import asyncio_redis from vibora import Vibora from vibora.hooks import Events from vibora.sessions import AsyncRedis from vibora.responses import Response app = Vibora(sessions=AsyncRedis()) @app.route('/', cache=False) async def home(request): print(request.session.dump()) await request.load_session() if request.session.get('count') is None: request.session['count'] = 0 request.session['count'] += 1 return Response(str(request.session['count']).encode()) @app.handle(Events.BEFORE_SERVER_START) async def open_connections(loop): pool = await asyncio_redis.Pool.create(host='localhost', port=6379, poolsize=10) app.session_engine.connection = pool if __name__ == '__main__': app.run(debug=True, port=8000, host='0.0.0.0', workers=6)
from vibora.request import Request from vibora.hooks import Events from vibora.sessions import Redis from vibora.responses import JsonResponse app = Vibora(sessions=Redis()) @app.route('/') def home(request: Request): if request.session.get('count') is None: request.session['count'] = 0 request.session['count'] += 1 return JsonResponse({'a': 1, 'session': request.session.dump()}) @app.route('/asd') def home(request: Request): return JsonResponse({'a': 1, 'session': request.session.dump()}) @app.handle(Events.AFTER_SERVER_START) def open_connections(): app.session_engine.connection = redis.StrictRedis(host="localhost", port=6379, db=0) if __name__ == '__main__': app.run(debug=True, port=8000, host='0.0.0.0')
"""python vibora_app.py""" from vibora import Request, Vibora from vibora.responses import Response app = Vibora() @app.route('/') async def home(request: Request): return Response(b'hello world') # 90000 Requests/sec if __name__ == '__main__': app.run(debug=False, host='0.0.0.0', port=8000, workers=4)
from vibora import Vibora, Request, Response from vibora.responses import JsonResponse from vibora.router import RouterStrategy from vibora.static import StaticHandler app = Vibora(template_dirs=[ './templates', ], router_strategy=RouterStrategy.CLONE, static=StaticHandler(paths=['./static'], url_prefix='/static', max_cache_size=1 * 1024 * 1024)) @app.route('/', methods=['POST', "GET"]) async def home(request: Request): print(request.method) if request.method == 'POST': print(await request.form()) else: for x in request.args: print(x) return await app.render("index.html") if __name__ == '__main__': app.run(debug=True, host='0.0.0.0', port=9999)
fortunes = fortunes.sort(key=sort_fortunes_key) return await app.render('index.html', fortunes=fortunes) @app.route('/db') async def single_query(request: Request): res = await fetchWorld() return JsonResponse({'id': res[0], 'randomNumber': res[1]}, headers={'Server': 'Vibora'}) @app.route('/plaintext') async def plaintext(): return Response(b'Hello, World!', headers={'Server': 'Vibora', 'Content-Type': 'text/plain'}) @app.route('/json') async def json(): return JsonResponse({'message': 'Hello, World!'}, headers={'Server': 'Vibora'}) @app.route('/queries') async def multiple_queries(request: Request): total_queries = getQueriesTotal(request.args) worlds = await fetchMultipleWorlds(total_queries) return JsonResponse(worlds, headers={'Server': 'Vibora', 'Content-Type': 'application/json', 'Content-Length': str(total_queries)}) @app.route('/updates') async def update_queries(request: Request): total_queries = getQueriesTotal(request.args) worlds = updateMultipleWorlds(total_queries) return JsonResponse(worlds, headers={'Server': 'Vibora', 'Content-Type': 'application/json', 'Content-Length': str(total_queries)}) if __name__ == '__main__': app.run(host="0.0.0.0", port=8000)
from vibora import Vibora from vibora.responses import Response app = Vibora() @app.route('/') async def home(): return Response(b'123') if __name__ == '__main__': app.run(debug=False, port=8000)
from vibora import Vibora, Response app = Vibora() @app.route("/") async def index(): return Response(b"") @app.route("/user/<id>", methods=["GET"]) async def user_info(id: int): return Response(f"{id}".encode()) @app.route("/user", methods=["POST"]) async def user(): return Response(b"") if __name__ == "__main__": app.run(host="0.0.0.0", port=3000, debug=False)
from vibora import Vibora from vibora.responses import JsonResponse app = Vibora() @app.route('/') async def home(): data = ({"message": "Hello World"}) return JsonResponse(data) if __name__ == '__main__': app.run(debug=True)
from vibora import Vibora, Request from vibora.responses import JsonResponse app = Vibora() @app.route('/hello-world', methods=['GET', 'POST']) async def hello_world(request: Request): response = { 'ok': True, 'method': request.method, 'hello': 'world' } if request.method == b'POST': response.update( {'hello': (await request.json()).get('who', 'whoareyou?')} ) return JsonResponse(response) app.run(host='0.0.0.0', port=8000, workers=4)
from vibora import Request, Vibora from vibora.responses import JsonResponse app = Vibora() @app.route("/") async def index() -> JsonResponse: return JsonResponse({"message": "hello!"}) @app.route("/hello/<name>/<age>") async def hello(name: str, age: int) -> JsonResponse: return JsonResponse(f"Hi {name}! I hear you're {age} years old.") @app.route("/echo", methods=["POST"]) async def echo(request: Request) -> JsonResponse: return JsonResponse(await request.json()) if __name__ == "__main__": app.run(debug=False, host="0.0.0.0", port=8000)
from vibora import Vibora, Response app = Vibora() @app.route('/') async def index(): return Response(b'') @app.route("/user/<id>", methods=['GET']) async def user_info(id: int): return Response(f'{id}') @app.route("/user", methods=['POST']) async def user(): return Response(b'') if __name__ == '__main__': app.run(host='0.0.0.0', port=3000, debug=False)
raise Exception("Path no exist") app = Vibora(static=StaticHandler(paths=[str(p)])) event_loop: ContextVar[AbstractEventLoop] = ContextVar("event_loop") @app.route("/alive", methods=["GET"]) async def alive(): return JsonResponse({"yes": ":)"}) @app.route("/static/never-loads1.html", methods=["GET"]) async def never_load(): loop = event_loop.get() if loop is None: loop = aio_get_event_loop() event_loop.set(loop) await aio_sleep(6, loop=loop) return RedirectResponse("http://localhost:8888/static/never-loads.html") def get_app(): app.run(debug=False, host="localhost", port=8888, block=False, workers=1) return app if __name__ == "__main__": print("alive") app.run(debug=False, host="localhost", port=8888, workers=2)
from vibora import Vibora from vibora.request import Request from vibora.responses import JsonResponse from vibora.static import StaticHandler app = Vibora(static=StaticHandler(['/tmp'], url_prefix='/static')) @app.route('/', methods=['POST']) async def home(request: Request): await request.form() return JsonResponse({'hello': 'world'}) if __name__ == '__main__': app.run(debug=False, port=8000, host='0.0.0.0')
import asyncio import time from vibora import Vibora from vibora.responses import Response app = Vibora() @app.route('/', cache=False) async def home(): await asyncio.sleep(0) return Response(str(time.time()).encode()) if __name__ == '__main__': app.run(debug=True, port=8888)
""" from aioprometheus import render, Counter, Registry from vibora import Vibora, Request, Response app = Vibora(__name__) app.registry = Registry() app.events_counter = Counter("events", "Number of events.") app.registry.register(app.events_counter) @app.route("/") async def hello(request: Request): app.events_counter.inc({"path": "/"}) return Response(b"hello") @app.route("/metrics") async def handle_metrics(request: Request): """ Negotiate a response format by inspecting the ACCEPTS headers and selecting the most efficient format. Render metrics in the registry into the chosen format and return a response. """ content, http_headers = render(app.registry, [request.headers.get("accept")]) return Response(content, headers=http_headers) app.run()
return Response(word, headers={'Content-Type': 'text/plain; charset=utf-8'}) @app.route('/mysql', methods=['POST'], cache=False) async def mysql(req: Request): values = parse_qs((await req.stream.read()).decode('utf-8')) sql = values['sql'][0] async with app.mysql.acquire() as conn: async with conn.cursor() as cur: await cur.execute(sql) value = await cur.fetchone() return Response(bytes(str(value[0]), 'utf-8'), headers={'Content-Type': 'text/plain; charset=utf-8'}) @app.handle(Events.BEFORE_SERVER_START) async def before_server_start(): app.redis = await aioredis.create_redis('redis://localhost') app.mysql = await aiomysql.create_pool( maxsize=100, host=config.get('client', 'host'), port=config.getint('client', 'port'), user=config.get('client', 'user'), password=config.get('client', 'password'), db=config.get('client', 'db') ) if __name__ == '__main__': app.run(debug=False, host='127.0.0.1', port=3000, workers=1)
from vibora import Vibora, Request from vibora.responses import JsonResponse app = Vibora() @app.route('/') async def home(request: Request): return JsonResponse({'hello': 'world'}) if __name__ == '__main__': app.run(debug=True, host='0.0.0.0', port=3300)
from vibora import Vibora from vibora.responses import JsonResponse from vibora.schemas import Schema, fields app = Vibora() async def validate(value, context): return True class BenchmarkSchema(Schema): field1: str = fields.String(required=True, ) field2 = fields.Integer(required=True) @app.route('/', methods=['POST']) async def home(request): values = BenchmarkSchema.from_request(request) context = await BenchmarkSchema.load(extra={'db': }) if context.is_valid: return JsonResponse({'msg': 'Successfully validated'}) return JsonResponse({'errors': context.errors}) if __name__ == '__main__': app.run(debug=False, port=8000, host='0.0.0.0', workers=8)
import time from vibora import Vibora from vibora.responses import Response from vibora.utils import Timeouts app = Vibora() @app.route('/') def home(): time.sleep(10) return Response(b'123') if __name__ == '__main__': app.run(debug=False, port=8000, host='0.0.0.0', workers=1, timeouts=Timeouts(worker=5, keep_alive=10))
app = Vibora() # Hello World @app.route('/') async def home(): return Response(b'Hello world') # Json response @app.route('/json') async def helloworld(): return JsonResponse({'hello': 'world'}) # Async websocket connection @app.websocket('/socket') async def on_connect(ws: Websocket): # Reply back the received message. while True: await ws.write(await ws.read()) if __name__ == '__main__': try: port = int(sys.argv[1]) except Exception as e: port = 5000 app.run(debug=True, host='0.0.0.0', port=port)
@app.route("/queries") async def multiple_queries(request: Request): total_queries = getQueriesTotal(request.args) worlds = await fetchMultipleWorlds(total_queries) return JsonResponse( worlds, headers={ "Server": "Vibora", "Content-Type": "application/json", "Content-Length": str(total_queries), }, ) @app.route("/updates") async def update_queries(request: Request): total_queries = getQueriesTotal(request.args) worlds = updateMultipleWorlds(total_queries) return JsonResponse( worlds, headers={ "Server": "Vibora", "Content-Type": "application/json", "Content-Length": str(total_queries), }, ) if __name__ == "__main__": app.run(host="0.0.0.0", port=8000)
from vibora import Vibora from vibora.responses import Response from vibora.request import Request app = Vibora() @app.route('/', methods=['POST']) def home(request: Request): print(request.form) return Response(b'asd') if __name__ == '__main__': app.run(debug=False, port=8000, host='localhost')
RUN apk add py-pip import asyncio from vibora import Vibora from vibora.request import Request from vibora.responses import JsonResponse app = Vibora() @app.route('/') def home(): return JsonResponse({'hello': 'world'}) @app.route('/async', methods=['GET']) async def home_async(request: Request): await asyncio.sleep(1) print(request.headers) return JsonResponse({'hello': 'world'}, status_code=201) if __name__ == '__main__': app.run()
import json from vibora import Vibora from backend.api import api from backend.config import Config if __name__ == "__main__": print('Welcome to the demo!') app = Vibora() # Registering our API app.add_blueprint(api, prefixes={'v1': '/v1'}) with open('backend/config.json') as f: config = Config(json.load(f)) app.components.add(config) app.run(host=config.host, port=config.port)