tests/fast_api_test.py - master - wezzydev/pyehtml5

tests/fast_api_test.py
370 строк15 KB
MarkEvan
Dev
09 мар 2026, 15:16
09 мар 2026, 15:166c4bb9a
from fastapi import FastAPI, Request, Query, Form, Body, HTTPException, status
from fastapi.responses import HTMLResponse, JSONResponse
from fastapi.staticfiles import StaticFiles
from .testrender import render
from typing import Annotated
from pyehtml5.exceptions import PyehtmlNotFound, PyehtmlNotCallable 
from pyehtml5.E5tagger import  Document, E ,HTML, Builder
from asyncio import sleep
from pyehtml5 import web
from starlette.middleware.base import BaseHTTPMiddleware
from tests.apps.corerender import render as reds



class ErrorHandlingMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request: Request, call_next):
        # print(request.method)
        try:
            response = await call_next(request)
            # print(response)
            return response
        except Exception as exc:
            return JSONResponse(
                status_code=500,
                content={"message": "Internal Server Error", "detail": str(exc)},
            )
class ExceptionCustom(HTTPException):
    pass


def exception_404_handler(request: Request, exc: HTTPException):
    return JSONResponse(status_code=status.HTTP_404_NOT_FOUND, content={"message f adfa fas fas fasf asfas fasf": "404"})



app = FastAPI()
# @app.exception_handler(Exception)
# async def custom_exception_handler(request: Request, exc: Exception):
#    return HTMLResponse(content="dsadasdasdasd", status_code=404, headers={"Cache-Control": "no-cache, no-store, must-revalidate"})


app.mount("/public", StaticFiles(directory="./public"), name="public")
app.add_middleware(ErrorHandlingMiddleware)

@app.get("/")
async def read_items(request: Request, page: Annotated[str | None, Query(max_length=50)] = None):
   
    result = await render(request, path="index", 
      keywords="Seo keywords slovo, slovo, slovo, slovo",
      description="Seo descriptions ", page=page)
    # raise ExceptionCustom(status_code=404, detail="no found")  

    return HTMLResponse(content=result, status_code=200, headers={"Cache-Control": "no-cache, no-store, must-revalidate"})


@app.get("/message")
async def read_items(request: Request, page: Annotated[str | None, Query(max_length=50)] = None):
    result = await render(request, path="message", title="Ceneral page title window",
      keywords="Seo keywords slovo, slovo, slovo, slovo",
      description="Seo descriptions ", page=page)
    return HTMLResponse(result, status_code=200, headers={"Cache-Control": "no-cache, no-store, must-revalidate"})





@app.get("/slide")
async def read_items(request: Request, page: Annotated[str | None, Query(max_length=50)] = None):
    try:
        result = await render(request, path="slide", title="Ceneral page title window",
            keywords="Seo keywords slovo, slovo, slovo, slovo",
            description="Seo descriptions ", page=page)
    except NoRegisterHandler as e:
        return HTMLResponse(e.respons_html()) 
    
    return HTMLResponse(content=str(result), status_code=200, headers={"Cache-Control": "no-cache, no-store, must-revalidate"})


@app.get("/modal")
async def read_items(request: Request, page: Annotated[str | None, Query(max_length=50)] = None):
    try:
        result = await render(request, path="modal", title="Ceneral page title window",
            keywords="Seo keywords slovo, slovo, slovo, slovo",
            description="Seo descriptions ", page=page)
    except NoRegisterHandler as e:
        return HTMLResponse(e.respons_html()) 
    
    return HTMLResponse(result, status_code=200, headers={"Cache-Control": "no-cache, no-store, must-revalidate"})


@app.get("/calendar")
async def read_items(request: Request, page: Annotated[str | None, Query(max_length=50)] = None):
    try:
        result = await render(request, path="calendar", title="Ceneral page title window",
            keywords="Seo keywords slovo, slovo, slovo, slovo",
            description="Seo descriptions ", page=page)
    except NoRegisterHandler as e:
        return HTMLResponse(e) 
    
    return HTMLResponse(result, status_code=200, headers={"Cache-Control": "no-cache, no-store, must-revalidate"})


@app.get("/card")
async def read_items(request: Request, page: Annotated[str | None, Query(max_length=50)] = None):
    try:
        result = await render(request, path="card", title="Ceneral page title window",
            keywords="Seo keywords slovo, slovo, slovo, slovo",
            description="Seo descriptions ", page=page)
    except NoRegisterHandler as e:
        return HTMLResponse(e) 
    
    return HTMLResponse(result, status_code=200, headers={"Cache-Control": "no-cache"})



@app.get("/paginator")
async def read_items(request: Request, page: Annotated[str | None, Query(max_length=50)] = None):
    try:
        result = await render(request, path="paginator", title="Ceneral page title window",
            keywords="Seo keywords slovo, slovo, slovo, slovo",
            description="Seo descriptions ", page=page)
    except NoRegisterHandler as e:
        return HTMLResponse(e) 
    
    return HTMLResponse(result, status_code=200, headers={"Cache-Control": "no-cache"})


