chore: bump hatchet version and clarify readme examples

Author: abelanger5

fast-api-react/README.md

@@ -6,27 +6,36 @@ This is an example project demonstrating how to use Hatchet with FastAPI.
 
 Before running this project, make sure you have the following:
 
-1. Python 3.7 or higher installed on your machine.
+1. Python 3.10 or higher installed on your machine.
 2. Poetry package manager installed. You can install it by running `pip install poetry`, or by following instructions in the [Poetry Docs](https://python-poetry.org/docs/#installation)
 3. (Optional) If you would like to run the example frontend, Node which can be installed from the [node website](https://nodejs.org/en/download)
 
 ## Setup
 
 1. Create a `.env` file in the `./backend` directory and set the required environment variables. This requires the `HATCHET_CLIENT_TOKEN` variable created in the [Getting Started README](../README.md). You will also need, a `OPENAI_API_KEY` which can be created on the [OpenAI Website](https://help.openai.com/en/articles/4936850-where-do-i-find-my-openai-api-key).
 
+**If you're running Hatchet locally without TLS:**
+
 ```
 HATCHET_CLIENT_TLS_STRATEGY=none
 HATCHET_CLIENT_TOKEN="<token>"
 OPENAI_API_KEY="<openai-key>"
 ```
 
+**If you're using Hatchet Cloud:**
+
+```
+HATCHET_CLIENT_TOKEN="<token>"
+OPENAI_API_KEY="<openai-key>"
+```
+
 2. Open a terminal and navigate to the project backend directory (`/fast-api-react/backend`).
 
 3. Run the following command to install the project dependencies:
 
-   ```shell
-   poetry install
-   ```
+```shell
+poetry install
+```
 
 ### Running the API
 

fast-api-react/backend/poetry.lock

@@ -18,7 +18,7 @@ openai = "^1.11.0"
 beautifulsoup4 = "^4.12.3"
 requests = "^2.31.0"
 urllib3 = "2.2.1"
-hatchet-sdk = "0.20.0"
+hatchet-sdk = "^0.26.0"
 
 [build-system]
 requires = ["poetry-core"]

fast-api-react/backend/pyproject.toml

@@ -1,3 +1,4 @@
+import asyncio
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import StreamingResponse
@@ -13,42 +14,42 @@
 load_dotenv()
 
 app = FastAPI()
+
 hatchet = Hatchet()
 
 
 origins = [
-    "http://localhost:3001",
-    "localhost:3001"
+    "http://localhost:3000",
+    "localhost:3000"
 ]
 
 
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],
+    allow_origins=origins,
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"]
 )
 
 
 @app.post("/message")
-def message(data: MessageRequest):
+async def message(data: MessageRequest):
     ''' This endpoint is called by the client to start a message generation workflow. '''
-    messageId = hatchet.client.admin.run_workflow("BasicRagWorkflow", {
+    workflowRun = await hatchet.client.admin.aio.run_workflow("BasicRagWorkflow", {
         "request": data.model_dump()
     })
 
-    # normally, we'd save the workflowRunId to a database and return a reference to the client
-    # for this simple example, we just return the workflowRunId
-
-    return {"messageId": messageId}
+    # normally, we'd save the workflow_run_id to a database and return a reference to the client
+    # for this simple example, we just return the workflow_run_id
 
+    return {"messageId": workflowRun.workflow_run_id}
 
-def event_stream_generator(workflowRunId):
+async def event_stream_generator(workflowRunId):
     ''' This helper function is a generator that yields events from the Hatchet event stream. '''
-    stream = hatchet.client.listener.stream(workflowRunId)
+    workflowRun = hatchet.client.admin.get_workflow_run(workflowRunId)
 
-    for event in stream:
+    async for event in workflowRun.stream():
         ''' you can filter and transform event data here that will be sent to the client'''
         data = json.dumps({
             "type": event.type,
@@ -57,6 +58,15 @@ def event_stream_generator(workflowRunId):
         })
         yield "data: " + data + "\n\n"
 
+    result = await workflowRun.result()
+
+    data = json.dumps({
+        "type": "result",
+        "payload": result,
+        "messageId": workflowRunId
+    })
+
+    yield "data: " + data + "\n\n"
 
 @app.get("/message/{messageId}")
 async def stream(messageId: str):

fast-api-react/backend/src/api/main.py

@@ -6,30 +6,39 @@ This is an example project demonstrating how to use Hatchet with Python.
 
 Before running this project, make sure you have the following:
 
-1. Python 3.7 or higher installed on your machine.
+1. Python 3.10 or higher installed on your machine.
 2. Poetry package manager installed. You can install it by running `pip install poetry`, or by following instructions in the [Poetry Docs](https://python-poetry.org/docs/#installation)
 
 ## Setup
 
 1. Create a `.env` file in the `./backend` directory and set the required environment variables. This requires the `HATCHET_CLIENT_TOKEN` variable created in the [Getting Started README](../README.md). If you would like to try the Generative AI examples in [./src/genai](./src/genai) You will also need, a `OPENAI_API_KEY` which can be created on the [OpenAI Website](https://help.openai.com/en/articles/4936850-where-do-i-find-my-openai-api-key).
 
+**If you're running Hatchet locally without TLS:**
+
 ```
 HATCHET_CLIENT_TLS_STRATEGY=none
 HATCHET_CLIENT_TOKEN="<token>"
 OPENAI_API_KEY="<openai-key>" # (OPTIONAL) only required to run examples in [./src/genai](./src/genai)
 ```
 
+**If you're using Hatchet Cloud:**
+
+```
+HATCHET_CLIENT_TOKEN="<token>"
+OPENAI_API_KEY="<openai-key>" # (OPTIONAL) only required to run examples in [./src/genai](./src/genai)
+```
+
 2. Open a terminal and navigate to the project root directory (`/simple-examples`).
 
 3. Run the following command to install the project dependencies:
 
-   ```shell
-   poetry install
-   ```
+```shell
+poetry install
+```
 
 ### Running the Hatchet Worker
 
-In a separate terminal, start the the Hatchet worker by running the following command:
+Next, start the the Hatchet worker by running the following command:
 
 ```shell
 poetry run hatchet
@@ -50,10 +59,11 @@ The project contains example workflows in the [`./src`](./src) directory. These
 The project includes a variety of basic workflows to demonstrate Hatchet's core capabilities, each showcasing different features:
 
 1. **[Simple Workflow](./src/simple/worker.py)**: Demonstrates a straightforward process flow, showcasing the basics of setting up a workflow in Hatchet.
-2. **[Concurrency Limit Workflow](./src/concurrency_limit/worker.py)**: Shows how to manage concurrency limits within workflows to ensure that only a certain number of instances run simultaneously.
-3. **[Directed Acyclic Graph (DAG) Workflow](./src/dag/worker.py)**: Illustrates setting up workflows with dependencies that form a Directed Acyclic Graph, demonstrating the advanced orchestration capabilities of Hatchet.
-4. **[Manual Trigger Workflow](./src/manual_trigger/worker.py)**: Explains how to initiate workflows manually, offering control over workflow execution triggers.
-5. **[Timeout Workflow](./src/timeout/worker.py)**: Demonstrates handling timeout scenarios within workflows, ensuring that long-running or stalled processes are appropriately managed.
+2. **[Async Workflow](./src/async_workflow/worker.py)**: An example of using `async def` together with `asyncio.sleep`. 
+3. **[Concurrency Limit Workflow](./src/concurrency_limit/worker.py)**: Shows how to manage concurrency limits within workflows to ensure that only a certain number of instances run simultaneously.
+4. **[Directed Acyclic Graph (DAG) Workflow](./src/dag/worker.py)**: Illustrates setting up workflows with dependencies that form a Directed Acyclic Graph, demonstrating the advanced orchestration capabilities of Hatchet.
+5. **[Manual Trigger Workflow](./src/manual_trigger/worker.py)**: Explains how to initiate workflows manually, offering control over workflow execution triggers.
+6. **[Timeout Workflow](./src/timeout/worker.py)**: Demonstrates handling timeout scenarios within workflows, ensuring that long-running or stalled processes are appropriately managed.
 
 #### Generative AI Workflows
 
@@ -62,6 +72,6 @@ For more complex use cases, the project includes examples that integrate with Op
 1. **[Simple Response Generation](./src/genai/simple.py)**: A single-step workflow that makes a request to OpenAI, showcasing how to incorporate AI services into Hatchet workflows.
 2. **[Basic Retrieval Augmented Generation (BasicRag)](./src/genai/basicrag.py)**: A multi-step workflow that involves loading website content with Beautiful Soup, reasoning about the information, and generating a response with OpenAI, demonstrating the potential for complex, AI-driven processes.
 
-### Exposing the workflows via a RestAPI
+### Exposing the workflows via FastAPI
 
 For a more complete example of how you might use Hatchet as part of a deployed production service, check out the [FastAPI Example](../fast-api-react/README.md)

simple-examples/README.md

@@ -14,7 +14,7 @@ python-dotenv = "^1.0.0"
 openai = "^1.12.0"
 beautifulsoup4 = "^4.12.3"
 requests = "^2.31.0"
-hatchet-sdk = "0.20.0"
+hatchet-sdk = "^0.26.0"
 
 [build-system]
 requires = ["poetry-core"]