async def download(id: str, msg_id: int):
if not user.is_connected():
await user.connect()
if not await user.is_user_authorized():
return templates.get_template("auth/not_authorized.html").render()
try:
try:
id = int(id)
except:
pass
msg = await user.get_messages(id, ids=msg_id)
if not msg or not msg.file:
return HTMLResponse(
templates.get_template("error.jinja2").render(
error="Такого сообщения не существует"))
msg: types.Message
if os.path.isdir(f"cache/{id}/{msg_id}"
) and os.listdir(f"cache/{id}/{msg_id}/") != []:
file = f"cache/{id}/{msg_id}/" + os.listdir(
f"cache/{id}/{msg_id}/")[0]
else:
for i in ["cache/", f"cache/{id}/", f"cache/{id}/{msg_id}/"]:
if not os.path.isdir(i): os.mkdir(i)
if msg.file.mime_type.split(
"/")[0] == "audio" and msg.file.ext != ".mp3":
file = f"cache/{id}/{msg_id}/audio.mp3"
m_ = io.BytesIO(await msg.download_media(bytes))
m_.name = "audio.wav"
AudioSegment.from_file(m_).export(file)
elif msg.file.mime_type.split("/")[0] == "image":
file = f"cache/{id}/{msg_id}/image." + config.pic_format
m_ = io.BytesIO(await msg.download_media(bytes))
m_.name = "pic.png"
im = Image.open(m_).convert("RGBA")
im.load()
bg = Image.new("RGB", im.size, (255, ) * 3)
bg.paste(im, mask=im.split()[3])
bg.thumbnail((config.pic_max_size, ) * 2, 1)
bg.save(file, config.pic_format, quality=config.pic_quality)
else:
path = f"cache/{id}/{msg_id}/{msg.file.name}"
file = await msg.download_media(path)
stream = open(file, mode="rb")
return StreamingResponse(stream, media_type=msg.file.mime_type)
except Exception as ex:
return HTMLResponse(
templates.get_template('error.jinja2').render(
error='<br>'.join(ex.args)))
async def read_note(note_name: str, json: bool = False):
note = get_note(note_name)
note_dict = {}
if note:
note_dict = note.dict()
else:
new_note = Note(name=note_name)
note_dict = new_note.dict()
note_key = urlsafe_key(note_name)
notes.put(note_dict, note_key)
note_dict["base_url"] = base_url
if json:
return note_dict
note_template = Template((open("note.html").read()))
note_css = open("style.css").read()
note_js = open("note.js").read()
return HTMLResponse(
note_template.render(note_data=note_dict,
note_js=note_js,
css=note_css))
async def websocket_base():
html = """
<!DOCTYPE html>
<html>
<head>
<title>Chat</title>
</head>
<body>
<h1>WebSocket Chat</h1>
<form action="" onsubmit="sendMessage(event)">
<input type="text" id="messageText" autocomplete="off"/>
<button>Send</button>
</form>
<ul id='messages'>
</ul>
<script>
var ws = new WebSocket("ws://localhost:8000/ws");
ws.onmessage = function(event) {
var messages = document.getElementById('messages')
var message = document.createElement('li')
var content = document.createTextNode(event.data)
message.appendChild(content)
messages.appendChild(message)
};
function sendMessage(event) {
var input = document.getElementById("messageText")
ws.send(input.value)
input.value = ''
event.preventDefault()
}
</script>
</body>
</html>
"""
return HTMLResponse(html)
def kakaopay_success(request: Request, response: Response,
pg_token: Optional[str]):
url = "https://kapi.kakao.com/v1/payment/approve"
APP_ADMIN_KEY = ""
headers = {
"Authorization": f"KakaoAK {APP_ADMIN_KEY}",
"content-type": "application/x-www-form-urlencoded;charset=utf-8"
}
# 쿠키 및 DB 대신 JSON 파일 활용
# tid = request.cookies.get("ttid")
tidDb = open('/Users/doylekim/my/myFastApi/db/db.txt',
mode='r',
encoding='utf-8')
tid = tidDb.read()
tidDb.close()
query = f"?cid=TC0ONETIME&tid={tid}&partner_order_id=partner_order_id&partner_user_id=partner_user_id&pg_token={pg_token}"
_res = requests.post(url=url + query, headers=headers)
_result = _res.json()
viewFile = open(
'/Users/doylekim/my/myFastApi/views/kakaofPage.html',
mode='r',
encoding='utf-8',
)
html_content = viewFile.read()
viewFile.close()
tidDbReset = open('/Users/doylekim/my/myFastApi/db/db.txt',
mode='w',
encoding='utf-8')
tidDbReset.write("")
tidDbReset.close()
print(_result)
return HTMLResponse(content=html_content, status_code=200)
def logged_out(format: str = ""):
if format == 'json':
return {"message": "Logged out!"}
elif format == 'html':
return HTMLResponse(content='<h1>Logged out!</h1>')
else:
return PlainTextResponse(content='Logged out!')
def page(body, title=None, menu_items=None):
doc = dom.document(title=f"ujira | {title}" if title else "ujira")
with doc.head:
link(
rel="stylesheet",
href="https://www.unpkg.com/[email protected]/dist/tailwind.min.css"
)
with div(
cls=
"min-h-screen flex flex-col flex-auto flex-shrink-0 antialiased bg-gray-50 text-gray-800"
) as container:
doc += container
with div(
cls=
"fixed flex flex-col top-0 left-0 w-64 bg-gray-900 h-full shadow-lg"
):
# Menu Header
with div(cls="flex items-center pl-6 h-20 border-b border-gray-800"
):
with div(cls="my-3"):
p("ujira",
cls=
"text-md font-medium tracking-wide text-gray-100 font-sans uppercase"
)
# Menu items
page_menu(menu_items or [])
div(body, cls="ml-72 flex")
return HTMLResponse(str(doc))
def home(request: Request):
'''
Returns barebones HTML form allowing the user to enter a URL and download format
'''
html_content = '''
<head>
<title>YouTube Downloader</title>
</head>
<h2>Enter a YouTube URL and download format</h2>
<form method="post">
<div>
<label>Enter YouTube URL </label>
<input type="text" name="url" style="width:400px" placeholder="https://www.youtube.com/watch?v=C0DPdy98e4c">
<div>
<label>Download Format</label>
<select name="download_format">
<option>VideoBestQuality</option>
<option>AudioBestQuality</option>
</select>
</div>
</div>
<button type="submit">Submit</button>
</form>
'''
return HTMLResponse(content=html_content, status_code=200)
def home(request: Request):
'''
Returns barebones HTML form allowing the user to select a file and model
'''
html_content = '''
<form method="post" enctype="multipart/form-data">
<div>
<label>Upload Image</label>
<input name="file" type="file" multiple>
<div>
<label>Select YOLO Model</label>
<select name="model_name">
<option>yolov5s</option>
<option>yolov5m</option>
<option>yolov5l</option>
<option>yolov5x</option>
</select>
</div>
</div>
<button type="submit">Submit</button>
</form>
'''
return HTMLResponse(content=html_content, status_code=200)
def welcome_token(*,
response: Response,
token: str = Query(None),
format: str = Query(None)):
if token not in app.token_value:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Incorrect email or password",
headers={"WWW-Authenticate": "Basic"},
)
if format == "json":
return {"message": "Welcome!"}
elif format == "html":
return HTMLResponse("""
<html>
<head>
<title>Some HTML in here</title>
</head>
<body>
<h1>Welcome!</h1>
</body>
</html>
""")
else:
return PlainTextResponse("Welcome!")
def return_message(text: str, message_format: Optional[str]):
if message_format == "json":
return JSONResponse(content={"message": text}, status_code=200)
if message_format == "html":
return HTMLResponse(content=f"<html><h1>{text}</h1></html>",
status_code=200)
return PlainTextResponse(content=text, status_code=200)
async def review_snippet(snippet_id: str):
try:
review_template = Template((open("review.html").read()))
snippet = Snippet(**snippets.get(snippet_id)["data"]).dict()
return HTMLResponse(review_template.render(snippet_data=snippet))
except KeyError:
return {"error": "no such snippet"}
async def show_overview():
html_content = """
<html>
<head>
<title>Model Debug Status</title>
<style>
.errorCode {
font-family: 'Courier New', monospace;
color: red;
width: 70vw;
border: 1px solid black;
}
</style>
</head>
<body>
<h1>Model Debugging Utility</h1>
<br>
<h3>Initialization Status</h3>
<p>%s</p>
<p class="errorCode">%s</p>
<br>
<h3>Prediction Status</h3>
<p>%s</p>
<code>%s</code>
<br> <br>
<p class="errorCode">%s</p>
</body>
</html>
""" % (init_status, init_error, predict_status, predict_result,
predict_error)
return HTMLResponse(content=html_content, status_code=200)
def login(
request: Request, next: Optional[str] = None,
ticket: Optional[str] = None):
if request.session.get("user", None):
# Already logged in
return RedirectResponse(request.url_for('profile'))
# next = request.args.get('next')
# ticket = request.args.get('ticket')
if not ticket:
# No ticket, the request come from end user, send to CAS login
cas_login_url = cas_client.get_login_url()
print('CAS login URL: %s', cas_login_url)
return RedirectResponse(cas_login_url)
# There is a ticket, the request come from CAS as callback.
# need call `verify_ticket()` to validate ticket and get user profile.
print('ticket: %s', ticket)
print('next: %s', next)
user, attributes, pgtiou = cas_client.verify_ticket(ticket)
print(
'CAS verify ticket response: user: %s, attributes: %s, pgtiou: %s',
user, attributes, pgtiou)
if not user:
return HTMLResponse('Failed to verify ticket. <a href="/login">Login</a>')
else: # Login successfully, redirect according `next` query parameter.
response = RedirectResponse(next)
request.session['user'] = dict(user=user)
return response
def root(page):
print(f"page: {page}")
try:
with open(f"web/{page}.html") as f:
return HTMLResponse(f.read())
except FileNotFoundError:
raise HTTPException(status_code=404, detail="page not found")
async def get():
return HTMLResponse("""
<!DOCTYPE html>
<html>
<head>
<title>Chat</title>
</head>
<body>
<h2>Events:</h2>
<ul id='events'>
</ul>
<script>
var ws = new WebSocket("ws://localhost:8000/events/ws");
ws.onmessage = function(event) {
var data = JSON.parse(event.data)
var events = document.getElementById('events')
var message = document.createElement('li')
var content = document.createTextNode(data['type'])
message.appendChild(content)
events.appendChild(message)
};
function sendMessage(event) {
var input = document.getElementById("messageText")
ws.send(input.value)
input.value = ''
event.preventDefault()
}
</script>
</body>
</html>
""")
async def main_site():
"""How did you get here?"""
bullshit = corporate_bullshit.sentence()
to_send = page_content.replace(r"%spicy_bullshit%", bullshit)
return HTMLResponse(content=to_send)
def reactCdn():
view = open('/Users/doylekim/my/myFastApi/views/reactView.html',
mode="r",
encoding="utf-8")
html_content = view.read()
view.close()
return HTMLResponse(content=html_content, status_code=200)
def get_rapidoc_html(
openapi_url: str,
title: str,
description: str,
rapidoc_js_url:
str = "https://cdn.jsdelivr.net/npm/rapidoc/dist/rapidoc-min.js",
) -> HTMLResponse:
html = f"""
<!DOCTYPE html>
<html lang="en">
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>{title}</title>
<meta name="description" content="{description}">
<script src="{rapidoc_js_url}"></script>
<rapi-doc
spec-url="{openapi_url}"
sort-endpoints-by=method
render-style=view
theme=dark
load-fonts=false
regular-font='"Fira Sans", Avenir, "Segoe UI", Arial, sans-serif'
schema-expand-level=1
schema-description-expanded=true
></rapi-doc>"""
return HTMLResponse(html)
def message_response(format: str, func_value: str):
if format == "json":
return JSONResponse(content={"message": func_value})
if format == "html":
return HTMLResponse(content=f"<h1>{func_value}</h1>")
return PlainTextResponse(content=func_value)
def chatbot_ans_html(question):
with open("chatbot_sample_intents.csv", "r") as f:
content = f.readlines()
text_fields = question.split(" ")
predict_answer = {}
for line in content:
fields = line.strip().split(",")
target = fields[0]
count = sum([1 for word in text_fields if word in fields[1:]])
predict_answer[target] = count
answer = max(predict_answer, key=predict_answer.get)
html_content = """<html>
<body>
<br><br><br><br><br><br>
""" + answer + """
<br><br><button onclick="window.location.href='/chatbot_question'">Another question</button>
<button onclick="window.location.href='/index'">Home</button>
</body>
</html> """
return HTMLResponse(content=html_content, status_code=200)
async def post(request: Request, ident):
ident = ident.replace('+', ' ')
if ident.isdigit():
post_data = await Post.cache(ident=int(ident))
else:
post_data = await Post.get_by_slug(ident)
if not post_data:
raise HTMLResponse(status_code=404)
post = Post(**post_data)
stats = await post.stats
reaction_type = None
liked_comment_ids = []
github_user = request.session.get('github_user')
pageview = await post.incr_pageview()
related_posts = await post.get_related(limit=4)
if github_user:
reaction_type = await post.get_reaction_type(github_user['gid'])
liked_comment_ids = await post.comment_ids_liked_by(github_user['gid'])
post = await post.to_async_dict(**post_data)
post.author = config.AttrDict(post.author)
return {
'post': post,
'github_user': github_user,
'stats': stats,
'reaction_type': reaction_type,
'liked_comment_ids': liked_comment_ids,
'related_posts': related_posts,
'pageview': pageview
}
async def login_page(
request: Request,
response: Response,
username: str = Form(...),
password: str = Form(...),
):
token = None
token = await auth_server.rpc_server["easyauth"][
"generate_auth_token"](username, password)
if not "access_token" in token:
message = ("invalid username / password" if
"invalid username / password" in token else token)
return HTMLResponse(
await auth_server.get_login_page(message=message,
request=request),
status_code=401,
)
token = token["access_token"]
token_id = auth_server.decode_token(token)[1]["token_id"]
auth_server.store["tokens"][token_id] = ""
response.set_cookie("token", token, **auth_server.cookie_security)
response.status_code = 200
redirect_ref = default_login_redirect
if "ref" in request.cookies:
redirect_ref = request.cookies["ref"]
response.delete_cookie("ref")
return RedirectResponse(redirect_ref,
headers=response.headers,
status_code=HTTP_302_FOUND)
async def update_calendar(request: Request, date: str) -> HTMLResponse:
last_day = cg.Day.convert_str_to_date(date)
next_weeks = cg.create_weeks(cg.get_n_days(last_day, ADD_DAYS_ON_SCROLL))
template = templates.get_template(
'partials/calendar/monthly_view/add_week.html')
content = template.render(weeks_block=next_weeks)
return HTMLResponse(content=content, status_code=HTTPStatus.OK)
async def add_alchemy(item: ItemAdd):
term_list = item.terminals.split(sep=',')
for term in term_list:
add_incas = Incas(terminal=term.strip(), user_id=item.user_id)
session.add(add_incas)
session.commit()
return HTMLResponse(status_code=200)
async def upload_datapackage_view():
content = """
<body>
<form action="/upload_datapackage/" enctype="multipart/form-data" method="post">
<p><input name="zipped_datapackage" type="file"></p>
<p>
<label for="schema">Schema</label>
<input name="schema" type="text" value="model_draft">
</p>
<p>
<label for="mapping">Mapping (optional)</label>
<input name="mapping" type="text">
</p>
<p>
<label for="show_json">Show data after mapping (instead of upload)</label>
<input name="show_json" type="checkbox" id="show_json">
</p>
<p>
<label for="adapt_foreign_keys">Adapt foreign keys (foreign keys are automatically set)</label>
<input name="adapt_foreign_keys" type="checkbox" id="adapt_foreign_keys">
</p>
<p><input type="submit"></p>
</form>
</body>
"""
logger.debug("Validating datapackage...")
return HTMLResponse(content=content)
async def main():
content = """
<body>
To know the usage visit github.com/ls-da3m0ns
</body>
"""
return HTMLResponse(content=content)
def logged_out(format: str = ""):
if format == 'json':
return {"message": "Logged out!"}
elif format == 'html':
return HTMLResponse(content="<h1>Logged out!</h1>", status_code=200)
else:
return PlainTextResponse(content="Logged out!", status_code=200)
async def png(room: int, admin: str):
retv = {
SCC["CHECK_IN_DICT"]: False,
SCC["PING_GOOD"]: False,
SCC["POLL_CODE"]: False,
}
prc = sp.get(room, None)
if prc is not None:
retv[SCC["CHECK_IN_DICT"]] = True
d = prc.poll()
if d is None:
retv[SCC["POLL_CODE"]] = True
else:
retv[SCC["POLL_CODE"]] = d
com = AsyncServiceCommunicator()
await com.start()
ps = Parser()
cmd = {
"action": SCC["PING_COMMAND"],
SCC["W8ANSWERIN"]: admin + str(room) + "ping"
}
await com.push_in_channel("e" + ps.create_room_name(room),
ps.parse_in(cmd))
await com.set_expires_channel("e" + ps.create_room_name(room), 5)
msg = await com.listen_for_clients([admin + str(room) + "ping"], 8)
if msg is not None:
retv[SCC["PING_GOOD"]] = True
return HTMLResponse(json.dumps(retv))
async def root():
cli_str = " ".join(
filter(None, [
"curl",
"-u 'username[:password]'" if config.use_security else None,
config.url,
"-F 'files=@/path/to/file1'",
"[-F 'files=@/path/to/file2' ...]",
]))
simple_cli_str = " ".join(
filter(None, [
r"""sed 's/\(.*\)/-F "files=@\1"/' <<EOF | tr '\n' ' ' | xargs -pr curl""",
"-u 'username[:password]'" if config.use_security else None,
config.url, "\n"
"/path/to/file1\n"
"/path/to/file2\n"
"`ls *.txt`\n"
"EOF"
]))
content = f"""
<body>
<form action="/" enctype="multipart/form-data" method="post">
<input name="files" type="file" multiple>
<input type="submit">
</form>
<pre>
{html.escape(cli_str)}
</pre>
<pre>
{html.escape(simple_cli_str)}
</pre>
</body>
"""
return HTMLResponse(content=content)
async def language(request: Request,
set_lang: str = Form(...),
next: str = Form(...),
q: str = Form(default=None)):
"""
A POST route used to set a session's language.
Return a 303 See Other redirect to {next}?next={next}. If we are
setting the language on any page, we want to preserve query
parameters across the redirect.
"""
if next[0] != '/':
return HTMLResponse(b"Invalid 'next' parameter.", status_code=400)
query_string = "?" + q if q else str()
# If the user is authenticated, update the user's LangPreference.
if request.user.is_authenticated():
with db.begin():
request.user.LangPreference = set_lang
# In any case, set the response's AURLANG cookie that never expires.
response = RedirectResponse(url=f"{next}{query_string}",
status_code=HTTPStatus.SEE_OTHER)
secure = aurweb.config.getboolean("options", "disable_http_login")
response.set_cookie("AURLANG",
set_lang,
secure=secure,
httponly=secure,
samesite=cookies.samesite())
return response