@app.get("/icons")
async def read_items(request: Request, page: Annotated[str | None, Query(max_length=50)] = None):
    try:
        result = await render(request, path="icons", title="Ceneral page title window",
            keywords="Seo keywords slovo, slovo, slovo, slovo",
            description="Seo descriptions ", page=page)
    except NoRegisterHandler as e:
        return HTMLResponse(e) 
    
    return HTMLResponse(result, status_code=200, headers={"Cache-Control": "no-cache"})


@app.get("/post")
async def read_items(request: Request, page: Annotated[str | None, Query(max_length=50)] = None):
    try:
        result = await render(request, path="post", title="Ceneral page title window",
            keywords="Seo keywords slovo, slovo, slovo, slovo",
            description="Seo descriptions ", page=page)
    except NoRegisterHandler as e:
        return HTMLResponse(e) 
    
    return HTMLResponse(result, status_code=200, headers={"Cache-Control": "no-cache"})






@app.get("/aside")
async def read_items(request: Request, page: Annotated[str | None, Query(max_length=50)] = None):
    try:
        result = await render(request, path="aside", title="Ceneral page title window",
            keywords="Seo keywords slovo, slovo, slovo, slovo",
            description="Seo descriptions ", page=page)
    except NoRegisterHandler as e:
        return HTMLResponse(e) 
    
    return HTMLResponse(result, status_code=200, headers={"Cache-Control": "no-cache"})


@app.get("/ivideo")
async def read_items(request: Request, page: Annotated[str | None, Query(max_length=50)] = None):
    try:
        result = await render(request, path="ivideo", title="Ceneral page title window",
            keywords="Seo keywords slovo, slovo, slovo, slovo",
            description="Seo descriptions ", page=page)
    except NoRegisterHandler as e:
        return HTMLResponse(e) 
    
    return HTMLResponse(result, status_code=200, headers={"Cache-Control": "no-cache"})

@app.get("/table")
async def read_items(request: Request, page: Annotated[str | None, Query(max_length=50)] = None):
    try:
        result = await render(request, path="table", title="Ceneral page title window",
            keywords="Seo keywords slovo, slovo, slovo, slovo",
            description="Seo descriptions ", page=page)
    except NoRegisterHandler as e:
        return HTMLResponse(e) 
    
    return HTMLResponse(result, status_code=200, headers={"Cache-Control": "no-cache"})


@app.get("/admin")
async def read_items(request: Request, page: Annotated[str | None, Query(max_length=50)] = None):
    try:
        result = await render(request, path="admin", title="Ceneral page title window",
            keywords="Seo keywords slovo, slovo, slovo, slovo",
            description="Seo descriptions ")
    except PyehtmlNotFound as e:
        return HTMLResponse(str(e)) 
    
    return HTMLResponse(result, status_code=200, headers={"Cache-Control": "no-cache"})


@app.get("/panel")
async def read_items(request: Request, page: Annotated[str | None, Query(max_length=50)] = None):
    try:
        result = await render(request, path="panel", title="Ceneral page title window",
            keywords="Seo keywords slovo, slovo, slovo, slovo",
            description="Seo descriptions ", page=page)
    except NoRegisterHandler as e:
        return HTMLResponse(e) 
    
    return HTMLResponse(result, status_code=200, headers={"Cache-Control": "no-cache"})

@app.get("/forms")
async def read_items(request: Request, page: Annotated[str | None, Query(max_length=50)] = None):
    try:
        result = await render(request, path="forms", title="Ceneral page title window",
            keywords="Seo keywords slovo, slovo, slovo, slovo",
            description="Seo descriptions ", page=page)
    except NoRegisterHandler as e:
        return HTMLResponse(e) 
    
    return HTMLResponse(result, status_code=200, headers={"Cache-Control": "no-cache"})

@app.get("/window")
async def read_items(request: Request, page: Annotated[str | None, Query(max_length=50)] = None):
    try:
        result = await render(request, path="window", title="Ceneral page title window",
            keywords="Seo keywords slovo, slovo, slovo, slovo",
            description="Seo descriptions ", page=page)
    except PyehtmlNotFound as e:
        return HTMLResponse(e) 
    
    return HTMLResponse(result, status_code=200, headers={"Cache-Control": "no-cache"})


@app.get("/notification")
async def read_items(request: Request, page: Annotated[str | None, Query(max_length=50)] = None):
    try:
        result = await render(request, path="notification", title="Ceneral page title window",
            keywords="Seo keywords slovo, slovo, slovo, slovo",
            description="Seo descriptions ", page=page)
    except PyehtmlNotFound as e:
        return HTMLResponse(e) 
    return HTMLResponse(result, status_code=200)


