Téléchargement fasthx - Téléchargement du code source fasthx

fasthx

Données du site Web

v2.1.1

Télécharger

Code source : https://github.com/volfpeter/fasthx

Documentation et exemples : https://volfpeter.github.io/fasthx

Fasthx

Fastapi Server côté serveur avec support HTMX intégré.

Caractéristiques clés:

Syntaxe de décorateur qui fonctionne avec Fastapi comme on pourrait s'y attendre, pas besoin de dépendances inutilisées ou magiques dans les routes.
Construit pour HTMX , mais peut être utilisé sans lui.
Fonctionne avec n'importe quel moteur de modèle ou bibliothèque de rendu côté serveur, par exemple htmy , jinja2 ou dominate .
Donne au moteur de rendu l'accès à toutes les dépendances de l'itinéraire décoré.
Les routes HTMX fonctionnent comme prévu si elles reçoivent des demandes non-HTMX, de sorte que le même itinéraire peut servir les données et rendre HTML en même temps.
Les en-têtes de réponse que vous définissez dans vos itinéraires sont conservés après le rendu, comme vous vous en doutez dans Fastapi.
Le typage correct permet d'appliquer d'autres décorateurs (dactylographiés) sur vos itinéraires.
Fonctionne avec les routes Sync et Async .

Installation

Le package est disponible sur PYPI et peut être installé avec:

$ pip install fasthx

Le package a des dépendances facultatives pour les intégrations officielles suivantes:

htmy: pip install fasthx[htmy] .
Jinja: pip install fasthx[jinja] .

Exemples

Pour des exemples complets mais simples qui présentent l'utilisation de base de FastHX , veuillez consulter le dossier Exemples.

Htmy Template

Exige: pip install fasthx[htmy] .

Servir les demandes HTML et HTMX avec HTMY est aussi simple que de créer une instance fasthx.htmy.HTMY et d'utiliser ses méthodes de décorateur hx() et page() sur vos itinéraires.

L'exemple ci-dessous suppose l'existence d'une IndexPage et d'un composant htmy UserList . L'exemple de travail complet avec les composants htmy peut être trouvé ici.

 from datetime import date

from fastapi import FastAPI
from pydantic import BaseModel

from fasthx . htmy import HTMY

# Pydantic model for the application
class User ( BaseModel ):
    name : str
    birthday : date

# Create the FastAPI application.
app = FastAPI ()

# Create the FastHX HTMY instance that renders all route results.
htmy = HTMY ()

@ app . get ( "/users" )
@ htmy . hx ( UserList )  # Render the result using the UserList component.
def get_users ( rerenders : int = 0 ) -> list [ User ]:
    return [
        User ( name = "John" , birthday = date ( 1940 , 10 , 9 )),
        User ( name = "Paul" , birthday = date ( 1942 , 6 , 18 )),
        User ( name = "George" , birthday = date ( 1943 , 2 , 25 )),
        User ( name = "Ringo" , birthday = date ( 1940 , 7 , 7 )),
    ]

@ app . get ( "/" )
@ htmy . page ( IndexPage )  # Render the index page.
def index () -> None : ...

Templage Jinja2

Exige: pip install fasthx[jinja] .

Pour commencer à servir les demandes HTML et HTMX, il vous suffit de créer une instance de fasthx.Jinja et d'utiliser ses méthodes hx() ou page() comme décorateurs sur vos itinéraires. hx() ne déclenche que le rendu HTML pour les demandes HTMX, tandis que page() rend inconditionnellement HTML. Voir l'exemple de code ci-dessous:

 from fastapi import FastAPI
from fastapi . templating import Jinja2Templates
from fasthx import Jinja
from pydantic import BaseModel

# Pydantic model of the data the example API is using.
class User ( BaseModel ):
    first_name : str
    last_name : str

# Create the app.
app = FastAPI ()

# Create a FastAPI Jinja2Templates instance and use it to create a
# FastHX Jinja instance that will serve as your decorator.
jinja = Jinja ( Jinja2Templates ( "templates" ))

@ app . get ( "/" )
@ jinja . page ( "index.html" )
def index () -> None :
    ...

@ app . get ( "/user-list" )
@ jinja . hx ( "user-list.html" )
async def htmx_or_data () -> list [ User ]:
    return [
        User ( first_name = "John" , last_name = "Lennon" ),
        User ( first_name = "Paul" , last_name = "McCartney" ),
        User ( first_name = "George" , last_name = "Harrison" ),
        User ( first_name = "Ringo" , last_name = "Starr" ),
    ]

@ app . get ( "/admin-list" )
@ jinja . hx ( "user-list.html" , no_data = True )
def htmx_only () -> list [ User ]:
    return [ User ( first_name = "Billy" , last_name = "Shears" )]

Voir l'exemple de travail complet ici.

Modèles personnalisés

Exige: pip install fasthx .

Si vous souhaitez utiliser un moteur de rendu sans intégration FASTHX, vous pouvez facilement construire sur les décorateurs hx() et page() qui vous donnent toutes les fonctionnalités dont vous aurez besoin. Tout ce que vous avez à faire est d'implémenter le protocole HTMLRenderer .

De façon similaire à l'affaire Jinja, hx() ne déclenche que le rendu HTML pour les demandes HTMX, tandis que page() rend inconditionnellement HTML. Voir l'exemple de code ci-dessous:

 from typing import Annotated , Any

from fastapi import Depends , FastAPI , Request
from fasthx import hx , page

# Create the app.
app = FastAPI ()

# Create a dependecy to see that its return value is available in the render function.
def get_random_number () -> int :
    return 4  # Chosen by fair dice roll.

DependsRandomNumber = Annotated [ int , Depends ( get_random_number )]

# Create the render methods: they must always have these three arguments.
# If you're using static type checkers, the type hint of `result` must match
# the return type annotation of the route on which this render method is used.
def render_index ( result : list [ dict [ str , str ]], * , context : dict [ str , Any ], request : Request ) -> str :
    return "<h1>Hello FastHX</h1>"

def render_user_list ( result : list [ dict [ str , str ]], * , context : dict [ str , Any ], request : Request ) -> str :
    # The value of the `DependsRandomNumber` dependency is accessible with the same name as in the route.
    random_number = context [ "random_number" ]
    lucky_number = f"<h1> { random_number } </h1>"
    users = "" . join (( "<ul>" , * ( f"<li> { u [ 'name' ] } </li>" for u in result ), "</ul>" ))
    return f" { lucky_number } n { users } "

@ app . get ( "/" )
@ page ( render_index )
def index () -> None :
    ...

@ app . get ( "/htmx-or-data" )
@ hx ( render_user_list )
def htmx_or_data ( random_number : DependsRandomNumber ) -> list [ dict [ str , str ]]:
    return [{ "name" : "Joe" }]

@ app . get ( "/htmx-only" )
@ hx ( render_user_list , no_data = True )
async def htmx_only ( random_number : DependsRandomNumber ) -> list [ dict [ str , str ]]:
    return [{ "name" : "Joe" }]

Voir l'exemple de travail complet ici.

Exemples externes

Fastapi-Htmx-Tailwind Exemple: un exemple de Jinja2 complexe avec des fonctionnalités telles que la recherche active, le chargement paresseux, les événements de serveur, les déclencheurs HTMX côté serveur personnalisés, les boîtes de dialogue et l'intégration TailwindCSS et Daisyui.