blux-framework 0.1.0__py3-none-any.whl

blux/__init__.py

@@ -0,0 +1,10 @@
+
+from .core.elements import *
+from .core.render import (
+    Page,
+    action,
+    args
+)
+from .core.api import *
+from fastapi.requests import Request
+from starlette.datastructures import FormData

blux/__projeto_test/app/api/payments/appypay.py

@@ -0,0 +1,24 @@
+import blux
+from pydantic import BaseModel
+
+class Payment(BaseModel):
+    amount:float
+    client_name:str
+    client_email: str
+
+@blux.api()
+def get_payment(nome:str):
+    """ Criar um novo produto"""
+
+    return {"ok":"ok"}
+
+
+@blux.api(method="POST")
+def create_produtos(nome:str):
+    """ Criar um novo produto"""
+
+    return {"ok":"ok"}
+
+
+
+

blux/__projeto_test/app/api/produtos/index.py

@@ -0,0 +1,18 @@
+import blux
+
+@blux.api()
+def get_produtos(nome:str):
+    """ Criar um novo produto"""
+
+    return {"ok":"ok"}
+
+
+@blux.api(method="POST")
+def create_produtos(nome:str):
+    """ Criar um novo produto"""
+
+    return {"ok":"ok"}
+
+
+
+

blux/__projeto_test/app/assets/globals.css

@@ -0,0 +1,47 @@
+.content_app {
+    padding: 10px;
+    height: 100%;
+
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    padding: 2rem;
+    text-align: center;
+
+    font-family: Verdana, Geneva, Tahoma, sans-serif;
+
+}
+
+.title {
+    font-weight: bold;
+    font-size: 2rem;
+}
+
+.text {
+    font-size: .8rem;
+    opacity: .7;
+    max-width: 70%;
+    margin: auto;
+}
+
+.content {
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+}
+
+.button_count {
+    background-color: #141414;
+    padding: 10px;
+    border: 0;
+    border-radius: 10px;
+    color: #d2d2d2;
+    cursor: pointer;
+}
+
+.row2 {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    justify-content: center;
+}

blux/__projeto_test/app/pages/index.py

@@ -0,0 +1,68 @@
+import blux
+
+num = 0
+
+class Index(blux.Page):
+
+    title = "index"
+    styles = ["globals.css"]
+
+    @blux.action
+    def contador(self, request:blux.Request):
+        global num
+        num += 1
+
+    def render(self, request:blux.Request):
+
+        return (
+            blux.View(
+                state=self.state,
+                class_name="content_app",
+                elements=[
+                    blux.View(
+                        class_name="content",
+                        elements=[
+
+                            blux.Text(content="Bem vindo ao Box", class_name="title"),
+                            blux.Text(
+                                content="O framework pensado na produtividade de criar aplicações full-stack com apenas uma base de codigo",
+                                class_name="text"
+                            ),
+                            blux.View(
+                                elements=[
+                                    blux.Button(
+                                        content=f"contador {num}",
+                                        on_click=self.contador,
+                                        class_name="button_count"
+                                    ),
+                                ]
+                            ),
+                            blux.View(
+                                elements=[
+                                    blux.Link(
+                                        content="Develop",
+                                        href="http://ricardocayoca.onrender.com/",
+                                        target="_blank"
+                                    ),
+                                    blux.Link(
+                                        content="Doc box",
+                                        href="/"
+                                    ),
+                                    blux.Link(
+                                        content="Swager",
+                                        href="/docs",
+                                        target="_blank"
+                                    ),
+                                    blux.Link(
+                                        content="API  doc",
+                                        href="/redoc",
+                                        target="_blank"
+                                    )
+                                ],
+                                class_name="row2"
+                            )
+                        ]
+                    )
+                ]
+            )
+        )

blux/__projeto_test/app/pages/sobre.py

@@ -0,0 +1,16 @@
+import blux
+
+
+class Sobre(blux.Page):
+
+    title = "sobre"
+
+    def render(self, request):
+        return (
+            blux.View(
+                elements=[
+                    blux.Text(content="Pagina sobre"),
+                    blux.Link(content="voltar", href="/")
+                ]
+            )
+        )

blux/app.py