@app.get("/drop")
async def read_items(request: Request, page: Annotated[str | None, Query(max_length=50)] = None):
    try:
        result = await render(request, path="drop", title="Ceneral page title window",
            keywords="Seo keywords slovo, slovo, slovo, slovo",
            description="Seo descriptions ", page=page)
    except NoRegisterHandler as e:
        return HTMLResponse(e) 
    
    return HTMLResponse(result, status_code=200, headers={"Cache-Control": "no-cache"})


@app.get("/grid")
async def read_items(request: Request, page: Annotated[str | None, Query(max_length=50)] = None):
    try:
        result = await render(request, path="grid", title="Ceneral page title window",
            keywords="Seo keywords slovo, slovo, slovo, slovo",
            description="Seo descriptions ", page=page)
    except NoRegisterHandler as e:
        return HTMLResponse(e) 
    
    return HTMLResponse(result, status_code=200, headers={"Cache-Control": "no-cache"})








@app.post("/clicked")
async def read_items(request: Request, args: Annotated[list[str] | None, Query()] = None):
    btn = E.button(hx_post="/clicked?args=column_5|size_12|title_3", class_="button is-info", hx_swap="innerHTML", hx_target="#opens" )("click me") 
    await sleep(1)
    col = web.Columns(class_="is-multiline has-text-primary  is-centered")

    for i in range(10):          # if i% 2  == 0:
                #  col.column("<p> tetettstss</p>", class_="bb")
        msg = web.Message(class_="is-link message" )

        msg.add_header("hellooo",  class_="is-link", onclick="messageClose(event)" )
        msg.add_body(E.p(class_="test")(f"ffasfasfasfasf-{i}"))
        col.column(msg(),  class_='is-3 bb is-desktop-3  ')
    sl = web.Slide()
    l = []
    sl.widescreen = 2 
    sl.desktop = 4 #> 968 width
    sl.mobile = 3 #<600 width
    sl.tablet = 8 #930 width
    for i in range(10):
        bibox = E.div(class_="box has-text-centered  has-background-primary mt-2 mb-2", style="height:auto;")(f"example-{i}") 
        # rt = sl.boxing(data=bibox(f"example-{i}"), classes=["m-0", "bb","is-centered" ,"mt-4", "mb-4"])
        l.append(bibox)
    sl.slider(l, style="padding:2px;")    
    fixed = web.FixedGrid(class_="has-2-rows")
    for i in range(10):
        box = E.div(class_="box bb has-background-info")(str(i))
        # fixed.cells(data_cell=box, class_="is-col-span-2")
        fixed.cells(data_cell=box,)

    modal = web.Modal()
    modal.active = True 
    modal.button_close_top = True
    # modal.background = True
    # modal.width = 70
    # modal.left = 100
    h1 = E.h1(class_="title ")("ef ewfwe fwef")
    # modal.top = 200
    # modal.bottom = 100
    modal.bottom_nav_theme = "is-info"
    modal.bottom_nav("tesr", href="/", data_target="tesst").bottom_nav("treeep", href="asdasdsadsd", data_tests="asdasdasdsad")
    modal.bottom_nav("adfafasf", href="fasfasfasf")
    modal.bottom_nav("ad", href="fasfasfasf")
    modal.bottom_nav("adf", href="fasfasfasf")
    modal.bottom_nav("adsf", href="fasfasfasf")
    # print(request.args)

    
    modal.modal_body_fixed(E.div(class_="box")(h1, btn, col(), sl(), fixed()))
    return HTMLResponse( str(modal()), status_code=200)

# @app.post("/")
# async def read_items(request: Request, binaryFile: Annotated[str | None, Form()] = None):
#     return HTMLResponse( "tree", status_code=200)    

@app.get("/doc")
async def read_items(request: Request, binaryFile: Annotated[str | None, Form()] = None):
    try:
        result = await render(request, path="doc", title="Ceneral page title window",
            keywords="Seo keywords slovo, slovo, slovo, slovo",
            description="Seo descriptions ",)
    except NoRegisterHandler as e:
        return HTMLResponse(e) 
    
    return HTMLResponse(result, status_code=200, headers={"Cache-Control": "no-cache"})

# app.add_exception_handler(ExceptionCustom, exception_404_handler)

@app.get("/hero")
async def read_items(request: Request, binaryFile: Annotated[str | None, Form()] = None):
    try:
        result = await render(request, path="hero", title="Ceneral page title window",
            keywords="Seo keywords slovo, slovo, slovo, slovo",
            description="Seo descriptions ",)
    except NoRegisterHandler as e:
        return HTMLResponse(e) 
    
    return HTMLResponse(result, status_code=200, headers={"Cache-Control": "no-cache"})



@app.get("/sapps")
async def read_items(request: Request):
    try:
        print(request)
        result = await reds(request, "index", title="Ceneral page title window",
            keywords="Seo keywords slovo, slovo, slovo, slovo",
            description="Seo descriptions ")
    except NoRegisterHandler as e:
        print(e)
        return HTMLResponse(e) 
    
    return HTMLResponse(result, status_code=200, headers={"Cache-Control": "no-cache"})