drakaina

Framework for simple RPC service implementation.

Features

• Serializers layer.
  • json, orjson, ujson and msgpack serializers.
• Generates schemas for documentation in OpenRPC format.
• WSGI protocol implementation
  • CORS middleware
  • JWT Authorization middleware.
  • Compatible with middlewares for others wsgi-frameworks, like as Werkzeug, Flask
• login_required and check_permissions decorators.

Installation and Dependencies

Drakaina may be installed via pip and requires Python 3.8 or higher :

pip install drakaina

Usage Examples

A minimal Drakaina example is:

from drakaina import remote_procedure
from drakaina.wsgi import WSGIHandler

@remote_procedure("hello")
def hello_method(name):
    return f"Hello, {name}!"

"""
>>> from drakaina.rpc_protocols import JsonRPCv2
>>> JsonRPCv2().handle({"jsonrpc": "2.0", "method": "hello", "params": ["🐍 Python"] "id": 1})
{"jsonrpc": "2.0", "result": "Hello, 🐍 Python!", "id": 1}
"""

# Or define WSGI application
app = WSGIHandler(route="/jrpc")

Documentation

Optional requirements

pip install drakaina[jwt, orjson, ujson]

Middlewares

CORS

JWT

Drakaina may be installed via pip and requires Python 3.7 or higher :

pip install drakaina[jwt]

Example of using Drakaina:

from functools import partial
from drakaina import check_permissions
from drakaina import ENV_IS_AUTHENTICATED
from drakaina import ENV_USER_ID
from drakaina import login_required
from drakaina import match_any
from drakaina import remote_procedure
from drakaina.contrib.jwt.middleware import JWTAuthenticationMiddleware
from drakaina.wsgi import WSGIHandler

import user_store


@login_required
@remote_procedure(provide_request=True)
def my_method(request):
    assert request[ENV_IS_AUTHENTICATED]
    return f"Hello Bro ✋! Your ID={request[ENV_USER_ID]}"


@check_permissions(["user_read", "user:admin", "username:johndoe"], match_any)
@remote_procedure
def my_method():
    return "Hello Bro! ✋️"


def get_user(request, payload):
    user_id = request[ENV_USER_ID] or payload["user_id"]
    return user_store.get(id=user_id)


def get_jwt_scopes(request, payload):
    # here `scp` is the key for the scopes value in the token payload
    return payload.get("scp")


app = WSGIHandler(
    middlewares=[
        partial(
            JWTAuthenticationMiddleware,
            secret_phrase="_secret_",
            credentials_required=True,
            auth_scheme="Bearer",
            # token_getter=custom_implementation_get_token,
            user_getter=get_user,
            scopes_getter=get_jwt_scopes,
            # revoke_checker=is_revoked,
        )
    ]
)

Drakaina may be ran with any WSGI-compliant server, such as Gunicorn.

gunicorn main:app

or ran with any ASGI-compliant server

uvicorn main:app2

Using with Django

Create file rpc_views.py in your django application. Define function and wrap it remote_procedure decorator:

from drakaina import remote_procedure

@remote_procedure
def my_method():
    return "Hello, Django Bro! ✋"

Add RPCView class to urlpatterns. The as_view method must accept the autodiscover argument as the name of the remote procedure files.

from django.urls import path
from drakaina.contrib.django.views import RPCView

urlpatterns = [
    ...,
    path("api/", RPCView.as_view(autodiscover="rpc_views")),
]

JWT Authentication in your Django project

Wrap an instance of RPCView with the JWTAuthenticationMiddleware.

from django.urls import path
from drakaina.contrib.django import RPCView, JWTAuthenticationMiddleware

urlpatterns = [
    ...,
    path("api/", JWTAuthenticationMiddleware(
        RPCView.as_view(autodiscover="rpc_views")
    )),
]

Define the parameters in the settings.py file.

...

DRAKAINA_JWT_SECRET_KEY = "__SECRET_KEY__"

...

License

Apache License 2.0

Artwork

"drakaina.png" by Korolko Anastasia is licensed under (CC BY-SA 4.0).