Frameworks

Python
Contenido
Falcon .................................................................................................................................................. 3
Ventajas ........................................................................................................................................... 3
Desventajas ..................................................................................................................................... 3
CubiWeb .............................................................................................................................................. 4
Ventajas ........................................................................................................................................... 4
Desventajas ..................................................................................................................................... 4
Morepath ............................................................................................................................................ 5
Ventajas ........................................................................................................................................... 5
Desventajas ..................................................................................................................................... 5
Sanic .................................................................................................................................................... 5
Ventajas ........................................................................................................................................... 5
Desventajas ..................................................................................................................................... 5
CherryPy .............................................................................................................................................. 6
Ventajas ........................................................................................................................................... 6
Desventajas ..................................................................................................................................... 6
Sugerencias Generales .................................................................................................................... 7
Django ................................................................................................................................................. 7
Ventajas ........................................................................................................................................... 7
¿Qué más puedes hacer? ................................................................................................................ 9
Desventajas ..................................................................................................................................... 9
FLASK ................................................................................................................................................. 10
Ventajas ......................................................................................................................................... 10
Desventajas ................................................................................................................................... 11
Pyramid ............................................................................................................................................. 12
Ventajas ......................................................................................................................................... 12
Bottle ................................................................................................................................................. 13
Ventajas ......................................................................................................................................... 13
Desventajas: .................................................................................................................................. 13
TurboGears ........................................................................................................................................ 14
Ventajas ......................................................................................................................................... 14
Desventajas ................................................................................................................................... 14
Masonite ........................................................................................................................................... 15
 Ventajas ......................................................................................................................................... 15
Web2py ............................................................................................................................................. 16
Ventajas ......................................................................................................................................... 17
Desventajas ................................................................................................................................... 17
Vibora ................................................................................................................................................ 18
Ventajas ......................................................................................................................................... 18
Desventajas ................................................................................................................................... 18
Pecan -DESUSO- .............................................................................................................................. 18
Ventajas ......................................................................................................................................... 18
Desventajas ................................................................................................................................... 18
Muffin -DESUSO- ............................................................................................................................... 19
Ventajas ......................................................................................................................................... 19
Ray -DESUSO- .................................................................................................................................... 19
Ventajas ......................................................................................................................................... 19
Desventajas ................................................................................................................................... 19
Falcon
Falcon es un Framework compatible con WSGI (interfaz de puerta de enlace de servidor
web), diseñado para construir API RESTFUL (estilo de arquitectura también
denominado transferencia de estado representacional), sin requerir dependencias externas
de las propias bibliotecas de código de Python.

Ventajas
• Compatibilidad con ASGI, WSGI y WebSocket
• Soporte asincrónico nativo
• No depende de globales mágicos para el enrutamiento y la gestión de la
administración
• Interfaces estables con énfasis en la compatibilidad con versiones anteriores
• Modelado de API simple a través de enrutamiento RESTFul centralizado
• Base de código ampliable y altamente optimizada
• Fácil acceso a encabezados y cuerpos a través de objetos de solicitud y respuesta
• Procesamiento de solicitudes DRY a través de componentes de middleware
• Cumplimiento estricto de los RFC
• Respuestas de error HTTPS idiomáticas
• Manejo sencillo de excepciones
• Pruebas rápidas con ayudantes y simulacros WSGI/ASGI
• Compatibilidad con CPython 3.5+ y PyPy3.5+

Desventajas
• Características limitadas
• Sin interés para aplicaciones orientadas al usuario
• Se enfoca en servir JSON a través de puntos finales REST
CubiWeb
Es un FrameWork semántico utilizado por los desarrolladores para crear aplicaciones web
mediante la reutilización de componentes.
Este FrameWork se centra completamente en la eficiencia, la reutilización (mediante cubos),
y las soluciones de desarrollo de calidad, es la opción más adecuada para aplicaciones
centradas de datos.
Modelas los datos es el primer paso, como siempre debe ser por que las aplicaciones se
desvanecen, pero los datos llegaron para quedarse. Una vez que se implementa su modelo,
su aplicación CubicWeb se ejecuta y puede agregar de manera incremental funcionalidades
de alto valor para sus usuarios.
Utiliza RQL (Resource Query Language) como lenguaje de consulta, es intuitivo y cercano al
lenguaje empresarial.
Después de que una solicitud RQL haya seleccionado un gráfico de datos, se pueden aplicar
varias vistas para mostrar la información de la manera más relevante. Toda la arquitectura
de CubicWeb está diseñada siguiendo este patrón.

