standalone activity samples to pair with docs for quickstart

Signed-off-by: Phil Prasek <prasek@gmail.com>

Author: prasek

hello_standalone_activity/README.md

@@ -0,0 +1,115 @@
+# Standalone Activity
+
+This sample shows how to execute Activities directly from a Temporal Client, without a Workflow.
+
+For full documentation, see [Standalone Activities - Python SDK](https://docs.temporal.io/develop/python/standalone-activities).
+
+### Sample directory structure
+
+- [my_activity.py](./my_activity.py) - Activity definition with `@activity.defn`
+- [worker.py](./worker.py) - Worker that registers and runs the Activity
+- [execute_activity.py](./execute_activity.py) - Execute a Standalone Activity and wait for the result
+- [start_activity.py](./start_activity.py) - Start a Standalone Activity, get a handle, then wait for the result
+- [list_activities.py](./list_activities.py) - List Standalone Activity Executions
+- [count_activities.py](./count_activities.py) - Count Standalone Activity Executions
+
+### Quickstart
+
+**1. Start the Temporal dev server**
+
+```bash
+temporal server start-dev
+```
+
+**2. Run the Worker** (in a separate terminal)
+
+```bash
+uv run hello_standalone_activity/worker.py
+```
+
+**3. Execute a Standalone Activity** (in a separate terminal)
+
+Execute and wait for the result:
+
+```bash
+uv run hello_standalone_activity/execute_activity.py
+```
+
+Or use the Temporal CLI:
+
+```bash
+temporal activity execute \
+  --type compose_greeting \
+  --activity-id my-standalone-activity-id \
+  --task-queue my-standalone-activity-task-queue \
+  --start-to-close-timeout 10s \
+  --input '{"greeting": "Hello", "name": "World"}'
+```
+
+**4. Start a Standalone Activity (without waiting)**
+
+Start, get a handle, then wait for the result:
+
+```bash
+uv run hello_standalone_activity/start_activity.py
+```
+
+Or use the Temporal CLI:
+
+```bash
+temporal activity start \
+  --type compose_greeting \
+  --activity-id my-standalone-activity-id \
+  --task-queue my-standalone-activity-task-queue \
+  --start-to-close-timeout 10s \
+  --input '{"greeting": "Hello", "name": "World"}'
+```
+
+**5. List Standalone Activities**
+
+```bash
+uv run hello_standalone_activity/list_activities.py
+```
+
+Or use the Temporal CLI:
+
+```bash
+temporal activity list --query "TaskQueue = 'my-standalone-activity-task-queue'"
+```
+
+Note: `list` and `count` are only available in the [Standalone Activity prerelease CLI](https://github.com/temporalio/cli/releases/tag/v1.6.2-standalone-activity).
+
+**6. Count Standalone Activities**
+
+```bash
+uv run hello_standalone_activity/count_activities.py
+```
+
+Or use the Temporal CLI:
+
+```bash
+temporal activity count --query "TaskQueue = 'my-standalone-activity-task-queue'"
+```
+
+### Temporal Cloud
+
+The same code works against Temporal Cloud - just set environment variables. No code changes needed.
+
+**Connect with mTLS:**
+
+```bash
+export TEMPORAL_ADDRESS=<your-namespace>.<your-account-id>.tmprl.cloud:7233
+export TEMPORAL_NAMESPACE=<your-namespace>.<your-account-id>
+export TEMPORAL_TLS_CLIENT_CERT_PATH='path/to/your/client.pem'
+export TEMPORAL_TLS_CLIENT_KEY_PATH='path/to/your/client.key'
+```
+
+**Connect with an API key:**
+
+```bash
+export TEMPORAL_ADDRESS=<region>.<cloud_provider>.api.temporal.io:7233
+export TEMPORAL_NAMESPACE=<your-namespace>.<your-account-id>
+export TEMPORAL_API_KEY=<your-api-key>
+```
+
+Then run the worker and starter as shown above.

hello_standalone_activity/__init__.py

@@ -0,0 +1,23 @@
+import asyncio
+
+from temporalio.client import Client
+from temporalio.envconfig import ClientConfig
+
+
+async def my_application():
+    connect_config = ClientConfig.load_client_connect_config()
+    connect_config.setdefault("target_host", "localhost:7233")
+    client = await Client.connect(**connect_config)
+
+    resp = await client.count_activities(
+        query="TaskQueue = 'my-standalone-activity-task-queue'",
+    )
+
+    print("Total activities:", resp.count)
+
+    for group in resp.groups:
+        print(f"Group {group.group_values}: {group.count}")
+
+
+if __name__ == "__main__":
+    asyncio.run(my_application())

hello_standalone_activity/count_activities.py

@@ -0,0 +1,26 @@
+import asyncio
+from datetime import timedelta
+
+from temporalio.client import Client
+from temporalio.envconfig import ClientConfig
+
+from hello_standalone_activity.my_activity import ComposeGreetingInput, compose_greeting
+
+
+async def my_application():
+    connect_config = ClientConfig.load_client_connect_config()
+    connect_config.setdefault("target_host", "localhost:7233")
+    client = await Client.connect(**connect_config)
+
+    activity_result = await client.execute_activity(
+        compose_greeting,
+        args=[ComposeGreetingInput("Hello", "World")],
+        id="my-standalone-activity-id",
+        task_queue="my-standalone-activity-task-queue",
+        start_to_close_timeout=timedelta(seconds=10),
+    )
+    print(f"Activity result: {activity_result}")
+
+
+if __name__ == "__main__":
+    asyncio.run(my_application())

hello_standalone_activity/execute_activity.py

@@ -0,0 +1,23 @@
+import asyncio
+
+from temporalio.client import Client
+from temporalio.envconfig import ClientConfig
+
+
+async def my_application():
+    connect_config = ClientConfig.load_client_connect_config()
+    connect_config.setdefault("target_host", "localhost:7233")
+    client = await Client.connect(**connect_config)
+
+    activities = client.list_activities(
+        query="TaskQueue = 'my-standalone-activity-task-queue'",
+    )
+
+    async for info in activities:
+        print(
+            f"ActivityID: {info.activity_id}, Type: {info.activity_type}, Status: {info.status}"
+        )
+
+
+if __name__ == "__main__":
+    asyncio.run(my_application())

hello_standalone_activity/list_activities.py

@@ -0,0 +1,15 @@
+from dataclasses import dataclass
+
+from temporalio import activity
+
+
+@dataclass
+class ComposeGreetingInput:
+    greeting: str
+    name: str
+
+
+@activity.defn
+def compose_greeting(input: ComposeGreetingInput) -> str:
+    activity.logger.info("Running activity with parameter %s" % input)
+    return f"{input.greeting}, {input.name}!"

hello_standalone_activity/my_activity.py

@@ -0,0 +1,31 @@
+import asyncio
+from datetime import timedelta
+
+from temporalio.client import Client
+from temporalio.envconfig import ClientConfig
+
+from hello_standalone_activity.my_activity import ComposeGreetingInput, compose_greeting
+
+
+async def my_application():
+    connect_config = ClientConfig.load_client_connect_config()
+    connect_config.setdefault("target_host", "localhost:7233")
+    client = await Client.connect(**connect_config)
+
+    # Start the activity without waiting for the result
+    activity_handle = await client.start_activity(
+        compose_greeting,
+        args=[ComposeGreetingInput("Hello", "World")],
+        id="my-standalone-activity-id",
+        task_queue="my-standalone-activity-task-queue",
+        start_to_close_timeout=timedelta(seconds=10),
+    )
+    print(f"Started activity: {activity_handle.id}")
+
+    # Wait for the result
+    activity_result = await activity_handle.result()
+    print(f"Activity result: {activity_result}")
+
+
+if __name__ == "__main__":
+    asyncio.run(my_application())

hello_standalone_activity/start_activity.py

@@ -0,0 +1,26 @@
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+
+from temporalio.client import Client
+from temporalio.envconfig import ClientConfig
+from temporalio.worker import Worker
+
+from hello_standalone_activity.my_activity import compose_greeting
+
+
+async def main():
+    connect_config = ClientConfig.load_client_connect_config()
+    connect_config.setdefault("target_host", "localhost:7233")
+    client = await Client.connect(**connect_config)
+    worker = Worker(
+        client,
+        task_queue="my-standalone-activity-task-queue",
+        activities=[compose_greeting],
+        activity_executor=ThreadPoolExecutor(5),
+    )
+    print("worker running...", end="", flush=True)
+    await worker.run()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())