descargar lightbug_http - descargar el código fuente lightbug

lightbug_http

Datos del sitio web

v0.1.5

Descargar

Chinchazón

? Un marco de mojo http con alas

Descripción general

Lightbug es un marco HTTP simple y dulce para Mojo que se basa en las mejores prácticas de la programación de sistemas, como el Golang Fasthttp y Rust May_minihttp.

Esto aún no está listo para la producción. Nuestro objetivo es mantenernos al día con los nuevos desarrollos en Mojo, pero puede llevar algún tiempo llegar a un punto en que esto sea seguro de usar en aplicaciones del mundo real.

Lightbug actualmente tiene las siguientes características:

¡Networking de Mojo puro! No hay dependencias de Python por defecto
Implementación basada en el servidor y cliente basada en TCP
Asigne su propio manejador personalizado a una ruta
Craft solicitudes y respuestas HTTP con primitivas incorporadas
Todo está completamente escrito, sin funciones def utilizadas

Mira estas bibliotecas de Mojo:

Registro - @Toasty/Stump
CLI y Terminal - @Toasty/Prism, @Toasty/Mog
Fecha/hora - @mojoto/mañana y @tostado/pequeño tiempo

(De vuelta a la cima)

Empezando

La única dependencia dura para lightbug_http es Mojo. Aprenda cómo poner en funcionamiento con Mojo en el sitio web modular. Una vez que tenga un proyecto Mojo configurado localmente,

Agregue el canal mojo-community a su mojoproject.toml , por ejemplo:

[ project ]
channels = [ " conda-forge " , " https://conda.modular.com/max " , " https://repo.prefix.dev/mojo-community " ]

Agregue lightbug_http como dependencia:

[ dependencies ]
lightbug_http = " >=0.1.5 "

Ejecute magic install en la raíz de su proyecto, donde se encuentra mojoproject.toml

Lightbug ahora debe instalarse como una dependencia. Puede importar todas las importaciones predeterminadas a la vez, por ejemplo:

 from lightbug_http import *

o importar estructuras y funciones individuales, por ejemplo

 from lightbug_http.service import HTTPService
from lightbug_http.http import HTTPRequest, HTTPResponse, OK , NotFound

Hay algunos manejadores predeterminados con los que puedes jugar:

 from lightbug_http.service import Printer # prints request details to console
from lightbug_http.service import Welcome # serves an HTML file with an image (currently requires manually adding files to static folder, details below)
from lightbug_http.service import ExampleRouter # serves /, /first, /second, and /echo routes

Agregue su controlador en lightbug. Al pasar una estructura que satisface el siguiente rasgo:

 trait HTTPService :
 fn func ( inout self , req : HTTPRequest) raises -> HTTPResponse:
     ...

Por ejemplo, para hacer un servicio Printer que imprima algunos detalles sobre la solicitud de consola:

 from lightbug_http import *

 @value
 struct Printer ( HTTPService ):
     fn func ( inout self , req : HTTPRequest) raises -> HTTPResponse:
         var uri = req.uri
         print ( " Request URI: " , to_string(uri.request_uri))

         var header = req.headers
         print ( " Request protocol: " , req.protocol)
         print ( " Request method: " , req.method)
         print (
             " Request Content-Type: " , to_string(header[HeaderKey. CONTENT_TYPE ])
         )

         var body = req.body_raw
         print ( " Request Body: " , to_string(body))

         return OK(body)

Inicie un servidor escuchando en un puerto con su servicio así.

 from lightbug_http import Welcome, Server

fn main () raises :
    var server = Server()
    var handler = Welcome()
    server.listen_and_serve( " 0.0.0.0:8080 " , handler)

Siéntase libre de cambiar la configuración en listen_and_serve() para servir en un host y puerto en particular.

Ahora envíe una solicitud 0.0.0.0:8080 . Debería ver algunos detalles sobre la solicitud impresa en la consola.

Felicitaciones ? ¡Estás usando Lightbug!

El enrutamiento no está en alcance para esta biblioteca, pero puede configurar fácilmente las rutas usted mismo:

 from lightbug_http import *

@value
struct ExampleRouter ( HTTPService ):
    fn func ( inout self , req : HTTPRequest) raises -> HTTPResponse:
        var body = req.body_raw
        var uri = req.uri

        if uri.path == " / " :
            print ( " I'm on the index path! " )
        if uri.path == " /first " :
            print ( " I'm on /first! " )
        elif uri.path == " /second " :
            print ( " I'm on /second! " )
        elif uri.path == " /echo " :
            print (to_string(body))

        return OK(body)

Planeamos agregar una funcionalidad de enrutamiento más avanzada en una biblioteca futura llamada lightbug_api , vea la hoja de ruta para obtener más detalles.

