[Release] Synchronize for release (#103)

Author: reboot-dev-bot

bank/backend/src/account_servicer.py

@@ -24,7 +24,7 @@ class AccountServicer(Account.Servicer):
     def authorizer(self):
         return allow()
 
-    async def Open(
+    async def open(
         self,
         context: WriterContext,
         request: OpenRequest,
@@ -35,26 +35,26 @@ async def Open(
 
         # We'd like to send the new customer a welcome email, but that can be
         # done asynchronously, so we schedule it as a task.
-        task_id = await self.ref().schedule().WelcomeEmail(context)
+        task_id = await self.ref().schedule().welcome_email(context)
 
         return OpenResponse(welcome_email_task_id=task_id)
 
-    async def Balance(
+    async def balance(
         self,
         context: ReaderContext,
         request: BalanceRequest,
     ) -> BalanceResponse:
         return BalanceResponse(balance=self.state.balance)
 
-    async def Deposit(
+    async def deposit(
         self,
         context: WriterContext,
         request: DepositRequest,
     ) -> DepositResponse:
         self.state.balance += request.amount
         return DepositResponse(updated_balance=self.state.balance)
 
-    async def Withdraw(
+    async def withdraw(
         self,
         context: WriterContext,
         request: WithdrawRequest,
@@ -67,7 +67,7 @@ async def Withdraw(
         self.state.balance = updated_balance
         return WithdrawResponse(updated_balance=updated_balance)
 
-    async def WelcomeEmail(
+    async def welcome_email(
         self,
         context: WriterContext,
         request: WelcomeEmailRequest,

bank/backend/src/bank_servicer.py

@@ -19,7 +19,7 @@ class BankServicer(Bank.Servicer):
     def authorizer(self):
         return allow()
 
-    async def SignUp(
+    async def sign_up(
         self,
         context: TransactionContext,
         request: SignUpRequest,
@@ -31,7 +31,7 @@ async def SignUp(
         new_account_id = str(uuid.uuid4())
 
         # Let's go create the account.
-        account, _ = await Account.Open(
+        account, _ = await Account.open(
             context,
             new_account_id,
             customer_name=request.customer_name,
@@ -42,15 +42,15 @@ async def SignUp(
 
         return SignUpResponse(account_id=account.state_id)
 
-    async def Transfer(
+    async def transfer(
         self,
         context: TransactionContext,
         request: TransferRequest,
     ) -> TransferResponse:
         from_account = Account.ref(request.from_account_id)
         to_account = Account.ref(request.to_account_id)
 
-        await from_account.Withdraw(context, amount=request.amount)
-        await to_account.Deposit(context, amount=request.amount)
+        await from_account.withdraw(context, amount=request.amount)
+        await to_account.deposit(context, amount=request.amount)
 
         return TransferResponse()

bank/backend/src/main.py

@@ -14,7 +14,7 @@
 async def initialize(context: InitializeContext):
     bank = Bank.ref(SINGLETON_BANK_ID)
 
-    await bank.SignUp(context, customer_name="Initial User")
+    await bank.sign_up(context, customer_name="Initial User")
 
 
 async def main():

bank/backend/tests/account_servicer_test.py

@@ -29,28 +29,28 @@ async def test_basics(self) -> None:
         # Create the state machine by calling its constructor. The fact that the
         # state machine _has_ a constructor means that this step is required
         # before other methods can be called on it.
-        account, _ = await Account.Open(context, customer_name="Alice")
+        account, _ = await Account.open(context, customer_name="Alice")
 
         # We can now call methods on the state machine. It should have a balance
         # of 0.
-        response: BalanceResponse = await account.Balance(context)
+        response: BalanceResponse = await account.balance(context)
         self.assertEqual(response.balance, 0)
 
         # When we deposit money, the balance should go up.
-        await account.Deposit(context, amount=100)
-        response = await account.Balance(context)
+        await account.deposit(context, amount=100)
+        response = await account.balance(context)
         self.assertEqual(response.balance, 100)
 
         # When we withdraw money, the balance should go down.
-        await account.Withdraw(context, amount=60)
-        response = await account.Balance(context)
+        await account.withdraw(context, amount=60)
+        response = await account.balance(context)
         self.assertEqual(response.balance, 40)
 
         # When we withdraw too much money, we should get an error.
         # Use a helper function here to get a code snippet for use in docs.
         async def withdraw():
             try:
-                await account.Withdraw(context, amount=65)
+                await account.withdraw(context, amount=65)
             except Account.WithdrawAborted as aborted:
                 match aborted.error:
                     case OverdraftError(amount=amount):
@@ -67,7 +67,7 @@ async def withdraw():
         self.assertTrue(isinstance(aborted.exception.error, OverdraftError))
         self.assertEqual(aborted.exception.error.amount, 25)
         # ... and the balance shouldn't have changed.
-        response = await account.Balance(context)
+        response = await account.balance(context)
         self.assertEqual(response.balance, 40)
 
     @mock.patch("account_servicer.send_email")
@@ -87,7 +87,7 @@ async def test_send_welcome_email(self, mock_send_email) -> None:
 
         # When we open an account, we expect the user to receive a welcome
         # email.
-        account, open_response = await Account.Open(
+        account, open_response = await Account.open(
             context,
             customer_name="Alice",
         )

bank/backend/tests/bank_servicer_test.py

@@ -26,14 +26,14 @@ async def test_signup(self) -> None:
 
         # The Bank state machine doesn't have a constructor, so we can simply
         # start calling methods on it.
-        response: SignUpResponse = await bank.SignUp(
+        response: SignUpResponse = await bank.sign_up(
             context,
             customer_name="Alice",
         )
 
         # SignUp will have created an Account we can call.
         account = Account.ref(response.account_id)
-        response = await account.Balance(context)
+        response = await account.balance(context)
         self.assertEqual(response.balance, 0)
 
     async def test_transfer(self):
@@ -43,37 +43,37 @@ async def test_transfer(self):
         context = self.rbt.create_external_context(name=f"test-{self.id()}")
         bank = Bank.ref("my-bank")
 
-        alice: SignUpResponse = await bank.SignUp(
+        alice: SignUpResponse = await bank.sign_up(
             context,
             customer_name="Alice",
         )
         alice_account = Account.ref(alice.account_id)
-        bob: SignUpResponse = await bank.SignUp(
+        bob: SignUpResponse = await bank.sign_up(
             context,
             customer_name="Bob",
         )
         bob_account = Account.ref(bob.account_id)
 
         # Alice deposits some money.
-        await alice_account.Deposit(context, amount=100)
-        response: BalanceResponse = await alice_account.Balance(context)
+        await alice_account.deposit(context, amount=100)
+        response: BalanceResponse = await alice_account.balance(context)
         self.assertEqual(response.balance, 100)
 
         # Alice transfers some money to Bob.
-        await bank.Transfer(
+        await bank.transfer(
             context,
             from_account_id=alice.account_id,
             to_account_id=bob.account_id,
             amount=40,
         )
-        response = await alice_account.Balance(context)
+        response = await alice_account.balance(context)
         self.assertEqual(response.balance, 60)
-        response = await bob_account.Balance(context)
+        response = await bob_account.balance(context)
         self.assertEqual(response.balance, 40)
 
         # Bob tries to transfer too much money back to Alice.
         with self.assertRaises(Bank.TransferAborted) as aborted:
-            await bank.Transfer(
+            await bank.transfer(
                 context,
                 from_account_id=bob.account_id,
                 to_account_id=alice.account_id,

hello-constructors/backend/src/hello_servicer.py

@@ -16,22 +16,22 @@ class HelloServicer(Hello.Servicer):
     def authorizer(self):
         return allow()
 
-    async def Create(
+    async def create(
         self,
         context: WriterContext,
         request: CreateRequest,
     ) -> CreateResponse:
         self.state.messages.extend([request.initial_message])
         return CreateResponse()
 
-    async def Messages(
+    async def messages(
         self,
         context: ReaderContext,
         request: MessagesRequest,
     ) -> MessagesResponse:
         return MessagesResponse(messages=self.state.messages)
 
-    async def Send(
+    async def send(
         self,
         context: WriterContext,
         request: SendRequest,

hello-constructors/backend/src/main.py

@@ -12,19 +12,19 @@
 
 async def initialize(context: InitializeContext):
     # Explicitly create the state machine.
-    hello, _ = await Hello.Create(
+    hello, _ = await Hello.create(
         context,
         EXAMPLE_STATE_MACHINE_ID,
         initial_message="Welcome! This message was sent by a constructor.",
     )
 
     # Send a message.
-    await hello.Send(
+    await hello.send(
         context,
         message="This message was sent after construction!",
     )
 
-    messages_response = await hello.Messages(context)
+    messages_response = await hello.messages(context)
     print(
         f"After initialization, the Hello messages are: {messages_response.messages}"
     )

hello-constructors/backend/tests/hello_servicer_test.py

@@ -22,12 +22,12 @@ async def test_hello_constructors(self) -> None:
         # Create the state machine by calling its constructor. The fact that the
         # state machine _has_ a constructor means that this step is required
         # before other methods can be called on it.
-        hello, _ = await Hello.Create(context, initial_message="first message")
+        hello, _ = await Hello.create(context, initial_message="first message")
 
         # Send another message.
-        await hello.Send(context, message="second message")
+        await hello.send(context, message="second message")
 
-        messages_response = await hello.Messages(context)
+        messages_response = await hello.messages(context)
         self.assertEqual(
             messages_response.messages, [
                 "first message",

hello-legacy-grpc/backend/src/main.py

@@ -14,7 +14,7 @@ async def initialize(context: InitializeContext):
     # NOTE: we don't need to `spawn()` because we want to immediately
     # wait for it to complete (this is syntactic sugar for spawning
     # and then awaiting the returned task).
-    await RebootGreeter.ref("my-greeter").Initialize(context)
+    await RebootGreeter.ref("my-greeter").initialize(context)
 
 
 async def main():

hello-legacy-grpc/backend/src/reboot_greeter_servicer.py

@@ -49,7 +49,7 @@ async def _get_deprecated_salutation(self, context: Context) -> str:
             )
             return salutation_response.salutation
 
-    async def Greet(
+    async def greet(
         self,
         context: WriterContext,
         request: GreetRequest,
@@ -66,7 +66,7 @@ async def Greet(
             f"by the Reboot service."
         )
 
-    async def GetSalutation(
+    async def get_salutation(
         self,
         context: ReaderContext,
         request: Empty,
@@ -76,7 +76,7 @@ async def GetSalutation(
         salutation = await self._get_deprecated_salutation(context)
         return GetSalutationResponse(salutation=salutation)
 
-    async def Initialize(
+    async def initialize(
         self,
         context: WorkflowContext,
         request: Empty,