Guillotina: A High-Performance Async Python Framework for APIs

Guillotina is an advanced open-source Python framework designed for high-performance API development. It is built on top of asyncio, making it an excellent choice for developers looking to create scalable, asynchronous applications. Designed with scalability and extendability in mind, Guillotina provides powerful tools to handle data storage, request processing, and API endpoints effortlessly.

Key Features of Guillotina

• Asynchronous and non-blocking operations using Python’s asyncio.
• Support for JSON and binary data through robust storage mechanisms.
• Highly customizable RESTful API capabilities.
• Optimized for high-performance scenarios.
• Integration with ZODB and relational databases.

Exploring Guillotina APIs with Code Examples

Let us dive into some of the most useful APIs provided by Guillotina and showcase them with code examples.

1. Creating a Guillotina Application

Example: Setting up a basic Guillotina application.

    from guillotina import app_settings
    from guillotina.commands import run
    from guillotina.interfaces import IApplication

    async def create_app(root):
        app = await root.make_application(name="my-app", settings=app_settings)
        return app

    if __name__ == '__main__':
        run(create_app)

2. Defining a Simple Content Type

Example: Adding a custom content type dynamically.

    from guillotina import configure
    from guillotina.interfaces import IItem

    @configure.contenttype(
        schema=IItem,
        type_name="MyCustomType",
        behaviors=["guillotina.behaviors.dublincore.IDublinCore"])
    class MyCustomType(Item):
        pass

3. Implementing a Custom API Endpoint

Example: Creating a new endpoint to fetch data.

    from guillotina import configure
    from guillotina.interfaces import IContainer
    from guillotina.api.service import Service

    @configure.service(
        method="GET",
        context=IContainer,
        permission="guillotina.AccessContent",
        name="@custom-endpoint")
    class CustomEndpoint(Service):

        async def __call__(self):
            return {"message": "Hello from Guillotina!"}

4. Working with Database Transactions

Example: Performing database transactions asynchronously.

    from guillotina.db.transaction import get_transaction

    async def perform_database_actions(request):
        txn = get_transaction(request)
        await txn.commit()

5. Middleware Support

Example: Adding custom middleware to process requests.

    from guillotina.middlewares import Middleware

    class CustomMiddleware(Middleware):

        async def __call__(self, request, handler):
            print("Request received:", request)
            response = await handler(request)
            return response

Building a Sample Application with Guillotina APIs

Here’s an example application that utilizes some of the above APIs to create a fully functional API-driven service:

    from guillotina import aiohttp
    from guillotina.async_app import App

    async def create_api_service():
        app = App()
        
        @app.router.add_route.override(
            method="GET", path="/hello", name="hello")
        async def hello_world(request):
            return aiohttp.web.json_response({"message": "Welcome to Guillotina!"})

        return app

    if __name__ == "__main__":
        import asyncio
        loop = asyncio.get_event_loop()
        loop.run_until_complete(create_api_service())

In this basic app, we define a custom endpoint, set up an API structure, and utilize middleware to intercept requests. Guillotina makes it easy to expand with additional functionalities as needed.

Conclusion

Guillotina is a powerful, async-friendly option for developers seeking performance and flexibility in their API design. With a robust set of features and extensive customization capabilities combined with straightforward syntax, Guillotina is a must-try for Python developers building modern web services.