Update example to a new, full app

Author: andystaples

examples/in_memory_backend_example.py

@@ -0,0 +1,95 @@
+# In-Memory Backend Example
+
+This example demonstrates how to structure a Durable Task Python project
+so that orchestrators and activities are defined separately from
+infrastructure code, enabling fast, fully in-process unit tests using the
+in-memory backend.
+
+You can copy this entire folder into a new directory and run it as a
+standalone project.
+
+## Folder Structure
+
+```text
+in_memory_backend_example/
+├── README.md
+├── requirements.txt
+├── src/
+│   ├── __init__.py
+│   ├── workflows.py   # Orchestrators & activities (pure logic, no infra)
+│   └── app.py          # Runs workflows against a real DTS backend
+└── test/
+    ├── __init__.py
+    └── test_workflows.py  # Unit tests using the in-memory backend
+```
+
+### Key ideas
+
+- **[src/workflows.py](src/workflows.py)** — All orchestrator and activity
+  definitions live here. They import only from `durabletask` and have no
+  dependency on a particular backend, making them portable and testable.
+
+- **[src/app.py](src/app.py)** — The entry point that wires up the real
+  Durable Task Scheduler (or emulator) client and worker, registers the
+  workflow functions, and schedules an orchestration.
+
+- **[test/test_workflows.py](test/test_workflows.py)** — Pytest tests that
+  exercise every workflow path using `create_test_backend()`. No sidecar,
+  emulator, or Azure resources are needed.
+
+## Getting Started
+
+1. Copy this folder to a new location and `cd` into it:
+
+   ```bash
+   cd in_memory_backend_example
+   ```
+
+1. Create and activate a virtual environment:
+
+   Bash:
+
+   ```bash
+   python -m venv .venv
+   source .venv/bin/activate
+   ```
+
+   PowerShell:
+
+   ```powershell
+   python -m venv .venv
+   .\.venv\Scripts\Activate.ps1
+   ```
+
+1. Install dependencies:
+
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+## Running the Tests
+
+From the `in_memory_backend_example/` directory:
+
+```bash
+pytest test/
+```
+
+## Running the App Against the Emulator
+
+Start the DTS emulator, then from the `in_memory_backend_example/`
+directory:
+
+```bash
+python -m src.app
+```
+
+## Patterns Demonstrated
+
+| Pattern | Where |
+|---|---|
+| Activity chaining | `process_order` — validate → calculate → pay |
+| Fan-out / fan-in | `process_order` — ship all items in parallel |
+| Sub-orchestration | `order_with_approval` calls `process_order` |
+| Human interaction (external event + timer) | `order_with_approval` — wait for approval or timeout |
+| Error handling | Tests verify validation failures propagate correctly |

examples/in_memory_backend_example/README.md

@@ -0,0 +1,2 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.

examples/in_memory_backend_example/__init__.py

@@ -0,0 +1,4 @@
+durabletask
+durabletask-azuremanaged
+azure-identity
+pytest

examples/in_memory_backend_example/requirements.txt

@@ -0,0 +1,2 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.

examples/in_memory_backend_example/src/__init__.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+"""
+Run the order-processing workflow against a real Durable Task Scheduler backend.
+
+Usage (emulator — no env vars needed):
+    python -m src.app
+
+Usage (Azure):
+    export ENDPOINT=https://<scheduler>.durabletask.io
+    export TASKHUB=<taskhub>
+    python -m src.app
+"""
+
+import os
+
+from azure.identity import DefaultAzureCredential
+
+from durabletask import client
+from durabletask.azuremanaged.client import DurableTaskSchedulerClient
+from durabletask.azuremanaged.worker import DurableTaskSchedulerWorker
+
+from src.workflows import (
+    Order,
+    OrderItem,
+    calculate_total,
+    order_with_approval,
+    process_order,
+    process_payment,
+    send_confirmation,
+    ship_item,
+    validate_order,
+)
+
+
+def main():
+    # Use environment variables if provided, otherwise default to the emulator.
+    taskhub_name = os.getenv("TASKHUB", "default")
+    endpoint = os.getenv("ENDPOINT", "http://localhost:8080")
+
+    print(f"Using taskhub: {taskhub_name}")
+    print(f"Using endpoint: {endpoint}")
+
+    secure_channel = endpoint.startswith("https://")
+    credential = DefaultAzureCredential() if secure_channel else None
+
+    with DurableTaskSchedulerWorker(
+        host_address=endpoint,
+        secure_channel=secure_channel,
+        taskhub=taskhub_name,
+        token_credential=credential,
+    ) as w:
+        # Register all orchestrators and activities
+        w.add_orchestrator(process_order)
+        w.add_orchestrator(order_with_approval)
+        w.add_activity(validate_order)
+        w.add_activity(calculate_total)
+        w.add_activity(process_payment)
+        w.add_activity(send_confirmation)
+        w.add_activity(ship_item)
+        w.start()
+
+        c = DurableTaskSchedulerClient(
+            host_address=endpoint,
+            secure_channel=secure_channel,
+            taskhub=taskhub_name,
+            token_credential=credential,
+        )
+
+        # Build a sample order
+        order = Order(
+            customer="Contoso",
+            items=[
+                OrderItem(name="Widget", quantity=3, unit_price=25.00),
+                OrderItem(name="Gadget", quantity=1, unit_price=99.99),
+            ],
+        )
+
+        # Schedule and run the orchestration
+        instance_id = c.schedule_new_orchestration(process_order, input=order)
+        print(f"Orchestration scheduled with ID: {instance_id}")
+
+        state = c.wait_for_orchestration_completion(instance_id, timeout=60)
+        if state and state.runtime_status == client.OrchestrationStatus.COMPLETED:
+            print(f"Orchestration completed! Result: {state.serialized_output}")
+        elif state:
+            print(f"Orchestration failed: {state.failure_details}")
+        else:
+            print("Orchestration timed out.")
+
+
+if __name__ == "__main__":
+    main()