Automated update of Base Application package.

Browse Source
This commit is contained in:
bot 2024-12-03 13:19:34 +00:00
parent 6f1d1262e9
commit da6ba57b48
11 changed files with 142 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
dist/app-1.0.0-py3-none-any.whl vendored
View File

Binary file not shown.

BIN
dist/app-1.0.0.tar.gz vendored
View File

Binary file not shown.

6
src/app/__init__.py
View File

@ -1,9 +1,9 @@
import logging
import logging
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s - %(levelname)s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S'
format="%(asctime)s - %(levelname)s - %(message)s",
datefmt="%Y-%m-%d %H:%M:%S",
)
log = logging.getLogger(__name__)

6
src/app/__main__.py
View File

@ -1,13 +1,11 @@
from aiohttp import web
from .app import create_app
from .args import parse_args
from .server import serve
def main():
args = parse_args()
serve(args.host, args.port)
if __name__ == '__main__':
if __name__ == "__main__":
main()

137
src/app/app.py
View File

@ -1,29 +1,41 @@
from aiohttp import web
import json
import time
from . import log
import json
import uuid
import dataset
from aiohttp import web
from . import log
def get_timestamp():
from datetime import datetime
now = datetime.now()
formatted_datetime = now.strftime("%Y-%m-%d %H:%M:%S")
return formatted_datetime
class BaseApplication(web.Application):
def __init__(self, username = None, password=None, cookie_name=None,session=None, *args, **kwargs):
def __init__(
self,
username=None,
password=None,
cookie_name=None,
session=None,
*args,
**kwargs,
):
self.cookie_name = cookie_name or str(uuid.uuid4())
self.username = username
self.password = password
self.username = username
self.password = password
self.session = session or {}
middlewares = kwargs.pop("middlewares",[])
middlewares = kwargs.pop("middlewares", [])
middlewares.append(self.request_middleware)
middlewares.append(self.base64_auth_middleware)
middlewares.append(self.session_middleware)
super().__init__(*args, **kwargs)
async def authenticate(self, username, password):
return self.username == username and self.password == password
@ -37,58 +49,60 @@ class BaseApplication(web.Application):
return web.Response(
status=401,
text="Unauthorized",
headers={"WWW-Authenticate": 'Basic realm="Restricted"'}
headers={"WWW-Authenticate": 'Basic realm="Restricted"'},
)
try:
encoded_credentials = auth_header.split(" ", 1)[1]
decoded_credentials = base64.b64decode(encoded_credentials).decode("utf-8")
username, password = decoded_credentials.split(":", 1)
except (ValueError, base64.binascii.Error):
return web.Response(status=400, text="Invalid Authorization Header")
if not await self.authenticate(username, password):
return web.Response(
status=401,
text="Invalid Credentials",
headers={"WWW-Authenticate": 'Basic realm="Restricted"'}
headers={"WWW-Authenticate": 'Basic realm="Restricted"'},
)
return await handler(request)
@web.middleware
async def request_middleware(self, request, handler):
time_start = time.time()
created = get_timestamp()
request = await handler(request)
time_end = time.time()
await self.insert("http_access",dict(
created=created,
path=request.path,
duration=time_end - time_start,
))
await self.insert(
"http_access",
{
"created": created,
"path": request.path,
"duration": time_end - time_start,
},
)
return request
@web.middleware
async def session_middleware(self,request, handler):
async def session_middleware(self, request, handler):
# Process the request and get the response
cookies = request.cookies
session_id = cookies.get(self.cookie_name, None)
setattr(request,"session", self.session.get(session_id,{}))
setattr(request, "session", self.session.get(session_id, {}))
response = await handler(request)
if not session_id:
session_id = str(uuid.uuid4())
response.set_cookie(
self.cookie_name,
session_id,
max_age=3600,
httponly=True
)
response.set_cookie(self.cookie_name, session_id, max_age=3600, httponly=True)
return response
class WebDbApplication(BaseApplication):
def __init__(self, db=None, db_web=False,db_path="sqlite:///:memory:",*args, **kwargs):
def __init__(
self, db=None, db_web=False, db_path="sqlite:///:memory:", *args, **kwargs
):
super().__init__(*args, **kwargs)
self.db_web = db_web
self.db_path = db_path
@ -103,53 +117,57 @@ class WebDbApplication(BaseApplication):
self.router.add_post("/delete", self.delete_handler)
async def insert_handler(self, request):
obj = await request.json()
await request.json()
response = await self.insert(request.get("table"), request.get("data"))
return web.json_response(response)
async def update_handler(self, request):
obj = await request.json()
response = await self.update(request.get('table'), request.get('data'), request.get('where',{}))
await request.json()
response = await self.update(
request.get("table"), request.get("data"), request.get("where", {})
)
return web.json_response(response)
async def upsert_handler(self, request):
obj = await request.json()
response = await self.upsert(request.get('table'), request.get('data'), request.get('keys',[]))
await request.json()
response = await self.upsert(
request.get("table"), request.get("data"), request.get("keys", [])
)
return web.json_response(response)
async def find_handler(self, request):
obj = await request.json()
response = await self.find(request.get('table'), requesst.get('where',{}))
await request.json()
response = await self.find(request.get("table"), requesst.get("where", {}))
return web.json_response(response)
async def find_one_handler(self, request):
obj = await request.json()
response = await self.find_one(request.get('table'), requesst.get('where',{}))
await request.json()
response = await self.find_one(request.get("table"), requesst.get("where", {}))
return web.json_response(response)
async def delete_handler(self, request):
obj = await request.json()
response = await self.delete(request.get('table'), requesst.get('where',{}))
await request.json()
response = await self.delete(request.get("table"), requesst.get("where", {}))
return web.json_response(response)
async def set(self, key, value):
value = json.dumps(value, default=str)
self.db['kv'].upsert(dict(key=key,value=value),['key'])
self.db["kv"].upsert({"key": key, "value": value}, ["key"])
async def get(self, key, default=None):
record = self.db['kv'].find_one(key=key)
record = self.db["kv"].find_one(key=key)
if record:
return json.loads(record.get('value','null'))
return json.loads(record.get("value", "null"))
return default
async def insert(self, table_name, data):
return self.db[table_name].insert(data)
async def update(self, table_name, data, where):
return self.db[table_name].update(data,where)
return self.db[table_name].update(data, where)
async def upsert(self, table_name, data, keys):
return self.db[table_name].upsert(data,keys or [])
return self.db[table_name].upsert(data, keys or [])
async def find(self, table_name, filters):
if not filters:
@ -162,17 +180,15 @@ class WebDbApplication(BaseApplication):
try:
return dict(self.db[table_name].find_one(**filters))
except ValueError:
return None
return None
async def delete(self, table_name, where):
return self.db[table_name].delete(**where)
class Application(WebDbApplication):
def __init__(self, *args, **kwargs):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.on_startup.append(self.on_startup_task)
self.router.add_get("/", self.index_handler)
@ -189,19 +205,22 @@ class Application(WebDbApplication):
self.running_since = get_timestamp()
async def inc_request_count(self):
request_count = await self.get("root_request_count",0)
request_count = await self.get("root_request_count", 0)
request_count += 1
await self.set("root_request_count", request_count)
return request_count
return request_count
async def index_handler(self,request):
return web.json_response(dict(
request_count=await self.inc_request_count(),
timestamp=get_timestamp(),
uptime=self.uptime,
running_since=self.running_since
),content_type="application/json")
async def index_handler(self, request):
return web.json_response(
{
"request_count": await self.inc_request_count(),
"timestamp": get_timestamp(),
"uptime": self.uptime,
"running_since": self.running_since,
},
content_type="application/json",
)
def create_app(*args, **kwargs):

