Python quickstart

Setup your app folder
mkdir hello-reboot && cd hello-reboot

Install Reboot

python3 -m venv ./.venv && source .venv/bin/activate && pip install reboot

Create a .proto file

mkdir -p ./api/hello/v1 && touch ./api/hello/v1/hello.proto

Define your durable state data types and operations

syntax = "proto3";

package hello.v1;

import "rbt/v1alpha1/options.proto";

message Hello {
  option (rbt.v1alpha1.state) = {};
  repeated string messages = 1;
}

service HelloInterface {
  rpc Messages(MessagesRequest) returns (MessagesResponse) {
    option (rbt.v1alpha1.method).reader = {};
  }

  rpc Send(SendRequest) returns (SendResponse) {
    option (rbt.v1alpha1.method).writer = {};
  }
}

message MessagesRequest {}

message MessagesResponse {
  repeated string messages = 1;
}

message SendRequest {
  string message = 1;
}

message SendResponse {}

Create .py implementation file

mkdir -p ./backend/src && touch ./backend/src/hello_servicer.py

Implement HelloServicer

from hello.v1.hello_rbt import (
    Hello,
    MessagesRequest,
    MessagesResponse,
    SendRequest,
    SendResponse,
)
from reboot.aio.contexts import ReaderContext, WriterContext

class HelloServicer(Hello.Interface):

    async def Messages(
        self,
        context: ReaderContext,
        state: Hello.State,
        request: MessagesRequest,
    ) -> MessagesResponse:
        return MessagesResponse(messages=state.messages)

    async def Send(
        self,
        context: WriterContext,
        state: Hello.State,
        request: SendRequest,
    ) -> SendResponse:
        state.messages.extend([request.message])
        return SendResponse()

Create a main entrypoint
touch ./backend/src/main.py

Implement main.py

import asyncio
from hello.v1.hello_rbt import Hello
from hello_servicer import HelloServicer
from reboot.aio.applications import Application
from reboot.aio.external import ExternalContext

async def initialize(context: ExternalContext):
    hello = Hello.lookup('hello-reboot')

    await hello.idempotently().Send(
        context,
        message='Hello, World!',
    )


async def main():
    application = Application(
        servicers=[HelloServicer],
        initialize=initialize,
    )

    await application.run()


if __name__ == '__main__':
    asyncio.run(main())

Create an .rbtrc file
touch .rbtrc

Add necessary flags to your .rbtrc file

protoc api/
protoc --python=backend/api/

dev run --name=hello
dev run --watch=backend/src/**/*.py
dev run --python
dev run --application=backend/src/main.py

Run your app
rbt dev run

Query your app

curl -XPOST https://dev.localhost.direct:9991/hello.v1.HelloInterface/Messages \
  -H "x-reboot-state-ref:hello.v1.Hello:hello-reboot"

Summary

In this example, you:

Defined a Reboot durable state data type.
Defined and implemented the operations on your data type.
Built your Reboot app and ran it.

This example is somewhat contrived as we only created one instance of your Hello data type, but in practice you are free to make as many of these as you like!

So far, we've covered reader and writer methods but Reboot's real power is in transactions. Learn about transactions and all of the other available method kinds here.

Hopefully, your wheels are starting to spin thinking of all of the possibilities!

Summary

Next steps