@@ -0,0 +1,48 @@
+import os
+from pathlib import Path
+
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+
+from .core.routes import build_router
+from .utils import install_form_middleware
+
+APP_DIR = None
+WEB_DIR = os.path.join(os.path.dirname(__file__), "web")
+
+
+template = Jinja2Templates(
+    directory=os.path.join(WEB_DIR, "templates")
+)
+
+def create_app():
+    app = FastAPI()
+
+    install_form_middleware(app)
+
+    app.mount("/static", StaticFiles(
+            directory=os.path.join(WEB_DIR, "static")
+        )
+    )
+
+    for page in Path(os.getcwd()).rglob("**/app"):
+        if page.exists():
+            APP_DIR = page
+            break
+
+    if not APP_DIR: raise FileNotFoundError(
+            f"Diretório de páginas não encontrado: app\n"
+            f"Rode o comando a partir da raiz do projeto, ou passe --app-dir."
+        )
+
+
+
+    app.mount("/assets", StaticFiles(
+        directory=APP_DIR.joinpath("assets")
+    ))
+
+    for route in build_router(APP_DIR, template):
+        app.include_router(route, include_in_schema=True)
+        
+    return app

blux/cli.py

@@ -0,0 +1,103 @@
+
+from __future__ import annotations
+
+import os
+import shutil
+from pathlib import Path
+
+import typer
+import uvicorn
+
+
+app = typer.Typer(help="CLI do blux — sobe o servidor e escaneia as rotas de app/")
+
+FACTORY_TARGET = "blux.app:create_app"
+
+
+@app.command()
+def dev(
+    host: str = typer.Option("127.0.0.1", help="Endereço para escutar"),
+    port: int = typer.Option(8000, help="Porta para escutar"),
+):
+    """Sobe o servidor de desenvolvimento com reload automático."""
+    typer.echo(f"blux dev -> http://{host}:{port}")
+    uvicorn.run(FACTORY_TARGET, factory=True, host=host, port=port, reload=True)
+
+
+@app.command()
+def init(name:str=typer.Argument(".", help="Diretório")):
+    """ Cria um estrutura do projeto """
+
+    ROOT = Path(name)
+
+    if ROOT.exists():
+        typer.echo(f"O projeto '{ROOT}' Já existe")
+        return
+    
+    origem = Path(os.path.dirname(__file__)).joinpath("__projeto_test")
+    print(origem)
+
+    for arquivo in origem.rglob("*"):
+        if arquivo.is_file():
+            relativo = arquivo.relative_to(origem)
+            destino_arquivo = ROOT / relativo
+
+            destino_arquivo.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(arquivo, destino_arquivo)
+
+
+    typer.echo(f"Projeto {ROOT} inicializado")
+    typer.echo(f"use: cd {ROOT}")
+    typer.echo("start develop server: blux dev")
+    typer.echo("cli help use: blux --help")
+
+
+    return True
+
+
+        
+
+
+
+
+
+
+@app.command()
+def start(
+    host: str = typer.Option("0.0.0.0", help="Endereço para escutar"),
+    port: int = typer.Option(8000, help="Porta para escutar"),
+    app_dir: str = typer.Option("app", "--app-dir", help="Diretório com as páginas"),
+    workers: int = typer.Option(1, help="Número de processos worker"),
+):
+    """Sobe o servidor em modo produção (sem reload)."""
+    os.environ["blux_APP_DIR"] = app_dir
+    typer.echo(f"backpay start -> http://{host}:{port}  (páginas em ./{app_dir}, workers={workers})")
+    uvicorn.run(FACTORY_TARGET, factory=True, host=host, port=port, workers=workers)
+
+
+@app.command()
+def routes(
+    app_dir: str = typer.Option("app", "--app-dir", help="Diretório com as páginas"),
+):
+    """Lista as rotas descobertas em app/, sem subir o servidor."""
+    from pathlib import Path
+
+    from .core.routes import discover_pages
+
+    pages = discover_pages(Path(app_dir))
+    if not pages:
+        typer.echo(f"Nenhuma página encontrada em ./{app_dir}")
+        raise typer.Exit(code=1)
+
+    for page in pages:
+        typer.echo(f"GET  {page.route_path}")
+        base = page.route_path.rstrip("/")
+        typer.echo(f"POST {base}/_action/{{component_id}}/{{action_name}}")
+
+
+def main():
+    app()
+
+
+if __name__ == "__main__":
+    main()

blux/core/api.py