Ventajas
• Seguridad de datos por diseño
• Lenguaje de consulta RQL
• Diversidad de vistas para muestreo de la información
• Almacenamiento de datos eficiente

Desventajas
• PostgreSQL base de datos preferida, por lo que utilizar otra podría traer errores
• Non full-stak
Morepath
Es un micro FrameWork web enfocado en crear aplicaciones web o API’s. La filosofía de
Morepath es el modelo de datos. Por defecto, el marco enruta las URL directamente al
código del modelo, a diferencia de, por ejemplo, Django, que requieren un enrutamiento
URL explicito por parte del desarrollador.
Pero el enrutamiento es a modelos y es flexible, lo que lo hace expresivo.

Ventajas
• Morepath no se interpone en tu camino
• Es extensible, con un mecanismo de anulación y extensión simple, coherente y
universal, que admite código reutilizable.
• Se entiende acerca de la generación de hipervínculos. La web se trata de
hipervínculos y Morepath realmente los conoce.
• Las vistas son funciones simples. Todas las vistas son genéricas.
• Tiene todas las herramientas para desarrollar servicios web REST en la caja

Desventajas
• Non full-stak

Sanic
Es un FramWork web de Python construido uvloop (uvloop es un reemplazo directo y rápido
del bucle de eventos asyncio incorporado) y diseñado para respuestas HTTP rápidas a través
del manejo de solicitudes asincrónicas. El objetivo del proyecto es proporcionar una forma
simple de poner en funcionamiento un servidor HTTP de alto rendimiento que sea fácil de
construir y, en última instancia, escalar.

Ventajas
• Permite el uso de la sintaxys async/await agregada a Python 3.5
• Compatible con ASGI
• Implementarlo con un servidor web ASGI alternativo
• Proyecto mantenido por la comunidad para la comunidad

Desventajas
• Soporte de Windows es actualmente “experimental”
CherryPy
Se presenta como FrameWork web (servidor web) minimalista, con la perspectiva de ofrecer
la creación de una aplicación web con el mínimo de código posible. El proyecto tiene una
larga historia e hizo transición importante entre su segunda y tercera versión.
Permite desarrollar aplicaciones web de la misma manera que lo haría con cualquier otro
programa de Python orientado a objetos. Esto da como resultado un código fuente más
pequeño desarrollado en menos tiempo.
CherryPy puede ser un servidor web en sí mismo o puede iniciarse a través de
cualquier entorno compatible con WSGI. No se ocupa de tareas como la creación de
plantillas para la representación de salida o el acceso de back-end. El marco es extensible
con filtros, que se llaman en puntos definidos en el procesamiento de solicitud/respuesta.

Ventajas
• Orientado a objetos
• Rápido y Fiable
• Utiliza un adaptador mod_python nativo
• Múltiples servidores HTTP
• Herramientas integradas para almacenamiento (Cache, codificación, sesiones,
autorización).
• Conjunto de pruebas

Desventajas
• Non full-stak
Sugerencias Generales
• Si está buscando comenzar rápidamente con una solución bien establecida donde los
recursos serán fáciles de encontrar, use Django o Flask
• Si le gusta comenzar poco a poco y comprender (o controlar) todas las piezas de su
aplicación, explore Pyramid, Flask o CherryPy
• Si está creando una API o un microservicio que deberá tener un alto rendimiento,
consulte Falcon, o Sanic.
• Si es un programador principiante o simplemente está aprendiendo a hacer
desarrollo web, web2py o Bottle son formas amigables y fáciles de comenzar.
• Si está buscando explorar marcos emergentes con nuevas ideas y formas de hacer las
cosas, consulte Masonite.

Django