23
src/app/args.py
View File

@ -1,36 +1,31 @@
import argparse
import argparse
def parse_args():
parser = argparse.ArgumentParser(
description="Async web service"
)
parser = argparse.ArgumentParser(description="Async web service")
parser.add_argument(
'--host',
"--host",
type=str,
required=False,
default="0.0.0.0",
help='Host to serve on. Default: 0.0.0.0.'
help="Host to serve on. Default: 0.0.0.0.",
)
parser.add_argument(
'--port',
"--port",
type=int,
required=False,
default=8888,
help='Port to serve on Default: 8888.'
help="Port to serve on Default: 8888.",
)
parser.add_argument(
'--url',
"--url",
type=str,
default="http://localhost:8888",
required=False,
help='Base URL.'
help="Base URL.",
)
return parser.parse_args()

23
src/app/cli.py
View File

@ -1,23 +1,24 @@
import asyncio
import time
from aiohttp import ClientSession
from . import log
from .args import parse_args
import time
from . import log
async def cli_client(url):
while True:
sentence = input("> ")
async with ClientSession() as session:
async with session.post("http://localhost:8080",json=sentence) as response:
async with session.post("http://localhost:8080", json=sentence) as response:
try:
print(await response.json())
except Exception as ex:
print(ex)
print(await response.text())
async def bench(url):
index = 0
while True:
@ -28,13 +29,14 @@ async def bench(url):
async with ClientSession() as session:
async with session.get(url) as response:
print(await response.text())
#print(await response.json())
# print(await response.json())
time_end = time.time()
print("Request {}. Duration: {}".format(index,time_end-time_start))
print(f"Request {index}. Duration: {time_end - time_start}")
except Exception as ex:
log.exception(ex)
await asyncio.sleep(1)
def cli_bench():
args = parse_args()
asyncio.run(bench(args.url))
@ -44,9 +46,6 @@ def main():
args = parse_args()
asyncio.run(cli_client(args.url))
if __name__ == '__main__':
if __name__ == "__main__":
main()

