This sample demonstrates how to use Temporal to run a workflow that periodically sleeps for a number of days.

To run, first see the main [README.md](../../README.md) for prerequisites.

Then create two terminals and `cd` to this directory.

Run the worker in one terminal:

poetry run python worker.py

And execute the workflow in the other terminal:

poetry run python starter.py

This sample will run indefinitely until you send a signal to `complete`. See how to send a signal via Temporal CLI [here](https://docs.temporal.io/cli/workflow#signal).

TASK_QUEUE = "sleep-for-days-task-queue"

from dataclasses import dataclass

from temporalio import activity

class SendEmailInput:

email_msg: str

async def send_email(input: SendEmailInput) -> str:

"""

result = f"Email message: {input.email_msg}, sent"

print(result)

return result

import asyncio

from typing import Optional

import uuid

from temporalio.client import Client

from sleep_for_days import TASK_QUEUE

from sleep_for_days.workflows import (

SleepForDaysWorkflow,

SleepForDaysInput,

)

async def main(client: Optional[Client] = None):

client = client or await Client.connect("localhost:7233")

wf_handle = await client.start_workflow(

SleepForDaysWorkflow.run,

SleepForDaysInput(numOfDays=3),

id=f"sleep-for-days-workflow-id-{uuid.uuid4()}",

task_queue=TASK_QUEUE,

)

# Wait for workflow completion (runs indefinitely until it receives a signal)

print(await wf_handle.result());

if __name__ == "__main__":

asyncio.run(main())

import asyncio

from temporalio.client import Client

from temporalio.worker import Worker

from sleep_for_days import TASK_QUEUE

from sleep_for_days.activities import send_email

from sleep_for_days.workflows import SleepForDaysWorkflow

async def main():

client = await Client.connect("localhost:7233")

worker = Worker(

client,

task_queue=TASK_QUEUE,

workflows=[SleepForDaysWorkflow],

activities=[send_email],

)

await worker.run()

if __name__ == "__main__":

asyncio.run(main())

from datetime import timedelta

from temporalio import workflow

from dataclasses import dataclass

from sleep_for_days.activities import send_email, SendEmailInput

class SleepForDaysInput:

numOfDays: int

class SleepForDaysWorkflow:

def __init__(self) -> None:

self.is_complete = False

@workflow.run

async def run(self, input: SleepForDaysInput) -> str:

while(not self.is_complete):

await workflow.execute_activity(send_email, SendEmailInput(f"{input.numOfDays} until the next email"), start_to_close_timeout=timedelta(seconds=10))

await workflow.sleep(timedelta(days=input.numOfDays))

return "done!"

@workflow.signal

def complete(self):

self.is_complete = True