(De vuelta a la cima)

Servir archivos estáticos

La pantalla de bienvenida predeterminada muestra un ejemplo de cómo servir archivos como imágenes o HTML usando LightBug. Mojo tiene métodos incorporados open , read and read_bytes que puede usar para leer archivos y servirlos en una ruta. Suponiendo que copie un archivo e imagen HTML desde el repositorio de buque de luz en un directorio static en la raíz de su repositorio:

 from lightbug_http import *

@value
struct Welcome ( HTTPService ):
    fn func ( inout self , req : HTTPRequest) raises -> HTTPResponse:
        var uri = req.uri

        if uri.path == " / " :
            var html : Bytes
            with open ( " static/lightbug_welcome.html " , " r " ) as f:
                html = f.read_bytes()
            return OK(html, " text/html; charset=utf-8 " )

        if uri.path == " /logo.png " :
            var image : Bytes
            with open ( " static/logo.png " , " r " ) as f:
                image = f.read_bytes()
            return OK(image, " image/png " )

        return NotFound(uri.path)

Usando el cliente

Cree un archivo, por ejemplo, client.mojo con el siguiente código. Ejecutar magic run mojo client.mojo para ejecutar la solicitud a una URL determinada.

 from lightbug_http import *
from lightbug_http.client import Client

fn test_request ( inout client : Client) raises -> None :
    var uri = URI .parse_raises( " http://httpbin.org/status/404 " )
    var headers = Header( " Host " , " httpbin.org " )

    var request = HTTPRequest(uri, headers)
    var response = client.do(request ^ )

    # print status code
    print ( " Response: " , response.status_code)

    # print parsed headers (only some are parsed for now)
    print ( " Content-Type: " , response.headers[ " Content-Type " ])
    print ( " Content-Length " , response.headers[ " Content-Length " ])
    print ( " Server: " , to_string(response.headers[ " Server " ]))

    print (
        " Is connection set to connection-close? " , response.connection_close()
    )

    # print body
    print (to_string(response.body_raw))


fn main () -> None :
    try :
        var client = Client()
        test_request(client)
    except e:
        print (e)

El cliente puro basado en Mojo está disponible de forma predeterminada. Este cliente también se usa internamente para probar el servidor.

Cambiar entre las implementaciones puras de mojo y python

Por defecto, LightBug utiliza la implementación de Pure Mojo para la red. Para usar la biblioteca socket de Python, simplemente importe el PythonServer en lugar del Server con la siguiente línea:

 from lightbug_http.python.server import PythonServer

Luego puede usar todos los comandos del servidor normal de la misma manera que con el servidor predeterminado. Nota: A partir de septiembre de 2024, PythonServer y PythonClient lanzan un error de compilación al comenzar. Hay un problema abierto para solucionar esto: ¡Bienvenido las contribuciones!

Hoja de ruta

Estamos trabajando en el apoyo a lo siguiente (¡los contribuyentes bienvenidos!):

Soporte de WebSocket
Soporte SSL/HTTPS
Soporte de UDP
Mejor manejo de errores, formulario mejorado/multipart y soporte JSON
Múltiples conexiones simultáneas, paralelización y optimizaciones de rendimiento
Soporte HTTP 2.0/3.0
Conformidad con especificaciones de ASGI

El plan es llegar a un conjunto de funciones similar a los marcos de Python como Starlette, pero con un mejor rendimiento.

Nuestra visión es desarrollar tres bibliotecas, con lightbug_http (este repositorio) como punto de partida:

lightbug_http - Infraestructura HTTP y desarrollo básico de API
lightbug_api - (¡Más tarde en 2024!) Herramientas para hacer que las API fueran rápidas, con soporte para las especificaciones de OpenApi y el diseño impulsado por el dominio
lightbug_web - (Fecha de lanzamiento TBD) Marco web de pila completa para Mojo, similar a NextJS o Sveltekit

La idea es llegar a un punto en el que se pueda escribir toda la base de código de una aplicación web moderna simple en Mojo.

Sin embargo, no hacemos ninguna promesa: esto es solo una visión, y si llegamos o no depende de muchos factores, incluido el apoyo de la comunidad.

Vea los problemas abiertos y envíe los suyos para ayudar a impulsar el desarrollo de Lightbug.

(De vuelta a la cima)

Que contribuye

Las contribuciones son las que hacen que la comunidad de código abierto sea un lugar tan increíble para aprender, inspirar y crear. Cualquier contribución que haga es muy apreciada . Consulte Contriping.MD para obtener más detalles sobre cómo contribuir.

Si tiene una sugerencia que lo mejore, desembolse el repositorio y cree una solicitud de extracción. También puede simplemente abrir un problema con la etiqueta "Mejora". ¡No olvides darle una estrella al proyecto!