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)