Django es un framework web de alto nivel que permite el desarrollo rápido de sitios web seguros y
mantenibles. Desarrollado por programadores experimentados, Django se encarga de gran parte de
las complicaciones del desarrollo web, por lo que puedes concentrarte en escribir tu aplicación sin
necesidad de reinventar la rueda. Es gratuito y de código abierto, tiene una comunidad próspera y
activa, una gran documentación y muchas opciones de soporte gratuito y de pago.

Ventajas:
Completo

Django sigue la filosofía "Baterías incluidas" y provee casi todo lo que los desarrolladores
quisieran que tenga "de fábrica". Porque todo lo que necesitas es parte de un único
"producto", todo funciona a la perfección, sigue principios de diseño consistentes y tiene
una amplia y actualizada documentación.

Versátil

Django puede ser (y ha sido) usado para construir casi cualquier tipo de sitio web — desde
sistemas manejadores de contenidos y wikis, hasta redes sociales y sitios de noticias. Puede
funcionar con cualquier framework en el lado del cliente, y puede devolver contenido en
casi cualquier formato (incluyendo HTML, RSS feeds, JSON, XML, etc). ¡El sitio que estás
leyendo actualmente está basado en Django!

Internamente, mientras ofrece opciones para casi cualquier funcionalidad que desees
(distintos motores de base de datos, motores de plantillas, etc.), también puede ser
extendido para usar otros componentes si es necesario.
Seguro

Django ayuda a los desarrolladores evitar varios errores comunes de seguridad al proveer
un framework que ha sido diseñado para "hacer lo correcto" para proteger el sitio web
automáticamente. Por ejemplo, Django, proporciona una manera segura de administrar
cuentas de usuario y contraseñas, evitando así errores comunes como
colocar informaciones de sesión en cookies donde es vulnerable (en lugar de eso las cookies
solo contienen una clave y los datos se almacenan en la base de datos) o se almacenan
directamente las contraseñas en un hash de contraseñas.

Un hash de contraseña es un valor de longitud fija creado al enviar la contraseña a

una cryptographic hash function. Django puede validar si la contraseña ingresada es
correcta enviándola a través de una función hash y comparando la salida con el valor hash
almacenado. Sin embargo debido a la naturaleza "unidireccional" de la función, incluso si un
valor hash almacenado se ve comprometido es difícil para un atacante resolver la
contraseña original.

Django permite protección contra algunas vulnerabilidades de forma predeterminada,

incluida la inyección SQL, scripts entre sitios, falsificación de solicitudes entre sitios y
clickjacking (consulte Seguridad de sitios web para obtener más detalles sobre dichos
ataques).

Escalable

Django usa un componente basado en la arquitectura “shared-nothing” (cada parte de la

arquitectura es independiente de las otras, y por lo tanto puede ser reemplazado o
cambiado si es necesario). Teniendo en cuenta una clara separación entre las diferentes
partes significa que puede escalar para aumentar el tráfico al agregar hardware en cualquier
nivel: servidores de cache, servidores de bases de datos o servidores de aplicación. Algunos
de los sitios más concurridos han escalado a Django para satisfacer sus demandas (por
ejemplo, Instagram y Disqus, por nombrar solo dos).

Mantenible

El código de Django está escrito usando principios y patrones de diseño para fomentar la
creación de código mantenible y reutilizable. En particular, utiliza el principio No te
repitas "Don't Repeat Yourself" (DRY) para que no exista una duplicación innecesaria,
reduciendo la cantidad de código. Django también promueve la agrupación de la
funcionalidad relacionada en "aplicaciones" reutilizables y en un nivel más bajo, agrupa
código relacionado en módulos (siguiendo el patrón Model View Controller (MVC)).

Portable

Django está escrito en Python, el cual se ejecuta en muchas plataformas. Lo que significa
que no está sujeto a ninguna plataforma en particular, y puede ejecutar sus aplicaciones en
muchas distribuciones de Linux, Windows y Mac OS X. Además, Django cuenta con el
respaldo de muchos proveedores de alojamiento web, y que a menudo proporcionan una
infraestructura específica y documentación para el alojamiento de sitios de Django.
¿Qué más puedes hacer?

Las secciones precedentes muestran las principales características que usarás en casi todas
las aplicaciones web: mapeo de URLs, vistas, modelos y plantillas. Sólo unas pocas de las
otras cosas que Django proporciona y que incluyen:

