FilesExpand file tree

main

/

hello_activity_method.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

64 lines (50 loc) · 1.89 KB

main

/

hello_activity_method.py

Copy path

Top

File metadata and controls

• Code
• Blame

64 lines (50 loc) · 1.89 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

import asyncio

from datetime import timedelta

from temporalio import activity, workflow

from temporalio.client import Client

from temporalio.envconfig import ClientConfig

from temporalio.worker import Worker

class MyDatabaseClient:

async def run_database_update(self) -> None:

print("Database update executed")

class MyActivities:

def __init__(self, db_client: MyDatabaseClient) -> None:

self.db_client = db_client

@activity.defn

async def do_database_thing(self) -> None:

await self.db_client.run_database_update()

@workflow.defn

class MyWorkflow:

@workflow.run

async def run(self) -> None:

await workflow.execute_activity_method(

MyActivities.do_database_thing,

start_to_close_timeout=timedelta(seconds=10),

)

async def main():

# Start client

config = ClientConfig.load_client_connect_config()

config.setdefault("target_host", "localhost:7233")

client = await Client.connect(**config)

# Create our database client that can then be used in the activity

db_client = MyDatabaseClient()

# Instantiate our class containing state that can be referenced from

# activity methods

my_activities = MyActivities(db_client)

# Run a worker for the workflow

async with Worker(

client,

task_queue="hello-activity-method-task-queue",

workflows=[MyWorkflow],

activities=[my_activities.do_database_thing],

):

# While the worker is running, use the client to run the workflow and

# print out its result. Note, in many production setups, the client

# would be in a completely separate process from the worker.

await client.execute_workflow(

MyWorkflow.run,

id="hello-activity-method-workflow-id",

task_queue="hello-activity-method-task-queue",

)

if __name__ == "__main__":

asyncio.run(main())