drakaina

{width=200px height=205px}

❗ WIP

Module for simple RPC service implementation

Quickstart

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

pip install drakaina

A minimal Drakaina example is:

from drakaina import remote_procedure
from drakaina.wsgi import WSGIHandler


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


@remote_procedure(name="something.get")
def get_some_string():
    return "You called `something.get`."


@remote_procedure(provide_request=True)
def do_something_with_environ(request):
    return f"You called `do_something_with_environ`. Request: {request}."


@remote_procedure()
def tell_the_middleware_something():
    return "You called `tell_the_middleware_something`. It has a some extra conditions."


async def asynchronous_procedure():
    await asyncio.sleep(5)
    return "Ding-Dong 🔔!"


"""
>>> JsonRPCv2().handle({"jsonrpc": "2.0", "method": "my_method", "id": 1})
or define WSGI application
"""
app = WSGIHandler(route="/jrpc")

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

gunicorn main:app

Features

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

Documentation

Installation

pip install drakaina

Middlewares

CORS

JWT

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

pip install drakaina[jwt]

A minimal Drakaina example is:

from functools import partial
from drakaina import ENV_IS_AUTHENTICATED
from drakaina import ENV_USER_ID
from drakaina import remote_procedure
from drakaina import check_permissions
from drakaina import login_required
from drakaina import match_any
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,
        )
    ]
)

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).