A micro web-framework using asyncio coroutines and chained middleware.

Related tags

Web FrameworksGrowler
Overview

Growler

master
Testing Report (Master Branch) Coverage Report (Master Branch) ' Latest PyPI version
dev
Testing Report (Development Branch) Coverage Report (Development Branch)

Growler is a web framework built atop asyncio, the asynchronous library described in PEP 3156 and added to the standard library in python 3.4. It takes a cue from the Connect & Express frameworks in the nodejs ecosystem, using a single application object and series of middleware to process HTTP requests. The custom chain of middleware provides an easy way to implement complex applications.

Installation

Growler is installable via pip:

$ pip install growler

The source can be downloaded/cloned from github at http://github.com/pyGrowler/Growler.

Extras

The pip utility allows packages to provide optional requirements, so features may be installed only upon request. This meshes well with the minimal nature of the Growler project: don't install anything the user doesn't need. That being said, there are (will be) community packages that are blessed by the growler developers (after ensuring they work as expected and are well tested with each version of growler) that will be available as extras directly from the growler package.

For example, if you want to use the popular mako html template engine, you can add support easily by adding it to the list of optionals:

$ pip install growler[mako]

This will automatically install the mako-growler packge, or growler-mako, or whatever it is named - you don't care, it's right there, and it works! Very easy!

The goal here is to provide a super simple method for adding middleware packages that the user can be sure works with that version of growler (i.e. has been tested), and has the blessing of the growler developer(s).

The coolest thing would be to describe your web stack via this command, so if you want mako, coffeescript, and some postgres ORM, your install command would look like growler[mako,coffee,pgorm]; anybody could look at that string and get the birds-eye view of your project.

When multiple extras are available, they will be listed here.

Usage

The core of the framework is the growler.App class, which links the asyncio server to your project's middleware. Middeware can be any callable or coroutine. The App object creates a request and a response object when a client connects and passes the pair to this middleware chain. Note: The middleware are processed in the same order they are specified - this could cause unexpected behavior (errors) if a developer is not careful, so be careful! The middleware can manipulate the request and response, adding features or checking state. If any respond to the client, the middleware chain is finished. This stream/filter model makes it very easy to modularize and extend web applications with many features, backed by the power of python.

Example Usage

import asyncio

from growler import App
from growler.middleware import (Logger, Static, StringRenderer)

loop = asyncio.get_event_loop()

# Construct our application with name GrowlerServer
app = App('GrowlerServer', loop=loop)

# Add some growler middleware to the application
app.use(Logger())
app.use(Static(path='public'))
app.use(StringRenderer("views/"))

# Add some routes to the application
@app.get('/')
def index(req, res):
    res.render("home")

@app.get('/hello')
def hello_world(req, res):
    res.send_text("Hello World!!")

# Create the server - this automatically adds it to the asyncio event loop
Server = app.create_server(host='127.0.0.1', port=8000)

# Tell the event loop to run forever - this will listen to the server's
# socket and wake up the growler application upon each connection
loop.run_forever()

This code creates an application which is identified by 'GrowlerServer' (this name does nothing at this point), and a reference to the event loop. Requests are passed to some middleware provided by the Grower package: Logger, Static, and StringRenderer. Logger simply prints the ip address of the connecting client to stdout. Static will check a request url path against files in views/, if one of the files match, the file type is determined, proper content-type header is set, and the file content is sent. Renderer adds the 'render' method to the response object, allowing any following function to call res.render('/filename'), where filename exists in the "views" directory.

Decorators are used to add endpoints to the application, so requests with path matching '/' will call index(req, res) and requests matching '/hello' will call hello_world(req, res). Because 'app.get' is used, only HTTP GET requests will match these endpoints. Other HTTP 'verbs' (post, put, delete, etc) are available as well as 'all', which matches any method. Verb methods must match a path in full.

The 'use' method takes an optional path parameter (e.g. app.use(Static("public"), '/static')), which calls the middleware anytime the request path begins with the parameter.

The asyncio package provides a Server class which does the low-level socket handling for the developer, this is how your application should be hosted. Calling app.create_server(...) creates an asyncio Server object with the event loop given in app's constructor, and the app as the target for incomming connections; this is the recommended way to setup a server. You can't do much with the server directly, so after creation the event loop must be given control of the thread The easiest way to do this is to use loop.run_forever() after app.create_server(...). Or do it in one line with app.create_server_and_run_forever(...).

Extensions

Growler introduces the virtual namespace growler_ext to which other projects may add their own growler-specific code. Of course, these packages may be imported in the standard way, but Growler provides an autoloading feature via the growler.ext module (note the '.' in place of '_') which will automatically import any packages found in the growler_ext namespace. This not only provides a standard interface for extensions, but allows for different implementations of an interface to be chosen by the environment, rather than hard-coded in. It also can reduce the number of import statements at the beginning of the file. This specialized importer may be imported as a standalone module:

from growler import App, ext

app = App()
app.use(ext.MyGrowlerExtension())
...

or a module to import 'from':

from growler import App
from growler.ext import MyGrowlerExtension

app = App()
app.use(MyGrowlerExtension())
...

This works by replacing the 'real' ext module with an object that will import submodules in the growler_ext namespace automatically. Perhaps unfortunately, because of this there is no way I know of to allow the import growler.ext.my_extension syntax, as this skips the importer object and raises an import error. Users must use the from growler.ext import ... syntax instead.

The best practice for developers to add their middleware to growler is now to put their code in the python module growler_ext/my_extension. This will allow your code to be imported by others via from growler.ext import my_extension or the combination of from growler import ext and ext.my_extension.