@@ -0,0 +1,33 @@
+from functools import wraps
+from fastapi import (
+    APIRouter,
+    HTTPException,
+    Depends
+)
+
+from typing import Literal
+
+
+def api(
+        method:Literal["GET", "POST", "PUT"]="GET", 
+        middeware:list=[],
+        title="",
+    ):
+
+    def decorador(f:callable):
+        @wraps(f)
+        def wrapper(*args, **kwargs):
+
+            return f(*args, **kwargs)
+        wrapper._api = True
+        wrapper._method = method
+        wrapper._title = title
+        return wrapper
+    
+    return decorador
+
+
+
+
+
+

blux/core/elements.py

@@ -0,0 +1,264 @@
+
+from __future__ import annotations
+
+import json
+from html import escape
+from typing import ClassVar, Optional, Callable, Any
+
+from pydantic import BaseModel, Field
+
+# Tags que não têm fechamento (não podem ter filhos nem content)
+SELF_CLOSING_TAGS = {"input", "img", "br", "hr"}
+ROOT = "root_blux_app_ricardo_cayoca"
+
+class Element(BaseModel):
+    """Classe base de todo componente. Cada subclasse define seu próprio tag_name."""
+
+    # ClassVar = atributo fixo da classe, não é campo do Pydantic (não entra
+    # no __init__, não pode ser sobrescrito por instância)
+    tag_name: ClassVar[str] = "div"
+
+    id: Optional[str] = None
+    class_name: Optional[str] = None
+    content: Optional[str] = None
+    elements: list["Element"] = Field(default_factory=list)
+
+    # atributos HTML livres (ex: {"data-foo": "1", "hx-post": "/x"})
+    attrs: dict[str, str] = Field(default_factory=dict)
+    on_click:Callable=None
+    action_args:dict = None
+    state:Any=None
+
+    def html_attrs(self) -> dict[str, str]:
+        result: dict[str, str] = {}
+        if self.id:
+            result["id"] = self.id
+        if self.class_name:
+            result["class"] = self.class_name
+
+        if self.on_click:
+            result["hx-target"]   = f"#{ROOT}"
+            result["hx-post"]     = f"/_action/{self.on_click.uuid}"
+            result["hx-swap"]     = "morph:innerHTML"
+            result["hx-push-url"] = "false"
+
+        if self.action_args:
+            result["hx-vals"] = json.dumps(self.action_args)
+
+        if self.state:
+            result["data-state"] = self.state
+        result.update(self.attrs)
+        return result
+
+
+class View(Element):
+    """<div>"""
+    tag_name: ClassVar[str] = "div"
+
+
+class Text(Element):
+    """<span>"""
+    tag_name: ClassVar[str] = "span"
+
+
+class Button(Element):
+    """<button>"""
+    tag_name: ClassVar[str] = "button"
+    type: str = "button"  # evita submit acidental dentro de um <form>
+
+    def html_attrs(self) -> dict[str, str]:
+        attrs = super().html_attrs()
+        attrs["type"] = self.type
+        return attrs
+
+
+class Input(Element):
+    """<input> — self-closing, não aceita content nem elements."""
+    tag_name: ClassVar[str] = "input"
+    type: str = "text"  # text, email, password, number, checkblux, radio...
+    name: Optional[str] = None
+    value: Optional[str] = None
+    placeholder: Optional[str] = None
+    required: bool = False
+    preserve:bool=False
+
+    def html_attrs(self) -> dict[str, str]:
+        attrs = super().html_attrs()
+        attrs["type"] = self.type
+        if self.name:
+            attrs["name"] = self.name
+        if self.value is not None:
+            attrs["value"] = self.value
+        if self.placeholder:
+            attrs["placeholder"] = self.placeholder
+        if self.required:
+            attrs["required"] = "required"
+        if self.preserve:
+            if not self.id:
+                raise ValueError("Input com preserve=True precisa de um id fixo")
+            attrs["hx-preserve"] = "true"
+        return attrs
+
+
+class Textarea(Element):
+    """<textarea>"""
+    tag_name: ClassVar[str] = "textarea"
+    name: Optional[str] = None
+    placeholder: Optional[str] = None
+    rows: Optional[int] = None
+
+    def html_attrs(self) -> dict[str, str]:
+        attrs = super().html_attrs()
+        if self.name:
+            attrs["name"] = self.name
+        if self.placeholder:
+            attrs["placeholder"] = self.placeholder
+        if self.rows is not None:
+            attrs["rows"] = str(self.rows)
+        return attrs
+
+
+class Image(Element):
+    """<img> — self-closing."""
+    tag_name: ClassVar[str] = "img"
+    src: str = ""
+    alt: str = ""
+
+    def html_attrs(self) -> dict[str, str]:
+        attrs = super().html_attrs()
+        attrs["src"] = self.src
+        attrs["alt"] = self.alt
+        return attrs
+
+
+class Link(Element):
+    """<a>"""
+    tag_name: ClassVar[str] = "a"
+    href: str = "#"
+    target: Optional[str] = None  # ex: "_blank"
+    onClick:Callable=None
+
+    def html_attrs(self) -> dict[str, str]:
+        attrs = super().html_attrs()
+        attrs["href"] = self.href
+
+
+        if self.target:
+            attrs["target"] = self.target
+
+        if self.target not in ["_blank"] and self.href != "#":
+            attrs["hx-get"] = self.href
+            attrs["hx-push-url"] = "true"
+            attrs["hx-target"]   = f"#{ROOT}"
+
+            #attrs["hx-swap"]="morph"
+
+        return attrs
+
+
+class TableCell(Element):
+    """<td>"""
+    tag_name: ClassVar[str] = "td"
+
+
+class TableHeaderCell(Element):
+    """<th>"""
+    tag_name: ClassVar[str] = "th"
+
+
+class TableRow(Element):
+    """<tr> — elements deve ser uma lista de TableCell ou TableHeaderCell."""
+    tag_name: ClassVar[str] = "tr"
+
+
+class Table(Element):
+    """<table> — elements deve ser uma lista de TableRow.
+
+    Helper opcional: Table.from_rows(header, rows) monta a tabela inteira
+    a partir de listas simples, sem você ter que montar TableRow/TableCell
+    manualmente.
+    """
+    tag_name: ClassVar[str] = "table"
+
+    @classmethod
+    def from_rows(cls, header: list[str], rows: list[list[str]], **kwargs) -> "Table":
+        header_row = TableRow(elements=[TableHeaderCell(content=h) for h in header])
+        body_rows = [
+            TableRow(elements=[TableCell(content=str(cell)) for cell in row])
+            for row in rows
+        ]
+        return cls(elements=[header_row, *body_rows], **kwargs)
+
+
+class Modal(Element):
+    """<dialog> — modal nativo do HTML, sem depender de JS extra pro caso
+    básico. Alterne `open` entre renders pra abrir/fechar.
+    """
+    tag_name: ClassVar[str] = "dialog"
+    open: bool = False
+
+    def html_attrs(self) -> dict[str, str]:
+        attrs = super().html_attrs()
+        if self.open:
+            attrs["open"] = "open"
+        return attrs
+
+
+class Form(Element):
+    """<form> — elements deve conter os campos (Input, Textarea, Button...)."""
+    tag_name: ClassVar[str] = "form"
+    action:Callable = None
+    method: str = "post"  # get | post
+
+    def html_attrs(self) -> dict[str, str]:
+        attrs = super().html_attrs()
+        if self.action:
+            #attrs["action"] = self.action
+            attrs["hx-target"]   = f"#{ROOT}"
+            attrs["hx-post"]     = f"/_action/{self.action.uuid}"
+            attrs["hx-swap"]     = "morph:innerHTML"
+            attrs["hx-push-url"] = "false"
+
+        
+        attrs["method"] = self.method
+        return attrs
+
+
+class Raw(Element):
+    """Escape hatch: qualquer tag HTML sem componente próprio ainda.
+    Ex: Raw(tag="video", attrs={"controls": "controls", "src": "/v.mp4"})
+    """
+    tag: str = "div"
+
+    @property
+    def tag_name(self) -> str:  # type: ignore[override]
+        return self.tag
+
+
+# Pydantic v2 precisa disso pra resolver `list["Element"]` (referência
+# recursiva declarada antes da classe existir por completo).
+Element.model_rebuild()
+
+
+def render(element: Element) -> str:
+    """Serializa recursivamente uma árvore de Element em uma string HTML."""
+    tag = element.tag_name
+    attrs = element.html_attrs()
+
+    attrs_str = "".join(
+        f' {key}="{escape(str(value), quote=True)}"' for key, value in attrs.items()
+    )
+
+    if tag in SELF_CLOSING_TAGS:
+        return f"<{tag}{attrs_str} />"
+
+    inner = ""
+    if element.content:
+        inner += escape(element.content)
+
+    for child in element.elements:
+        inner += render(child)
+
+    return f"<{tag}{attrs_str}>{inner}</{tag}>"
+
+