• Formularios: Los formularios HTML se usan para recolectar datos de los usuarios
para su procesamiento en el servidor. Django simplifica la creación, validación y
procesamiento de los formularios.
• Autenticación y permisos de los usuarios: Django incluye un sistema robusto de
autenticación y permisos que ha sido construido con la seguridad en mente.
• Cacheo: La creación dinámica de contenido es mucho más intensiva
computacionalmente (y lenta) que un servicio de contenido estático. Django
proporciona un cacheo flexible de forma que puedes almacenar todo o parte de una
página renderizada para que no sea renderizada nada más que cuando sea
necesario.
• Sitio de Administración: el sitio de administración de Django está incluido por
defecto cuando creas una app usando el esqueleto básico. Esto hace que sea
trivialmente fácil proporcionar una página de administración para que los
administradores puedan crear, editar y visualizar cualquiera de los modelos de datos
de su sitio.
• Serialización de datos: Django hace fácil el serializar y servir tus datos como XML o
JSON. Esto puede ser útil cuando se está creando un servicio web (un sitio web que
sólo sirve datos para ser consumidos por otras aplicaciones o sitios, y que no
presenta en pantalla nada por sí mismo), o cuando se crea un sitio web en el que el
código del lado cliente maneja toda la renderización de los datos.

Desventajas
Entre los inconvenientes que se pueden encontrar al utilizar Django para desarrollar aplicaciones
web con Python podemos destacar su extensa documentación, que a veces puede llegar a
ser confusa y dispersa. También, puede resultar difícil a la hora de realizar API Rest (estilo de
arquitectura software para crear aplicaciones web respetando el protocolo HTTP) o
resultar complejo cuando se trabaja con sockets.
FLASK

Escrito en Python puro, Flask es un marco de micro web construido sobre la base del motor de
plantillas Jinja2 y el kit de herramientas Werkzeug. Está categorizado como un micro-framework, ya
que no requiere ninguna biblioteca o herramienta en particular. Sin embargo, Flask brinda soporte
a extensiones que agregan características a Flask como si fueran parte del propio Flask. Los
programadores pueden aprender la programación de Flask para crear proyectos innovadores.

Micro Framework: Perfecto si se quiere desarrollar una App básica o que se quiera crear de manera
rápida y ágil. Para según qué aplicaciones no se requieren muchas extensiones y con Flask es
suficiente.

Ventajas:
• Incluye un servidor web de desarrollo: Por lo tanto, no requiere una infraestructura con un
servidor web para testar las apps web, simplemente se puede correr un servidor web de
forma sencilla con el que se pueden ir observando los resultados que se van obteniendo.

• Tiene un depurador y soporte integrado para pruebas unitarias: Si hay algún error en el
código que se está creando, se puede depurar ese error y también se pueden ver los valores
de las variables. A su vez, existe la posibilidad de integrar pruebas unitarias.

• Compatibilidad con WSGI: Para servir las páginas web creadas en Python se pueden usar los
servidores web con este protocolo, el WSGI.

• Es compatible con Python3.

• Buen manejo de rutas: Cuando se trabaja con Apps Web hechas en Flask Python se tiene el
controlador que recibe todas las peticiones que hacen los clientes y se tiene que determinar
a qué ruta está accediendo el cliente para ejecutar el código pertinente.

• Soporta de manera nativa el uso de cookies.

• Sin ORMs: No tiene ORMs, pero fácilmente se puede usar una extensión.

• Se pueden usar sesiones.

• Óptima para construir servicios web o aplicaciones de contenido estático.

• Documentación, lista de correos y código de GitHub.
• Open Source que se ampara bajo una licencia BSD.
 Desventajas:

• Su sistema de autenticación de usuarios es muy básico, a comparación del

potente sistema de autenticación que utiliza Django, este puede crear un sistema
de Login API sencillo para aplicaciones más pequeñas.
• Su representación de Plugins no es tan extensa como la tiene Django.
• Es algo complicado a la hora de pruebas unitarias o migraciones.
• El ORM (Mapeo objeto relacional) para conectar con las bases de datos,
SQLAlchemy es externo.
Pyramid