An example of an extension is the indexer packge, which hosts an automatically generated index of a filesystem directory. It should implement the best practices of how to write extensions.

More

As it stands, Growler is single threaded, partially implemented, and not fully tested. Any submissions, comments, and issues are greatly appreciated, but I request that you please follow the Growler contributing guide.

The name Growler comes from the beer bottle keeping in line with the theme of giving python micro-web-frameworks fluid container names.

License

Growler is licensed under Apache 2.0.

FPS, fast pluggable server, is a framework designed to compose and run a web-server based on plugins.

FPS, fast pluggable server, is a framework designed to compose and run a web-server based on plugins. It is based on top of fastAPI, uvicorn, typer, and pluggy.

Adrien Delsalle 1 Nov 16, 2021
Quiz Web App with Flask and MongoDB as the Databases

quiz-app Quiz Web Application made with flask and mongodb as the Databases Before you run this application, change the inside MONGODB_URI ( in config.

gibran abdillah 7 Dec 14, 2022
Containers And REST APIs Workshop

Containers & REST APIs Workshop Containers vs Virtual Machines Ferramentas Podman: https://podman.io/ Docker: https://www.docker.com/ IBM CLI: https:/

Vanderlei Munhoz 8 Dec 16, 2021
Pyrin is an application framework built on top of Flask micro-framework to make life easier for developers who want to develop an enterprise application using Flask

Pyrin A rich, fast, performant and easy to use application framework to build apps using Flask on top of it. Pyrin is an application framework built o

Mohamad Nobakht 10 Jan 25, 2022
WAZO REST API for the call management of the C4 infrastructure

wazo-router-calld wazo-router-calld provides REST API for the C4 infrastructure. Installing wazo-router-calld The server is already provided as a part

Wazo Platform 4 Dec 21, 2022
Full duplex RESTful API for your asyncio web apps

TBone TBone makes it easy to develop full-duplex RESTful APIs on top of your asyncio web application or webservice. It uses a nonblocking asynchronous

TBone Framework 37 Aug 07, 2022
Web3.py plugin for using Flashbots' bundle APIs

This library works by injecting a new module in the Web3.py instance, which allows submitting "bundles" of transactions directly to miners. This is done by also creating a middleware which captures c

Georgios Konstantopoulos 294 Jan 04, 2023
Restful API framework wrapped around MongoEngine

Flask-MongoRest A Restful API framework wrapped around MongoEngine. Setup from flask import Flask from flask_mongoengine import MongoEngine from flask

Close 525 Jan 01, 2023
Screaming-fast Python 3.5+ HTTP toolkit integrated with pipelining HTTP server based on uvloop and picohttpparser.

Japronto! There is no new project development happening at the moment, but it's not abandoned either. Pull requests and new maintainers are welcome. I

Paweł Piotr Przeradowski 8.6k Dec 29, 2022
A comprehensive reference for all topics related to building and maintaining microservices

This pandect (πανδέκτης is Ancient Greek for encyclopedia) was created to help you find and understand almost anything related to Microservices that i

Ivan Bilan 64 Dec 09, 2022
A library that makes consuming a RESTful API easier and more convenient

Slumber is a Python library that provides a convenient yet powerful object-oriented interface to ReSTful APIs. It acts as a wrapper around the excellent requests library and abstracts away the handli

Sam Giles 597 Dec 13, 2022
Persistent remote applications for X11; screen sharing for X11, MacOS and MSWindows.

Table of Contents About Installation Usage Help About Xpra is known as "screen for X" : its seamless mode allows you to run X11 programs, usually on a

xpra.org 785 Dec 30, 2022
A Simple Kivy Greeting App

SimpleGreetingApp A Simple Kivy Greeting App This is a very simple GUI App that receives a name text input from the user and returns a "Hello" greetin

Mariya 40 Dec 02, 2022
Fast⚡, simple and light💡weight ASGI micro🔬 web🌏-framework for Python🐍.

NanoASGI Asynchronous Python Web Framework NanoASGI is a fast ⚡ , simple and light 💡 weight ASGI micro 🔬 web 🌏 -framework for Python 🐍 . It is dis

Kavindu Santhusa 8 Jun 16, 2022
Mini Web Framework on MicroPython (Esp8266)

dupgee Dupgee is a mini web framework developed for micro-python(Tested on esp8266). Installation pip install dupgee Create Project dupgee create newp

ahmet kotan 38 Jul 25, 2022
The no-nonsense, minimalist REST and app backend framework for Python developers, with a focus on reliability, correctness, and performance at scale.

The Falcon Web Framework Falcon is a reliable, high-performance Python web framework for building large-scale app backends and microservices. It encou

Falconry 9k Jan 01, 2023
Bablyon 🐍 A small ASGI web framework

A small ASGI web framework that you can make asynchronous web applications using uvicorn with using few lines of code

xArty 8 Dec 07, 2021
Low code web framework for real world applications, in Python and Javascript

Full-stack web application framework that uses Python and MariaDB on the server side and a tightly integrated client side library.

Frappe 4.3k Dec 30, 2022
Bionic is Python Framework for crafting beautiful, fast user experiences for web and is free and open source

Bionic is fast. It's powered core python without any extra dependencies. Bionic offers stateful hot reload, allowing you to make changes to your code and see the results instantly without restarting

⚓ 0 Mar 05, 2022
FastAPI framework, high performance, easy to learn, fast to code, ready for production

FastAPI framework, high performance, easy to learn, fast to code, ready for production Documentation: https://fastapi.tiangolo.com Source Code: https:

Sebastián Ramírez 53k Jan 02, 2023