Merge branch 'main' into reuse-policy-terminate-existing

Author: mjameswh

README.md

@@ -55,6 +55,7 @@ Some examples require extra dependencies. See each sample's directory for specif
   * [hello_search_attributes](hello/hello_search_attributes.py) - Start workflow with search attributes then change
     while running.
   * [hello_signal](hello/hello_signal.py) - Send signals to a workflow.
+  * [hello update](hello/hello_update.py) - Send a request to and a response from a client to a workflow execution.
 <!-- Keep this list in alphabetical order -->
 * [activity_worker](activity_worker) - Use Python activities from a workflow in another language.
 * [batch_sliding_window](batch_sliding_window) - Batch processing with a sliding window of child workflows.
@@ -69,6 +70,7 @@ Some examples require extra dependencies. See each sample's directory for specif
 * [encryption](encryption) - Apply end-to-end encryption for all input/output.
 * [env_config](env_config) - Load client configuration from TOML files with programmatic overrides.
 * [gevent_async](gevent_async) - Combine gevent and Temporal.
+* [hello_standalone_activity](hello_standalone_activity) - Use activities without using a workflow.
 * [langchain](langchain) - Orchestrate workflows for LangChain.
 * [message_passing/introduction](message_passing/introduction/) - Introduction to queries, signals, and updates.
 * [message_passing/safe_message_handlers](message_passing/safe_message_handlers/) - Safely handling updates and signals.
@@ -84,7 +86,7 @@ Some examples require extra dependencies. See each sample's directory for specif
 * [updatable_timer](updatable_timer) - A timer that can be updated while sleeping.
 * [worker_specific_task_queues](worker_specific_task_queues) - Use unique task queues to ensure activities run on specific workers.
 * [worker_versioning](worker_versioning) - Use the Worker Versioning feature to more easily version your workflows & other code.
-* [worker_multiprocessing](worker_multiprocessing) - Leverage Python multiprocessing to parallelize workflow tasks and other CPU bound operations by running multiple workers. 
+* [worker_multiprocessing](worker_multiprocessing) - Leverage Python multiprocessing to parallelize workflow tasks and other CPU bound operations by running multiple workers.
 
 ## Test
 

batch_sliding_window/sliding_window_workflow.py

@@ -108,6 +108,7 @@ async def _execute(self, input: SlidingWindowWorkflowInput) -> int:
 
             # Start child workflow for this record
             child_id = f"{workflow_id}/{record.id}"
+            self.current_records.add(record.id)
             child_handle = await workflow.start_child_workflow(
                 RecordProcessorWorkflow.run,
                 record,
@@ -117,7 +118,6 @@ async def _execute(self, input: SlidingWindowWorkflowInput) -> int:
             )
 
             self.children_started_by_this_run.append(child_handle)
-            self.current_records.add(record.id)
 
         return await self._continue_as_new_or_complete(input)
 

custom_metric/worker.py

@@ -39,7 +39,7 @@ async def execute_activity(self, input: ExecuteActivityInput):
             unit="duration",
         )
         histogram.record(
-            schedule_to_start, {"workflow_type": activity.info().workflow_type}
+            schedule_to_start, {"workflow_type": activity.info().workflow_type or ""}
         )
         return await self.next.execute_activity(input)
 

hello/README.md

@@ -44,7 +44,7 @@ Replace `hello/hello_activity.py` in the command with any other example filename
 * [hello_search_attributes](hello_search_attributes.py) - Start workflow with search attributes then change while
   running.
 * [hello_signal](hello_signal.py) - Send signals to a workflow.
-* [hello_update](hello_update.py) - Send a request to and a response from a client to a workflow execution.
+* [hello_update](hello_update.py) - **Send a request to and a response from a client to a workflow execution.**
 
 Note: To enable the workflow update, set the `frontend.enableUpdateWorkflowExecution` dynamic config value to true.
 

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}!"