Pyramid es un framework web WSGI de código abierto basado en el patrón arquitectónico Modelo-
Vista-Controlador (MVC) y ahora mantenido por el proyecto Pylons, junto a otros proyectos
relacionados a Python.

Pyramid facilita la escritura de aplicaciones web. Puede comenzar poco a poco con esta aplicación
web de solicitud / respuesta mínima de “hola mundo”. Esto puede llevarlo lejos, especialmente
mientras aprende. A medida que su aplicación crece, Pyramid ofrece muchas características que
hacen que escribir software complejo requiera menos esfuerzo.

Ventajas:

• Sencillez: Pyramid está diseñado para ser fácil de usar. Puede comenzar incluso si no lo
comprende todo. Y cuando esté listo para hacer más, Pyramid estará allí para usted.

• Minimalismo: Por defecto, Pyramid proporciona solo las herramientas básicas necesarias
para casi todas las aplicaciones web: asignación de URL al código, seguridad y servicio de
activos estáticos (archivos como JavaScript y CSS). Las herramientas adicionales brindan
plantillas, integración de bases de datos y más. Pero con Pyramid puedes “pagar solo por lo
que comes” .

• Documentación: Pyramid está comprometido con la documentación completa y

actualizada.

• Velocidad: Pyramid está diseñado para ser notablemente rápido.

• Fiabilidad: Pyramid se desarrolla de forma conservadora y se prueba exhaustivamente.

Nuestro lema es: “Si no se prueba, está roto”.

• Franqueza: Al igual que con Python, el software Pyramid se distribuye bajo una licencia
permisiva de código abierto.
Bottle

Bottle es un micro framework web WSGI rápido, simple y liviano para Python. Se distribuye como
un módulo de archivo único y no tiene dependencias distintas de la Biblioteca estándar de Python.

El framework Bottle pierde algunas características avanzadas y posibles soluciones listas para usar
que se encuentran en otros frameworks (MVC, ORM, validación de formularios, andamios, XML-
RPC).

Aunque es posible agregar estas características y construir aplicaciones complejas con Bottle,
debería considerar usar un framework web de pila completa como Django o Flask.

Ventajas:
‣ Enrutamiento: Solicitudes de mapeo de llamadas de función con soporte para URL limpias y
dinámicas.

‣ Plantillas: Motor de plantillas incorporado rápido y pythonic y soporte para plantillas mako, jinja2
y cheetah.

‣ Utilidades: acceso conveniente a datos de formularios, carga de archivos, cookies, encabezados y

otros metadatos relacionados con HTTP.

‣ Servidor: servidor de desarrollo HTTP incorporado y soporte para pegar, fapws3, bjoern, Google
App Engine, cherrypy o cualquier otro servidor HTTP compatible con WSGI.

Desventajas:
• El inconveniente de usar Bottle puede ser la dificultad de encontrar documentación o
soporte en línea. Además, es bastante difícil establecer proyectos de más de 1.000 líneas.

• Bottle no es parte de la libreria estandar de python

TurboGears
TurboGears, es un framework enfocado hacía los desarrolladores full-stack sobre Pylons, y ahora es
un framework web WSGI independiente capaz de funcionar tanto como un framework full-stack
(como Django) o como un micro framework (como Flask). Originalmente inspirado en RubyOnRails,
se basa en MVC, donde el controlador envía la solicitud a un conjunto de acciones expuestas desde
el propio controlador.

Ventajas:
• Es altamente configurable
• Se desarrolla dentro del proyecto HTT
• Tiene amplia aceptación en la red
• Posee licencia freeware gracias a su amplio nivel de capacitación, su costo y su
compatibilidad con los sistemas operativos.
• Posee código abierto y el fácil de conseguir ayuda y soporte.

Desventajas:
• Este incluye formatos de configuración no estándar
• No cuenta con una buena administración
• Falta de Integración
Masonite

Masonite es un framework web moderno de Python, centrado en el desarrollador full-stack que

utiliza el patrón de arquitectura MVC (Modelo-Vista-Controlador) y viene con una gran cantidad de
funcionalidades preparadas para usar y una arquitectura extremadamente extensible.