42
src/app/kim.py
View File

@ -1,17 +1,18 @@
#!/usr/bin/python3
import sys
import shutil
import sys
from readchar import readkey
def text_editor(init='', prompt=''):
'''
def text_editor(init="", prompt=""):
"""
Allow user to edit a line of text complete with support for line wraps
and a cursor | you can move back and forth with the arrow keys.
init = initial text supplied to edit
prompt = Decoration presented before the text (not editable and not returned)
'''
"""
term_width = shutil.get_terminal_size()[0]
ptr = len(init)
@ -25,26 +26,24 @@ def text_editor(init='', prompt=''):
copy = prompt + text.copy()
if ptr < len(text):
copy.insert(ptr + len(prompt), '|')
copy.insert(ptr + len(prompt), "|")
# Line wraps support:
if len(copy) > term_width:
cut = len(copy) + 3 - term_width
if ptr > len(copy) / 2:
copy = ['<'] * 3 + copy[cut:]
copy = ["<"] * 3 + copy[cut:]
else:
copy = copy[:-cut] + ['>'] * 3
copy = copy[:-cut] + [">"] * 3
# Display current line
print('\r' * term_width + ''.join(copy), end=' ' * (term_width - len(copy)))
print("\r" * term_width + "".join(copy), end=" " * (term_width - len(copy)))
# Read new character into c
if c in (53, 54):
# Page up/down bug
c = readkey()
if c == '~':
if c == "~":
continue
else:
c = readkey()
@ -52,17 +51,17 @@ def text_editor(init='', prompt=''):
if len(c) > 1:
# Control Character
c = ord(c[-1])
if c == 68: # Left
if c == 68: # Left
ptr -= 1
elif c == 67: # Right
elif c == 67: # Right
ptr += 1
elif c == 53: # PgDn
elif c == 53: # PgDn
ptr -= term_width // 2
elif c == 54: # PgUp
elif c == 54: # PgUp
ptr += term_width // 2
elif c == 70: # End
elif c == 70: # End
ptr = len(text)
elif c == 72: # Home
elif c == 72: # Home
ptr = 0
else:
print("\nUnknown control character:", c)
@ -77,17 +76,18 @@ def text_editor(init='', prompt=''):
num = ord(c)
if num in (13, 10): # Enter
print()
return ''.join(text)
elif num == 127: # Backspace
return "".join(text)
elif num == 127: # Backspace
if text:
text.pop(ptr - 1)
ptr -= 1
elif num == 3: # Ctrl-C
elif num == 3: # Ctrl-C
sys.exit(1)
else:
# Insert normal character into text.
text.insert(ptr, c)
ptr += 1
if __name__ == "__main__":
print("Result =", text_editor('Edit this text', prompt="Prompt: "))
print("Result =", text_editor("Edit this text", prompt="Prompt: "))

3
src/app/repl.py
View File

@ -1,4 +1,4 @@
import code
import code
def repl(**kwargs):
@ -8,6 +8,7 @@ def repl(**kwargs):
variables.update(kwargs)
code.interact(local=variables)
if __name__ == "__main__":
repl()

17
src/app/server.py
View File

@ -1,14 +1,17 @@
from aiohttp import web
from .app import create_app
from . import log
import time
import time
def serve(host="0.0.0.0",port=8888):
from aiohttp import web
from . import log
from .app import create_app
def serve(host="0.0.0.0", port=8888):
app = create_app()
log.info("Serving on {}:{}".format(host,port))
log.info(f"Serving on {host}:{port}")
while True:
try:
web.run_app(app,host=host,port=port)
web.run_app(app, host=host, port=port)
except KeyboardInterrupt:
break
except Exception as ex:

13
src/app/tests.py
View File

@ -1,20 +1,19 @@
from .app import WebDbApplication
import unittest
import asyncio
from .app import WebDbApplication
class WebDbApplicationTestCase(unittest.IsolatedAsyncioTestCase):
def setUp(self):
self.db = WebDbApplication()
async def test_insert(self):
self.assertEqual(await self.db.insert("test",dict(test=True)), 1)
self.assertEqual(len(await self.db.find("test",dict(test=True, id=1))), 1)
self.assertEqual(await self.db.insert("test", {"test": True}), 1)
self.assertEqual(len(await self.db.find("test", {"test": True, "id": 1})), 1)
async def test_find(self):
print(await self.db.find("test",None))
print(await self.db.find("test", None))
# self.assertEqual(len(await self.db.find("test",dict(test=True, id=1))), 1)