Masonite es la herramienta de desarrollo enfocada en el desarrollador con todas las funciones que
necesita para el desarrollo rápido que se merece. Masonite es perfecto para principiantes que
implementan su primera aplicación web o para desarrolladores avanzados y empresas que
necesitan alcanzar la flota completa de funciones disponibles. Una breve lista de las características
disponibles son:

• Soporte de correo para enviar correos electrónicos rápidamente.

• Compatibilidad con colas para acelerar su aplicación mediante el envío de trabajos
para que se ejecuten en una cola o de forma asíncrona.
• Notificaciones para enviar notificaciones a tus usuarios de forma sencilla y eficaz.
• Programación de tareas para ejecutar sus trabajos en un horario (como todos los
días a la medianoche) para que pueda configurar y olvidar sus tareas.
• Eventos que puede escuchar para ejecutar oyentes que realizan sus tareas cuando
ocurren ciertos eventos en su aplicación.

Ventajas
ORM de estilo de registro activo.
Un potente contenedor de IoC para la inyección de dependencias
Soporte de primera clase para pruebas unitarias

Desventajas

Migraciones de bases de datos las cuales deben ser creadas por el desarrollador.
Web2py

Web2py es un framework full-stack de desarrollo web que es software libre y de

código abierto con una estructura de proyecto basada en patrones de modelo-vista-
controlador para el desarrollo rápido de aplicaciones web basadas en bases de
datos rápidas, escalables, seguras y portátiles. Escrito y programado en Python.
Su objetivo principal es dar soporte al desarrollo ágil de software de aplicaciones
web escalables, seguras y portables enfocadas en bases de datos. Web2py está
escrito y programado en lenguaje Python. Dado que web2py fue originalmente
diseñado como una herramienta de enseñanza con énfasis en la facilidad de uso y
despliegue, no tiene ningún archivo de configuración a nivel de proyecto.

Seguridad de alto nivel: Web2py tiene un foco en la seguridad prestando

mecanismos predeterminados seguros, previniendo las vulnerabilidades más
comunes;8 nunca ha tenido reportes de incidentes de seguridad.

• Sistema de Tickets
Cada aplicación web2py viene con un Sistema de seguimiento de incidentes:
✓ Si ocurre un error, es registrado y un ticket es generado para el
usuario. Esto permite seguimiento de errores.
✓ Los errores y el código fuente son solo accesibles por el administrador,
quien puede buscar y recuperar los errores por fecha o IP del cliente.
El código nunca se expone al usuario.

• Planificador de tareas Portable

Cron es un mecanismo para crear y ejecutar tareas recurrentes en segundo
plano. Busca por un archivo crontab en el formato estándar. Hay tres modos
de operación disponibles:
✓ Soft cron: cron las rutinas son revisadas después de servir el
contenido web, no garantiza precisión en su ejecución. (para Apache
CGI/WSGI)
 ✓ Hard cron: un hilo cron se inicia al comenzar web2py. (para Windows
y CherryPy).
✓ System cron: las funciones cron son llamadas desde el sistema
operativo (Unix/Linux).

• Protección del código fuente

Web2py puede compilar las aplicaciones web y estas pueden ser distribuidas
en forma de bytecode, sin el código fuente. Esto ayuda pero no garantiza la
protección del código fuente debido a la existencia de desensambladores y
decompilador para Python con efectividad variada (archivos *.pyc y *.pyo)

• Capa de abstracción de base de datos (DAL)

Web2py implementa una DAL, no un ORM. Un ORM mapea las tablas de
una base de datos en clases y los registros en instancias de estas clases. La
DAL en cambio mapea, de manera transparente, las tablas en instancias de
una clase (Table) y los registros en instancias (DAL Set, DAL Rows, DAL
Fields). Tiene una sintaxis muy similar a un ORM pero es más rápido,10 y
puede manejar casi cualquier expresión SQL. La DAL puede ser usada sin
web2py.

Ventajas
• Es ligero y rápido.
• Ofrece una estructura sencilla, basada en el modelo vista-controlador, que
permite a los usuarios aprender sobre el desarrollo web sin comprometer la
funcionalidad del sistema.
• No necesita instalación ni configuración.
• Sus actualizaciones se realizan de forma incremental, permitiendo una total
compatibilidad entre las nuevas versión y las aplicaciones realizadas
utilizando versiones antiguas.
• Aataca de manera proactiva las cuestiones de seguridad más relevantes
• Ofrece una interfaz administrativa que permite simplificar la creación y
gestión de las aplicaciones.
• Dispone de bastante documentación, así como foros de ayuda.

Desventajas
• Los archivos de modelo y los archivos de controlador no son módulos y el
orden de ejecución es importante (aunque se puede especificar mediante
modelos condicionales).
Vibora

Vibora es un framework de modelo asíncrono similar a Sanic que se inspiró en la

sintaxis de Flask. Sin embargo, el autor del marco reescribió muchas partes como
el motor de plantillas para maximizar el rendimiento; en la actualidad se encuentra
en standby a la espera de una actualización completa.

Ventajas
• Recarga automática
• Soporte HTTP2
• Soporte Brotli (Servidor/Cliente)
• Plantillas compiladas de Cython
• Rutas de usuario compiladas de Cython

Desventajas
• Se encuentra en una etapa temprana de desarrollo.

Pecan -DESUSO-
Pecan está inspirado en CherryPy y TurboGears. Se centra exclusivamente en
mejorar las solicitudes y respuestas HTTP a través de objetos Python y no integra
el manejo de las sesiones o el acceso a las bases de datos.

Ventajas
• Envío de objetos para facilitar el enrutamiento
• Soporte completo para controladores de estilo REST
• Marco de seguridad extensible
• Soporte de lenguaje de plantilla extensible
• Compatibilidad con JSON extensible
• Fácil configuración basada en Python

Desventajas
• No brinda soporte para sesiones o bases de datos listas para usar, se
incluyen tutoriales para integrarlos usted mismo en solo unas pocas líneas
de código.
Muffin -DESUSO-
Muffin es un framework creado sobre el módulo “Asyncio” de la biblioteca estándar
de Python 3.4+. Muffin estaba inspirado en Flask. Los frameworks Muffin son
bastante rápidos y sencillos, lo que es ideal para pequeñas aplicaciones web. Si
está a punto de crear una pequeña aplicación web sin intención de hacerla crecer,
lo mejor sería preferir el marco Muffin Python. La configuración del marco Muffin
Python se puede realizar fácilmente a través de Python 3. Muffin depende de ASGI
Tools y Modconfig y estas distribuciones se instalarán automáticamente durante el
proceso de instalación de Muffin.

Ventajas
• Es un marco simple y rápido.
• Es un extracto de Flask con rutas URL.
• Utiliza PeeWee ORM (Mapeo relacional de objetos).
• Es compatible con ASGI.
• Es compatible con las bibliotecas de Python Asyncio, Trio y Curio.
• Es capaz de manejar WebSockets y eventos del lado del servidor.

Ray -DESUSO-
Ray es un framework para construir API RESTful, similar a Falcon. La publicación
inicial proporciona un código base desde el que comenzar a crear puntos finales,
agregar autenticación y proteger contra clientes maliciosos. Ray es un marco de
ejecución distribuida de alto rendimiento dirigido a aplicaciones de aprendizaje de
refuerzo y aprendizaje automático a gran escala. Logra escalabilidad y tolerancia a
fallas abstrayendo el estado de control del sistema en un almacén de control global
y manteniendo todos los demás componentes sin estado. Utiliza un almacén de
objetos distribuidos de memoria compartida para manejar eficientemente grandes
cantidades de datos a través de la memoria compartida, y utiliza una arquitectura
de programación jerárquica de abajo hacia arriba para lograr una programación de
baja latencia y alto rendimiento. Utiliza una API liviana basada en gráficos de tareas
dinámicas y actores para expresar una amplia gama de aplicaciones de manera
flexible.

Ventajas
• Ejecutar el mismo código en más de una máquina.
• Creación de microservicios y actores que tengan estado y puedan
comunicarse.
• Manejar con gracia las fallas de la máquina .
• Manejo eficiente de objetos grandes y datos numéricos .

Desventajas
• El módulo de multiprocesamiento tiene una capacidad muy limitada