diff --git a/daprdocs/README.md b/daprdocs/README.md
deleted file mode 100644
index 5213ae21..00000000
--- a/daprdocs/README.md
+++ /dev/null
@@ -1,25 +0,0 @@
-# Dapr Python SDK documentation
-
-This page covers how the documentation is structured for the Dapr Python SDK.
-
-## Dapr Docs
-
-All Dapr documentation is hosted at [docs.dapr.io](https://docs.dapr.io), including the docs for the [Python SDK](https://docs.dapr.io/developing-applications/sdks/python/). Head over there if you want to read the docs.
-
-### Python SDK docs source
-
-Although the docs site code and content is in the [docs repo](https://github.com/dapr/docs), the Python SDK content and images are within the `content` and `static` directories, respectively.
-
-This allows separation of roles and expertise between maintainers, and makes it easy to find the docs files you are looking for.
-
-## Writing Python SDK docs
-
-To get up and running to write Python SDK docs, visit the [docs repo](https://github.com/dapr/docs) to initialize your environment. It will clone both the docs repo and this repo, so you can make changes and see it rendered within the site instantly, as well as commit and PR into this repo.
-
-Make sure to read the [docs contributing guide](https://docs.dapr.io/contributing/contributing-docs/) for information on style/semantics/etc.
-
-## Docs architecture
-
-The docs site is built on [Hugo](https://gohugo.io), which lives in the docs repo. This repo is setup as a git submodule so that when the repo is cloned and initialized, the python repo, along with the docs, are cloned as well.
-
-Then, in the Hugo configuration file, the `daprdocs/content` and `daprdocs/static` directories are redirected to the `daprdocs/developing-applications/sdks/python` and `static/python` directories, respectively. Thus, all the content within this repo is folded into the main docs site.
\ No newline at end of file
diff --git a/daprdocs/content/en/python-sdk-contributing/python-contributing.md b/daprdocs/content/en/python-sdk-contributing/python-contributing.md
deleted file mode 100644
index fe22c10b..00000000
--- a/daprdocs/content/en/python-sdk-contributing/python-contributing.md
+++ /dev/null
@@ -1,27 +0,0 @@
----
-type: docs
-title: "Contributing to the Python SDK"
-linkTitle: "Python SDK"
-weight: 3000
-description: Guidelines for contributing to the Dapr Python SDK
----
-
-When contributing to the [Python SDK](https://github.com/dapr/python-sdk) the following rules and best-practices should be followed.
-
-## Examples
-
-The `examples` directory contains code samples for users to run to try out specific functionality of the various Python SDK packages and extensions. When writing new and updated samples keep in mind:
-
-- All examples should be runnable on Windows, Linux, and MacOS. While Python code is consistent among operating systems, any pre/post example commands should provide options through [tabpane]({{% ref "contributing-docs.md#tabbed-content" %}})
-- Contain steps to download/install any required pre-requisites. Someone coming in with a fresh OS install should be able to start on the example and complete it without an error. Links to external download pages are fine.
-
-## Docs
-
-The `daprdocs` directory contains the markdown files that are rendered into the [Dapr Docs](https://docs.dapr.io) website. When the documentation website is built this repo is cloned and configured so that its contents are rendered with the docs content. When writing docs keep in mind:
-
- - All rules in the [docs guide]({{% ref contributing-docs.md %}}) should be followed in addition to these.
- - All files and directories should be prefixed with `python-` to ensure all file/directory names are globally unique across all Dapr documentation.
-
-## Github Dapr Bot Commands
-
-Checkout the [daprbot documentation](https://docs.dapr.io/contributing/daprbot/) for Github commands you can run in this repo for common tasks. For example, you can run the `/assign` (as a comment on an issue) to assign issues to a user or group of users.
\ No newline at end of file
diff --git a/daprdocs/content/en/python-sdk-docs/_index.md b/daprdocs/content/en/python-sdk-docs/_index.md
deleted file mode 100644
index b8689eb9..00000000
--- a/daprdocs/content/en/python-sdk-docs/_index.md
+++ /dev/null
@@ -1,157 +0,0 @@
----
-type: docs
-title: "Dapr Python SDK"
-linkTitle: "Python"
-weight: 1000
-description: Python SDK packages for developing Dapr applications
-no_list: true
-cascade:
- github_repo: https://github.com/dapr/python-sdk
- github_subdir: daprdocs/content/en/python-sdk-docs
- path_base_for_github_subdir: content/en/developing-applications/sdks/python/
- github_branch: master
----
-
-Dapr offers a variety of subpackages to help with the development of Python applications. Using them you can create Python clients, servers, and virtual actors with Dapr.
-
-## Prerequisites
-
-- [Dapr CLI]({{% ref install-dapr-cli.md %}}) installed
-- Initialized [Dapr environment]({{% ref install-dapr-selfhost.md %}})
-- [Python 3.9+](https://www.python.org/downloads/) installed
-
-## Installation
-
-To get started with the Python SDK, install the main Dapr Python SDK package.
-
-{{< tabpane text=true >}}
-
-{{% tab header="Stable" %}}
-
-```bash
-pip install dapr
-```
-{{% /tab %}}
-
-{{% tab header="Development" %}}
-
-> **Note:** The development package will contain features and behavior that will be compatible with the pre-release version of the Dapr runtime. Make sure to uninstall any stable versions of the Python SDK before installing the dapr-dev package.
-
-```bash
-pip install dapr-dev
-```
-
-{{% /tab %}}
-
-{{< /tabpane >}}
-
-
-## Available subpackages
-
-### SDK imports
-
-Python SDK imports are subpackages included with the main SDK install, but need to be imported when used. The most common imports provided by the Dapr Python SDK are:
-
-
-
-
-
Client
-
Write Python applications to interact with a Dapr sidecar and other Dapr applications, including stateful virtual actors in Python
-
-
-
-
-
-
Actors
-
Create and interact with Dapr's Actor framework.
-
-
-
-
-
-
Conversation
-
Use the Dapr Conversation API (Alpha) for LLM interactions, tools, and multi-turn flows.
-
-
-
-
-
-Learn more about _all_ of the [available Dapr Python SDK imports](https://github.com/dapr/python-sdk/tree/master/dapr).
-
-### SDK extensions
-
-SDK extensions mainly work as utilities for receiving pub/sub events, programatically creating pub/sub subscriptions, and handling input binding events. While you can acheive all of these tasks without an extension, using a Python SDK extension proves convenient.
-
-
-
-
-
gRPC
-
Create Dapr services with the gRPC server extension.
-
-
-
-
-
-
FastAPI
-
Integrate with Dapr Python virtual actors and pub/sub using the Dapr FastAPI extension.
-
-
-
-
-
-
Flask
-
Integrate with Dapr Python virtual actors using the Dapr Flask extension.
-
-
-
-
-
-
Workflow
-
Author workflows that work with other Dapr APIs in Python.
-
-
-
-
-
-Learn more about [the Dapr Python SDK extensions](https://github.com/dapr/python-sdk/tree/master/ext).
-
-## Try it out
-
-Clone the Python SDK repo.
-
-```bash
-git clone https://github.com/dapr/python-sdk.git
-```
-
-Walk through the Python quickstarts, tutorials, and examples to see Dapr in action:
-
-| SDK samples | Description |
-| ----------- | ----------- |
-| [Quickstarts]({{% ref quickstarts %}}) | Experience Dapr's API building blocks in just a few minutes using the Python SDK. |
-| [SDK samples](https://github.com/dapr/python-sdk/tree/master/examples) | Clone the SDK repo to try out some examples and get started. |
-| [Bindings tutorial](https://github.com/dapr/quickstarts/tree/master/tutorials/bindings) | See how Dapr Python SDK works alongside other Dapr SDKs to enable bindings. |
-| [Distributed Calculator tutorial](https://github.com/dapr/quickstarts/tree/master/tutorials/distributed-calculator/python) | Use the Dapr Python SDK to handle method invocation and state persistent capabilities. |
-| [Hello World tutorial](https://github.com/dapr/quickstarts/tree/master/tutorials/hello-world) | Learn how to get Dapr up and running locally on your machine with the Python SDK. |
-| [Hello Kubernetes tutorial](https://github.com/dapr/quickstarts/tree/master/tutorials/hello-kubernetes) | Get up and running with the Dapr Python SDK in a Kubernetes cluster. |
-| [Observability tutorial](https://github.com/dapr/quickstarts/tree/master/tutorials/observability) | Explore Dapr's metric collection, tracing, logging and health check capabilities using the Python SDK. |
-| [Pub/sub tutorial](https://github.com/dapr/quickstarts/tree/master/tutorials/pub-sub) | See how Dapr Python SDK works alongside other Dapr SDKs to enable pub/sub applications. |
-
-
-## More information
-
-
-
-
-
Serialization
-
Learn more about serialization in Dapr SDKs.
-
-
-
-
-
-
PyPI
-
Python Package Index
-
-
-
-
diff --git a/daprdocs/content/en/python-sdk-docs/conversation.md b/daprdocs/content/en/python-sdk-docs/conversation.md
deleted file mode 100644
index db67a6c4..00000000
--- a/daprdocs/content/en/python-sdk-docs/conversation.md
+++ /dev/null
@@ -1,295 +0,0 @@
-title: "Conversation API (Python) – Recommended Usage"
-linkTitle: "Conversation"
-weight: 11000
-type: docs
-description: Recommended patterns for using Dapr Conversation API in Python with and without tools, including multi‑turn flows and safety guidance.
----
-
-The Dapr Conversation API is currently in alpha. This page presents the recommended, minimal patterns to use it effectively with the Python SDK:
-- Plain requests (no tools)
-- Requests with tools (functions as tools)
-- Multi‑turn flows with tool execution
-- Async variants
-- Important safety notes for executing tool calls
-
-## Prerequisites
-
-- [Dapr CLI]({{% ref install-dapr-cli.md %}}) installed
-- Initialized [Dapr environment]({{% ref install-dapr-selfhost.md %}})
-- [Python 3.9+](https://www.python.org/downloads/) installed
-- [Dapr Python package]({{% ref "python#installation" %}}) installed
-- A configured LLM component (for example, OpenAI or Azure OpenAI) in your Dapr environment
-
-For full, end‑to‑end flows and provider setup, see:
-- The SDK examples under Conversation:
- - [TOOL-CALL-QUICKSTART.md](https://github.com/dapr/python-sdk/blob/main/examples/conversation/TOOL-CALL-QUICKSTART.md)
- - [real_llm_providers_example.py](https://github.com/dapr/python-sdk/blob/main/examples/conversation/real_llm_providers_example.py)
-
-## Plain conversation (no tools)
-
-```python
-from dapr.clients import DaprClient
-from dapr.clients.grpc import conversation
-
-# Build a single‑turn Alpha2 input
-user_msg = conversation.create_user_message("What's Dapr?")
-alpha2_input = conversation.ConversationInputAlpha2(messages=[user_msg])
-
-with DaprClient() as client:
- resp = client.converse_alpha2(
- name="echo", # replace with your LLM component name
- inputs=[alpha2_input],
- temperature=1,
- )
-
- for msg in resp.to_assistant_messages():
- if msg.of_assistant.content:
- print(msg.of_assistant.content[0].text)
-```
-
-Key points:
-- Use `conversation.create_user_message` to build messages.
-- Wrap into `ConversationInputAlpha2(messages=[...])` and pass to `converse_alpha2`.
-- Use `response.to_assistant_messages()` to iterate assistant outputs.
-
-## Tools: decorator‑based (recommended)
-
-Decorator-based tools offer a clean, ergonomic approach. Define a function with clear type hints and detail docstring, this is important for the LLM to understand how or when to invoke the tool;
-decorate it with `@conversation.tool`. Registered tools can be passed to the LLM and invoked via tool calls.
-
-```python
-from dapr.clients import DaprClient
-from dapr.clients.grpc import conversation
-
-@conversation.tool
-def get_weather(location: str, unit: str = 'fahrenheit') -> str:
- """Get current weather for a location."""
- # Replace with a real implementation
- return f"Weather in {location} (unit={unit})"
-
-user_msg = conversation.create_user_message("What's the weather in Paris?")
-alpha2_input = conversation.ConversationInputAlpha2(messages=[user_msg])
-
-with DaprClient() as client:
- response = client.converse_alpha2(
- name="openai", # your LLM component
- inputs=[alpha2_input],
- tools=conversation.get_registered_tools(), # tools registered by @conversation.tool
- tool_choice='auto',
- temperature=1,
- )
-
- # Inspect assistant messages, including any tool calls
- for msg in response.to_assistant_messages():
- if msg.of_assistant.tool_calls:
- for tc in msg.of_assistant.tool_calls:
- print(f"Tool call: {tc.function.name} args={tc.function.arguments}")
- elif msg.of_assistant.content:
- print(msg.of_assistant.content[0].text)
-```
-
-Notes:
-- Use `conversation.get_registered_tools()` to collect all `@conversation.tool` decorated functions.
-- The binder validates/coerces params using your function signature. Keep annotations accurate.
-
-## Minimal multi‑turn with tools
-
-This is the go‑to loop for tool‑using conversations:
-
-{{% alert title="Warning" color="warning" %}}
-Do not blindly auto‑execute tool calls returned by the LLM unless you trust all tools registered. Treat tool names and arguments as untrusted input.
-- Validate inputs and enforce guardrails (allow‑listed tools, argument schemas, side‑effect constraints).
-- For async or I/O‑bound tools, prefer `conversation.execute_registered_tool_async(..., timeout=...)` and set conservative timeouts.
-- Consider adding a policy layer or a user confirmation step before execution in sensitive contexts.
-- Log and monitor tool usage; fail closed when validation fails.
-{{% /alert %}}
-
-```python
-from dapr.clients import DaprClient
-from dapr.clients.grpc import conversation
-
-@conversation.tool
-def get_weather(location: str, unit: str = 'fahrenheit') -> str:
- return f"Weather in {location} (unit={unit})"
-
-history: list[conversation.ConversationMessage] = [
- conversation.create_user_message("What's the weather in San Francisco?")]
-
-with DaprClient() as client:
- # Turn 1
- resp1 = client.converse_alpha2(
- name="openai",
- inputs=[conversation.ConversationInputAlpha2(messages=history)],
- tools=conversation.get_registered_tools(),
- tool_choice='auto',
- temperature=1,
- )
-
- # Append assistant messages; execute tool calls; append tool results
- for msg in resp1.to_assistant_messages():
- history.append(msg)
- for tc in msg.of_assistant.tool_calls:
- # IMPORTANT: validate inputs and enforce guardrails in production
- tool_output = conversation.execute_registered_tool(
- tc.function.name, tc.function.arguments
- )
- history.append(
- conversation.create_tool_message(
- tool_id=tc.id, name=tc.function.name, content=str(tool_output)
- )
- )
-
- # Turn 2 (LLM sees tool result)
- history.append(conversation.create_user_message("Should I bring an umbrella?"))
- resp2 = client.converse_alpha2(
- name="openai",
- inputs=[conversation.ConversationInputAlpha2(messages=history)],
- tools=conversation.get_registered_tools(),
- temperature=1,
- )
-
- for msg in resp2.to_assistant_messages():
- history.append(msg)
- if not msg.of_assistant.tool_calls and msg.of_assistant.content:
- print(msg.of_assistant.content[0].text)
-```
-
-Tips:
-- Always append assistant messages to history.
-- Execute each tool call (with validation) and append a tool message with the tool output.
-- The next turn includes these tool results so the LLM can reason with them.
-
-## Functions as tools: alternatives
-
-When decorators aren’t practical, two options exist.
-
-A) Automatic schema from a typed function:
-
-```python
-from enum import Enum
-from dapr.clients.grpc import conversation
-
-class Units(Enum):
- CELSIUS = 'celsius'
- FAHRENHEIT = 'fahrenheit'
-
-def get_weather(location: str, unit: Units = Units.FAHRENHEIT) -> str:
- return f"Weather in {location}"
-
-fn = conversation.ConversationToolsFunction.from_function(get_weather)
-weather_tool = conversation.ConversationTools(function=fn)
-```
-
-B) Manual JSON Schema (fallback):
-
-```python
-from dapr.clients.grpc import conversation
-
-fn = conversation.ConversationToolsFunction(
- name='get_weather',
- description='Get current weather',
- parameters={
- 'type': 'object',
- 'properties': {
- 'location': {'type': 'string'},
- 'unit': {'type': 'string', 'enum': ['celsius', 'fahrenheit']},
- },
- 'required': ['location'],
- },
-)
-weather_tool = conversation.ConversationTools(function=fn)
-```
-
-## Async variant
-
-Use the asynchronous client and async tool execution helpers as needed.
-
-```python
-import asyncio
-from dapr.aio.clients import DaprClient as AsyncDaprClient
-from dapr.clients.grpc import conversation
-
-@conversation.tool
-def get_time() -> str:
- return '2025-01-01T12:00:00Z'
-
-async def main():
- async with AsyncDaprClient() as client:
- msg = conversation.create_user_message('What time is it?')
- inp = conversation.ConversationInputAlpha2(messages=[msg])
- resp = await client.converse_alpha2(
- name='openai', inputs=[inp], tools=conversation.get_registered_tools()
- )
- for m in resp.to_assistant_messages():
- if m.of_assistant.content:
- print(m.of_assistant.content[0].text)
-
-asyncio.run(main())
-```
-
-If you need to execute tools asynchronously (e.g., network I/O), implement async functions and use `conversation.execute_registered_tool_async` with timeouts.
-
-## Safety and validation (must‑read)
-
-An LLM may suggest tool calls. Treat all model‑provided parameters as untrusted input.
-
-Recommendations:
-- Register only trusted functions as tools. Prefer the `@conversation.tool` decorator for clarity and automatic schema generation.
-- Use precise type annotations and docstrings. The SDK converts function signatures to JSON schema and binds parameters with type coercion and rejection of unexpected/invalid fields.
-- Add guardrails for tools that can cause side effects (filesystem, network, subprocess). Consider allow‑lists, sandboxing, and limits.
-- Validate arguments before execution. For example, sanitize file paths or restrict URLs/domains.
-- Consider timeouts and concurrency controls. For async tools, pass a timeout to `execute_registered_tool_async(..., timeout=...)`.
-- Log and monitor tool usage. Fail closed: if validation fails, avoid executing the tool and inform the user safely.
-
-See also inline notes in `dapr/clients/grpc/conversation.py` (e.g., `tool()`, `ConversationTools`, `execute_registered_tool`) for parameter binding and error handling details.
-
-
-## Key helper methods (quick reference)
-
-This section summarizes helper utilities available in dapr.clients.grpc.conversation used throughout the examples.
-
-- create_user_message(text: str) -> ConversationMessage
- - Builds a user role message for Alpha2. Use in history lists.
- - Example: `history.append(conversation.create_user_message("Hello"))`
-
-- create_system_message(text: str) -> ConversationMessage
- - Builds a system message to steer the assistant’s behavior.
- - Example: `history = [conversation.create_system_message("You are a concise assistant.")]`
-
-- create_assistant_message(text: str) -> ConversationMessage
- - Useful for injecting assistant text in tests or controlled flows.
-
-- create_tool_message(tool_id: str, name: str, content: Any) -> ConversationMessage
- - Converts a tool’s output into a tool message the LLM can read next turn.
- - content can be any object; it is stringified safely by the SDK.
- - Example: `history.append(conversation.create_tool_message(tool_id=tc.id, name=tc.function.name, content=conversation.execute_registered_tool(tc.function.name, tc.function.arguments)))`
-
-- get_registered_tools() -> list[ConversationTools]
- - Returns all tools currently registered in the in-process registry.
- - Includes tools created via:
- - @conversation.tool decorator (auto-registered by default), and
- - ConversationToolsFunction.from_function with register=True (default).
- - Pass this list in converse_alpha2(..., tools=...).
-
-- register_tool(name: str, t: ConversationTools) / unregister_tool(name: str)
- - Manually manage the tool registry (e.g., advanced scenarios, tests, cleanup).
- - Names must be unique; unregister to avoid collisions in long-lived processes.
-
-- execute_registered_tool(name: str, params: Mapping|Sequence|str|None) -> Any
- - Synchronously executes a registered tool by name.
- - params accepts kwargs (mapping), args (sequence), JSON string, or None. If a JSON string is provided (as commonly returned by LLMs), it is parsed for you.
- - Parameters are validated and coerced against the function signature/schema; unexpected or invalid fields raise errors.
- - Security: treat params as untrusted; add guardrails for side effects.
-
-- execute_registered_tool_async(name: str, params: Mapping|Sequence|str|None, *, timeout: float|None=None) -> Any
- - Async counterpart. Supports timeouts, which are recommended for I/O-bound tools.
- - Prefer this for async tools or when using the aio client.
-
-- ConversationToolsFunction.from_function(func: Callable, register: bool = True) -> ConversationToolsFunction
- - Derives a JSON schema from a typed Python function (annotations + optional docstring) and optionally registers a tool.
- - Typical usage: `spec = conversation.ConversationToolsFunction.from_function(my_func)`; then either rely on auto-registration or wrap with `ConversationTools(function=spec)` and call `register_tool(spec.name, tool)` or pass `[tool]` directly to `tools=`.
-
-- ConversationResponseAlpha2.to_assistant_messages() -> list[ConversationMessage]
- - Convenience to transform the response outputs into assistant ConversationMessage objects you can append to history directly (including tool_calls when present).
-
-Tip: The @conversation.tool decorator is the easiest way to create a tool. It auto-generates the schema from your function, allows an optional namespace/name override, and auto-registers the tool (you can set register=False to defer registration).
diff --git a/daprdocs/content/en/python-sdk-docs/python-actor.md b/daprdocs/content/en/python-sdk-docs/python-actor.md
deleted file mode 100644
index 22360afd..00000000
--- a/daprdocs/content/en/python-sdk-docs/python-actor.md
+++ /dev/null
@@ -1,130 +0,0 @@
----
-type: docs
-title: "Getting started with the Dapr actor Python SDK"
-linkTitle: "Actor"
-weight: 20000
-description: How to get up and running with the Dapr Python SDK
----
-
-The Dapr actor package allows you to interact with Dapr virtual actors from a Python application.
-
-## Pre-requisites
-
-- [Dapr CLI]({{% ref install-dapr-cli.md %}}) installed
-- Initialized [Dapr environment]({{% ref install-dapr-selfhost.md %}})
-- [Python 3.9+](https://www.python.org/downloads/) installed
-- [Dapr Python package]({{% ref "python#installation" %}}) installed
-
-## Actor interface
-
-The interface defines the actor contract that is shared between the actor implementation and the clients calling the actor. Because a client may depend on it, it typically makes sense to define it in an assembly that is separate from the actor implementation.
-
-```python
-from dapr.actor import ActorInterface, actormethod
-
-class DemoActorInterface(ActorInterface):
- @actormethod(name="GetMyData")
- async def get_my_data(self) -> object:
- ...
-```
-
-## Actor services
-
-An actor service hosts the virtual actor. It is implemented a class that derives from the base type `Actor` and implements the interfaces defined in the actor interface.
-
-Actors can be created using one of the Dapr actor extensions:
- - [FastAPI actor extension]({{% ref python-fastapi.md %}})
- - [Flask actor extension]({{% ref python-flask.md %}})
-
-## Actor client
-
-An actor client contains the implementation of the actor client which calls the actor methods defined in the actor interface.
-
-```python
-import asyncio
-
-from dapr.actor import ActorProxy, ActorId
-from demo_actor_interface import DemoActorInterface
-
-async def main():
- # Create proxy client
- proxy = ActorProxy.create('DemoActor', ActorId('1'), DemoActorInterface)
-
- # Call method on client
- resp = await proxy.GetMyData()
-```
-
-## Sample
-
-Visit [this page](https://github.com/dapr/python-sdk/tree/main/examples/demo_actor) for a runnable actor sample.
-
-
-## Mock Actor Testing
-
-The Dapr Python SDK provides the ability to create mock actors to unit test your actor methods and see how they interact with the actor state.
-
-### Sample Usage
-
-
-```
-from dapr.actor.runtime.mock_actor import create_mock_actor
-
-class MyActor(Actor, MyActorInterface):
- async def save_state(self, data) -> None:
- await self._state_manager.set_state('mystate', data)
- await self._state_manager.save_state()
-
-mock_actor = create_mock_actor(MyActor, "id")
-
-await mock_actor.save_state(5)
-assert mockactor._state_manager._mock_state['mystate'] == 5 #True
-```
-Mock actors are created by passing your actor class and an actor ID (a string) to the create_mock_actor function. This function returns an instance of the actor with many internal methods overridden. Instead of interacting with Dapr for tasks like saving state or managing timers, the mock actor uses in-memory state to simulate these behaviors.
-
-This state can be accessed through the following variables:
-
-**IMPORTANT NOTE: Due to type hinting issues as discussed further down, these variables will not be visible to type hinters/linters/etc, who will think they are invalid variables. You will need to use them with #type: ignore in order to satisfy any such systems.**
-
-- **_state_manager._mock_state()**
-A `[str, object]` dict where all the actor state is stored. Any variable saved via `_state_manager.save_state(key, value)`, or any other statemanager method is stored in the dict as that key, value pair. Any value loaded via `try_get_state` or any other statemanager method is taken from this dict.
-
-- **_state_manager._mock_timers()**
-A `[str, ActorTimerData]` dict which holds the active actor timers. Any actor method which would add or remove a timer adds or pops the appropriate `ActorTimerData` object from this dict.
-
-- **_state_manager._mock_reminders()**
-A [str, ActorReminderData] dict which holds the active actor reminders. Any actor method which would add or remove a timer adds or pops the appropriate ActorReminderData object from this dict.
-
-**Note: The timers and reminders will never actually trigger. The dictionaries exist only so methods that should add or remove timers/reminders can be tested. If you need to test the callbacks they should activate, you should call them directly with the appropriate values:**
-```
-result = await mock_actor.recieve_reminder(name, state, due_time, period, _ttl)
-# Test the result directly or test for side effects (like changing state) by querying `_state_manager._mock_state`
-```
-
-### Usage and Limitations
-
-**To allow for more fine-grained control, the `_on_activate` method will not be called automatically the way it is when Dapr initializes a new Actor instance. You should call it manually as needed as part of your tests.**
-
-**A current limitation of the mock actor system is that it does not call the `_on_pre_actor_method` and `_on_post_actor_method` methods. You can always call these methods manually as part of a test.**
-
-The `__init__`, `register_timer`, `unregister_timer`, `register_reminder`, `unregister_reminder` methods are all overwritten by the MockActor class that gets applied as a mixin via `create_mock_actor`. If your actor itself overwrites these methods, those modifications will themselves be overwritten and the actor will likely not behave as you expect.
-
-*note: `__init__` is a special case where you are expected to define it as*
-```
- def __init__(self, ctx, actor_id):
- super().__init__(ctx, actor_id)
-```
-*Mock actors work fine with this, but if you have added any extra logic into `__init__`, it will be overwritten. It is worth noting that the correct way to apply logic on initialization is via `_on_activate` (which can also be safely used with mock actors) instead of `__init__`.*
-
-*If you have an actor which does override default Dapr actor methods, you can create a custom subclass of the MockActor class (from MockActor.py) which implements whatever custom logic you have along with interacting with `_mock_state`, `_mock_timers`, and `_mock_reminders` as normal, and then applying that custom class as a mixin via a `create_mock_actor` function you define yourself.*
-
-The actor `_runtime_ctx` variable is set to None. All the normal actor methods have been overwritten such as to not call it, but if your code itself interacts directly with `_runtime_ctx`, tests may fail.
-
-The actor _state_manager is overwritten with an instance of `MockStateManager`. This has all the same methods and functionality of the base `ActorStateManager`, except for using the various `_mock` variables for storing data instead of the `_runtime_ctx`. If your code implements its own custom state manager it will be overwritten and tests will likely fail.
-
-### Type Hinting
-
-Because of Python's lack of a unified method for type hinting type intersections (see: [python/typing #213](https://github.com/python/typing/issues/213)), type hinting unfortunately doesn't work with Mock Actors. The return type is type hinted as "instance of Actor subclass T" when it should really be type hinted as "instance of MockActor subclass T" or "instance of type intersection `[Actor subclass T, MockActor]`" (where, it is worth noting, `MockActor` is itself a subclass of `Actor`).
-
-This means that, for example, if you hover over `mockactor._state_manager` in a code editor, it will come up as an instance of ActorStateManager (instead of MockStateManager), and various IDE helper functions (like VSCode's `Go to Definition`, which will bring you to the definition of ActorStateManager instead of MockStateManager) won't work properly.
-
-For now, this issue is unfixable, so it's merely something to be noted because of the confusion it might cause. If in the future it becomes possible to accurately type hint cases like this feel free to open an issue about implementing it.
\ No newline at end of file
diff --git a/daprdocs/content/en/python-sdk-docs/python-client.md b/daprdocs/content/en/python-sdk-docs/python-client.md
deleted file mode 100644
index f03a6a74..00000000
--- a/daprdocs/content/en/python-sdk-docs/python-client.md
+++ /dev/null
@@ -1,601 +0,0 @@
----
-type: docs
-title: "Getting started with the Dapr client Python SDK"
-linkTitle: "Client"
-weight: 10000
-description: How to get up and running with the Dapr Python SDK
----
-
-The Dapr client package allows you to interact with other Dapr applications from a Python application.
-
-{{% alert title="Note" color="primary" %}}
- If you haven't already, [try out one of the quickstarts]({{% ref quickstarts %}}) for a quick walk-through on how to use the Dapr Python SDK with an API building block.
-
-{{% /alert %}}
-
-## Prerequisites
-
-[Install the Dapr Python package]({{% ref "python#installation" %}}) before getting started.
-
-## Import the client package
-
-The `dapr` package contains the `DaprClient`, which is used to create and use a client.
-
-```python
-from dapr.clients import DaprClient
-```
-
-## Initialising the client
-You can initialise a Dapr client in multiple ways:
-
-#### Default values:
-When you initialise the client without any parameters it will use the default values for a Dapr
-sidecar instance (`127.0.0.1:50001`).
-```python
-from dapr.clients import DaprClient
-
-with DaprClient() as d:
- # use the client
-```
-
-#### Specifying an endpoint on initialisation:
-When passed as an argument in the constructor, the gRPC endpoint takes precedence over any
-configuration or environment variable.
-
-```python
-from dapr.clients import DaprClient
-
-with DaprClient("mydomain:50051?tls=true") as d:
- # use the client
-```
-
-#### Configuration options:
-
-##### Dapr Sidecar Endpoints
-You can use the standardised `DAPR_GRPC_ENDPOINT` environment variable to
-specify the gRPC endpoint. When this variable is set, the client can be initialised
-without any arguments:
-
-```bash
-export DAPR_GRPC_ENDPOINT="mydomain:50051?tls=true"
-```
-```python
-from dapr.clients import DaprClient
-
-with DaprClient() as d:
- # the client will use the endpoint specified in the environment variables
-```
-
-The legacy environment variables `DAPR_RUNTIME_HOST`, `DAPR_HTTP_PORT` and `DAPR_GRPC_PORT` are
-also supported, but `DAPR_GRPC_ENDPOINT` takes precedence.
-
-##### Dapr API Token
-If your Dapr instance is configured to require the `DAPR_API_TOKEN` environment variable, you can
-set it in the environment and the client will use it automatically.
-You can read more about Dapr API token authentication [here](https://docs.dapr.io/operations/security/api-token/).
-
-##### Health timeout
-On client initialisation, a health check is performed against the Dapr sidecar (`/healthz/outbound`).
-The client will wait for the sidecar to be up and running before proceeding.
-
-The default healthcheck timeout is 60 seconds, but it can be overridden by setting the `DAPR_HEALTH_TIMEOUT`
-environment variable.
-
-##### Retries and timeout
-
-The Dapr client can retry a request if a specific error code is received from the sidecar. This is
-configurable through the `DAPR_API_MAX_RETRIES` environment variable and is picked up automatically,
-not requiring any code changes.
-The default value for `DAPR_API_MAX_RETRIES` is `0`, which means no retries will be made.
-
-You can fine-tune more retry parameters by creating a `dapr.clients.retry.RetryPolicy` object and
-passing it to the DaprClient constructor:
-
-```python
-from dapr.clients.retry import RetryPolicy
-
-retry = RetryPolicy(
- max_attempts=5,
- initial_backoff=1,
- max_backoff=20,
- backoff_multiplier=1.5,
- retryable_http_status_codes=[408, 429, 500, 502, 503, 504],
- retryable_grpc_status_codes=[StatusCode.UNAVAILABLE, StatusCode.DEADLINE_EXCEEDED, ]
-)
-
-with DaprClient(retry_policy=retry) as d:
- ...
-```
-
-or for actors:
-```python
-factory = ActorProxyFactory(retry_policy=RetryPolicy(max_attempts=3))
-proxy = ActorProxy.create('DemoActor', ActorId('1'), DemoActorInterface, factory)
-```
-
-**Timeout** can be set for all calls through the environment variable `DAPR_API_TIMEOUT_SECONDS`. The default value is 60 seconds.
-
-> Note: You can control timeouts on service invocation separately, by passing a `timeout` parameter to the `invoke_method` method.
-
-## Error handling
-Initially, errors in Dapr followed the [Standard gRPC error model](https://grpc.io/docs/guides/error/#standard-error-model). However, to provide more detailed and informative error messages, in version 1.13 an enhanced error model has been introduced which aligns with the gRPC [Richer error model](https://grpc.io/docs/guides/error/#richer-error-model). In response, the Python SDK implemented `DaprGrpcError`, a custom exception class designed to improve the developer experience.
-It's important to note that the transition to using `DaprGrpcError` for all gRPC status exceptions is a work in progress. As of now, not every API call in the SDK has been updated to leverage this custom exception. We are actively working on this enhancement and welcome contributions from the community.
-
-Example of handling `DaprGrpcError` exceptions when using the Dapr python-SDK:
-
-```python
-try:
- d.save_state(store_name=storeName, key=key, value=value)
-except DaprGrpcError as err:
- print(f'Status code: {err.code()}')
- print(f"Message: {err.message()}")
- print(f"Error code: {err.error_code()}")
- print(f"Error info(reason): {err.error_info.reason}")
- print(f"Resource info (resource type): {err.resource_info.resource_type}")
- print(f"Resource info (resource name): {err.resource_info.resource_name}")
- print(f"Bad request (field): {err.bad_request.field_violations[0].field}")
- print(f"Bad request (description): {err.bad_request.field_violations[0].description}")
-```
-
-
-## Building blocks
-
-The Python SDK allows you to interface with all of the [Dapr building blocks]({{% ref building-blocks %}}).
-
-### Invoke a service
-
-The Dapr Python SDK provides a simple API for invoking services via either HTTP or gRPC (deprecated). The protocol can be selected by setting the `DAPR_API_METHOD_INVOCATION_PROTOCOL` environment variable, defaulting to HTTP when unset. GRPC service invocation in Dapr is deprecated and GRPC proxying is recommended as an alternative.
-
-```python
-from dapr.clients import DaprClient
-
-with DaprClient() as d:
- # invoke a method (gRPC or HTTP GET)
- resp = d.invoke_method('service-to-invoke', 'method-to-invoke', data='{"message":"Hello World"}')
-
- # for other HTTP verbs the verb must be specified
- # invoke a 'POST' method (HTTP only)
- resp = d.invoke_method('service-to-invoke', 'method-to-invoke', data='{"id":"100", "FirstName":"Value", "LastName":"Value"}', http_verb='post')
-```
-
-The base endpoint for HTTP api calls is specified in the `DAPR_HTTP_ENDPOINT` environment variable.
-If this variable is not set, the endpoint value is derived from the `DAPR_RUNTIME_HOST` and `DAPR_HTTP_PORT` variables, whose default values are `127.0.0.1` and `3500` accordingly.
-
-The base endpoint for gRPC calls is the one used for the client initialisation ([explained above](#initialising-the-client)).
-
-
-- For a full guide on service invocation visit [How-To: Invoke a service]({{% ref howto-invoke-discover-services.md %}}).
-- Visit [Python SDK examples](https://github.com/dapr/python-sdk/tree/master/examples/invoke-simple) for code samples and instructions to try out service invocation.
-
-### Save & get application state
-
-```python
-from dapr.clients import DaprClient
-
-with DaprClient() as d:
- # Save state
- d.save_state(store_name="statestore", key="key1", value="value1")
-
- # Get state
- data = d.get_state(store_name="statestore", key="key1").data
-
- # Delete state
- d.delete_state(store_name="statestore", key="key1")
-```
-
-- For a full list of state operations visit [How-To: Get & save state]({{% ref howto-get-save-state.md %}}).
-- Visit [Python SDK examples](https://github.com/dapr/python-sdk/tree/master/examples/state_store) for code samples and instructions to try out state management.
-
-### Query application state (Alpha)
-
-```python
- from dapr import DaprClient
-
- query = '''
- {
- "filter": {
- "EQ": { "state": "CA" }
- },
- "sort": [
- {
- "key": "person.id",
- "order": "DESC"
- }
- ]
- }
- '''
-
- with DaprClient() as d:
- resp = d.query_state(
- store_name='state_store',
- query=query,
- states_metadata={"metakey": "metavalue"}, # optional
- )
-```
-
-- For a full list of state store query options visit [How-To: Query state]({{% ref howto-state-query-api.md %}}).
-- Visit [Python SDK examples](https://github.com/dapr/python-sdk/tree/master/examples/state_store_query) for code samples and instructions to try out state store querying.
-
-### Publish & subscribe
-
-#### Publish messages
-
-```python
-from dapr.clients import DaprClient
-
-with DaprClient() as d:
- resp = d.publish_event(pubsub_name='pubsub', topic_name='TOPIC_A', data='{"message":"Hello World"}')
-```
-
-
-Send [CloudEvents](https://cloudevents.io/) messages with a json payload:
-```python
-from dapr.clients import DaprClient
-import json
-
-with DaprClient() as d:
- cloud_event = {
- 'specversion': '1.0',
- 'type': 'com.example.event',
- 'source': 'my-service',
- 'id': 'myid',
- 'data': {'id': 1, 'message': 'hello world'},
- 'datacontenttype': 'application/json',
- }
-
- # Set the data content type to 'application/cloudevents+json'
- resp = d.publish_event(
- pubsub_name='pubsub',
- topic_name='TOPIC_CE',
- data=json.dumps(cloud_event),
- data_content_type='application/cloudevents+json',
- )
-```
-
-Publish [CloudEvents](https://cloudevents.io/) messages with plain text payload:
-```python
-from dapr.clients import DaprClient
-import json
-
-with DaprClient() as d:
- cloud_event = {
- 'specversion': '1.0',
- 'type': 'com.example.event',
- 'source': 'my-service',
- 'id': "myid",
- 'data': 'hello world',
- 'datacontenttype': 'text/plain',
- }
-
- # Set the data content type to 'application/cloudevents+json'
- resp = d.publish_event(
- pubsub_name='pubsub',
- topic_name='TOPIC_CE',
- data=json.dumps(cloud_event),
- data_content_type='application/cloudevents+json',
- )
-```
-
-
-#### Subscribe to messages
-
-```python
-from cloudevents.sdk.event import v1
-from dapr.ext.grpc import App
-import json
-
-app = App()
-
-# Default subscription for a topic
-@app.subscribe(pubsub_name='pubsub', topic='TOPIC_A')
-def mytopic(event: v1.Event) -> None:
- data = json.loads(event.Data())
- print(f'Received: id={data["id"]}, message="{data ["message"]}"'
- ' content_type="{event.content_type}"',flush=True)
-
-# Specific handler using Pub/Sub routing
-@app.subscribe(pubsub_name='pubsub', topic='TOPIC_A',
- rule=Rule("event.type == \"important\"", 1))
-def mytopic_important(event: v1.Event) -> None:
- data = json.loads(event.Data())
- print(f'Received: id={data["id"]}, message="{data ["message"]}"'
- ' content_type="{event.content_type}"',flush=True)
-```
-
-- For more information about pub/sub, visit [How-To: Publish & subscribe]({{% ref howto-publish-subscribe.md %}}).
-- Visit [Python SDK examples](https://github.com/dapr/python-sdk/tree/master/examples/pubsub-simple) for code samples and instructions to try out pub/sub.
-
-#### Streaming message subscription
-
-You can create a streaming subscription to a PubSub topic using either the `subscribe`
-or `subscribe_handler` methods.
-
-The `subscribe` method returns an iterable `Subscription` object, which allows you to pull messages from the
-stream by using a `for` loop (ex. `for message in subscription`) or by
-calling the `next_message` method. This will block on the main thread while waiting for messages.
-When done, you should call the close method to terminate the
-subscription and stop receiving messages.
-
-The `subscribe_with_handler` method accepts a callback function that is executed for each message
-received from the stream.
-It runs in a separate thread, so it doesn't block the main thread. The callback should return a
-`TopicEventResponse` (ex. `TopicEventResponse('success')`), indicating whether the message was
-processed successfully, should be retried, or should be discarded. The method will automatically
-manage message acknowledgements based on the returned status. The call to `subscribe_with_handler`
-method returns a close function, which should be called to terminate the subscription when you're
-done.
-
-Here's an example of using the `subscribe` method:
-
-```python
-import time
-
-from dapr.clients import DaprClient
-from dapr.clients.grpc.subscription import StreamInactiveError, StreamCancelledError
-
-counter = 0
-
-
-def process_message(message):
- global counter
- counter += 1
- # Process the message here
- print(f'Processing message: {message.data()} from {message.topic()}...')
- return 'success'
-
-
-def main():
- with DaprClient() as client:
- global counter
-
- subscription = client.subscribe(
- pubsub_name='pubsub', topic='TOPIC_A', dead_letter_topic='TOPIC_A_DEAD'
- )
-
- try:
- for message in subscription:
- if message is None:
- print('No message received. The stream might have been cancelled.')
- continue
-
- try:
- response_status = process_message(message)
-
- if response_status == 'success':
- subscription.respond_success(message)
- elif response_status == 'retry':
- subscription.respond_retry(message)
- elif response_status == 'drop':
- subscription.respond_drop(message)
-
- if counter >= 5:
- break
- except StreamInactiveError:
- print('Stream is inactive. Retrying...')
- time.sleep(1)
- continue
- except StreamCancelledError:
- print('Stream was cancelled')
- break
- except Exception as e:
- print(f'Error occurred during message processing: {e}')
-
- finally:
- print('Closing subscription...')
- subscription.close()
-
-
-if __name__ == '__main__':
- main()
-```
-
-And here's an example of using the `subscribe_with_handler` method:
-
-```python
-import time
-
-from dapr.clients import DaprClient
-from dapr.clients.grpc._response import TopicEventResponse
-
-counter = 0
-
-
-def process_message(message):
- # Process the message here
- global counter
- counter += 1
- print(f'Processing message: {message.data()} from {message.topic()}...')
- return TopicEventResponse('success')
-
-
-def main():
- with (DaprClient() as client):
- # This will start a new thread that will listen for messages
- # and process them in the `process_message` function
- close_fn = client.subscribe_with_handler(
- pubsub_name='pubsub', topic='TOPIC_A', handler_fn=process_message,
- dead_letter_topic='TOPIC_A_DEAD'
- )
-
- while counter < 5:
- time.sleep(1)
-
- print("Closing subscription...")
- close_fn()
-
-
-if __name__ == '__main__':
- main()
-```
-
-- For more information about pub/sub, visit [How-To: Publish & subscribe]({{% ref howto-publish-subscribe.md %}}).
-- Visit [Python SDK examples](https://github.com/dapr/python-sdk/tree/main/examples/pubsub-simple) for code samples and instructions to try out streaming pub/sub.
-
-### Conversation (Alpha)
-
-{{% alert title="Note" color="primary" %}}
-The Dapr Conversation API is currently in alpha.
-{{% /alert %}}
-
-Since version 1.15 Dapr offers developers the capability to securely and reliably interact with Large Language Models (LLM) through the [Conversation API]({{% ref conversation-overview.md %}}).
-
-```python
-from dapr.clients import DaprClient
-from dapr.clients.grpc.conversation import ConversationInput
-
-with DaprClient() as d:
- inputs = [
- ConversationInput(content="What's Dapr?", role='user', scrub_pii=True),
- ConversationInput(content='Give a brief overview.', role='user', scrub_pii=True),
- ]
-
- metadata = {
- 'model': 'foo',
- 'key': 'authKey',
- 'cacheTTL': '10m',
- }
-
- response = d.converse_alpha1(
- name='echo', inputs=inputs, temperature=0.7, context_id='chat-123', metadata=metadata
- )
-
- for output in response.outputs:
- print(f'Result: {output.result}')
-```
-
-### Interact with output bindings
-
-```python
-from dapr.clients import DaprClient
-
-with DaprClient() as d:
- resp = d.invoke_binding(binding_name='kafkaBinding', operation='create', data='{"message":"Hello World"}')
-```
-
-- For a full guide on output bindings visit [How-To: Use bindings]({{% ref howto-bindings.md %}}).
-- Visit [Python SDK examples](https://github.com/dapr/python-sdk/tree/main/examples/invoke-binding) for code samples and instructions to try out output bindings.
-
-### Retrieve secrets
-
-```python
-from dapr.clients import DaprClient
-
-with DaprClient() as d:
- resp = d.get_secret(store_name='localsecretstore', key='secretKey')
-```
-
-- For a full guide on secrets visit [How-To: Retrieve secrets]({{% ref howto-secrets.md %}}).
-- Visit [Python SDK examples](https://github.com/dapr/python-sdk/tree/master/examples/secret_store) for code samples and instructions to try out retrieving secrets
-
-### Configuration
-
-#### Get configuration
-
-```python
-from dapr.clients import DaprClient
-
-with DaprClient() as d:
- # Get Configuration
- configuration = d.get_configuration(store_name='configurationstore', keys=['orderId'], config_metadata={})
-```
-
-#### Subscribe to configuration
-
-```python
-import asyncio
-from time import sleep
-from dapr.clients import DaprClient
-
-async def executeConfiguration():
- with DaprClient() as d:
- storeName = 'configurationstore'
-
- key = 'orderId'
-
- # Wait for sidecar to be up within 20 seconds.
- d.wait(20)
-
- # Subscribe to configuration by key.
- configuration = await d.subscribe_configuration(store_name=storeName, keys=[key], config_metadata={})
- while True:
- if configuration != None:
- items = configuration.get_items()
- for key, item in items:
- print(f"Subscribe key={key} value={item.value} version={item.version}", flush=True)
- else:
- print("Nothing yet")
- sleep(5)
-
-asyncio.run(executeConfiguration())
-```
-
-- Learn more about managing configurations via the [How-To: Manage configuration]({{% ref howto-manage-configuration.md %}}) guide.
-- Visit [Python SDK examples](https://github.com/dapr/python-sdk/tree/master/examples/configuration) for code samples and instructions to try out configuration.
-
-### Distributed Lock
-
-```python
-from dapr.clients import DaprClient
-
-def main():
- # Lock parameters
- store_name = 'lockstore' # as defined in components/lockstore.yaml
- resource_id = 'example-lock-resource'
- client_id = 'example-client-id'
- expiry_in_seconds = 60
-
- with DaprClient() as dapr:
- print('Will try to acquire a lock from lock store named [%s]' % store_name)
- print('The lock is for a resource named [%s]' % resource_id)
- print('The client identifier is [%s]' % client_id)
- print('The lock will will expire in %s seconds.' % expiry_in_seconds)
-
- with dapr.try_lock(store_name, resource_id, client_id, expiry_in_seconds) as lock_result:
- assert lock_result.success, 'Failed to acquire the lock. Aborting.'
- print('Lock acquired successfully!!!')
-
- # At this point the lock was released - by magic of the `with` clause ;)
- unlock_result = dapr.unlock(store_name, resource_id, client_id)
- print('We already released the lock so unlocking will not work.')
- print('We tried to unlock it anyway and got back [%s]' % unlock_result.status)
-```
-
-- Learn more about using a distributed lock: [How-To: Use a lock]({{% ref howto-use-distributed-lock.md %}}).
-- Visit [Python SDK examples](https://github.com/dapr/python-sdk/blob/master/examples/distributed_lock) for code samples and instructions to try out distributed lock.
-
-### Cryptography
-
-```python
-from dapr.clients import DaprClient
-
-message = 'The secret is "passw0rd"'
-
-def main():
- with DaprClient() as d:
- resp = d.encrypt(
- data=message.encode(),
- options=EncryptOptions(
- component_name='crypto-localstorage',
- key_name='rsa-private-key.pem',
- key_wrap_algorithm='RSA',
- ),
- )
- encrypt_bytes = resp.read()
-
- resp = d.decrypt(
- data=encrypt_bytes,
- options=DecryptOptions(
- component_name='crypto-localstorage',
- key_name='rsa-private-key.pem',
- ),
- )
- decrypt_bytes = resp.read()
-
- print(decrypt_bytes.decode()) # The secret is "passw0rd"
-```
-
-- For a full list of state operations visit [How-To: Use the cryptography APIs]({{% ref howto-cryptography.md %}}).
-- Visit [Python SDK examples](https://github.com/dapr/python-sdk/tree/master/examples/crypto) for code samples and instructions to try out cryptography
-
-## Related links
-[Python SDK examples](https://github.com/dapr/python-sdk/tree/master/examples)
diff --git a/daprdocs/content/en/python-sdk-docs/python-sdk-extensions/_index.md b/daprdocs/content/en/python-sdk-docs/python-sdk-extensions/_index.md
deleted file mode 100644
index 8b7bc9c5..00000000
--- a/daprdocs/content/en/python-sdk-docs/python-sdk-extensions/_index.md
+++ /dev/null
@@ -1,7 +0,0 @@
----
-type: docs
-title: "Dapr Python SDK extensions"
-linkTitle: "Extensions"
-weight: 30000
-description: Python SDK for developing Dapr applications
----
diff --git a/daprdocs/content/en/python-sdk-docs/python-sdk-extensions/python-fastapi.md b/daprdocs/content/en/python-sdk-docs/python-sdk-extensions/python-fastapi.md
deleted file mode 100644
index 13b6499b..00000000
--- a/daprdocs/content/en/python-sdk-docs/python-sdk-extensions/python-fastapi.md
+++ /dev/null
@@ -1,115 +0,0 @@
----
-type: docs
-title: "Dapr Python SDK integration with FastAPI"
-linkTitle: "FastAPI"
-weight: 200000
-description: How to create Dapr Python virtual actors and pubsub with the FastAPI extension
----
-
-The Dapr Python SDK provides integration with FastAPI using the `dapr-ext-fastapi` extension.
-
-## Installation
-
-You can download and install the Dapr FastAPI extension with:
-
-{{< tabpane text=true >}}
-
-{{% tab header="Stable" %}}
-```bash
-pip install dapr-ext-fastapi
-```
-{{% /tab %}}
-
-{{% tab header="Development" %}}
-{{% alert title="Note" color="warning" %}}
-The development package will contain features and behavior that will be compatible with the pre-release version of the Dapr runtime. Make sure to uninstall any stable versions of the Python SDK extension before installing the `dapr-dev` package.
-{{% /alert %}}
-
-```bash
-pip install dapr-ext-fastapi-dev
-```
-{{% /tab %}}
-
-{{< /tabpane >}}
-
-## Example
-
-### Subscribing to events of different types
-
-```python
-import uvicorn
-from fastapi import Body, FastAPI
-from dapr.ext.fastapi import DaprApp
-from pydantic import BaseModel
-
-class RawEventModel(BaseModel):
- body: str
-
-class User(BaseModel):
- id: int
- name: str
-
-class CloudEventModel(BaseModel):
- data: User
- datacontenttype: str
- id: str
- pubsubname: str
- source: str
- specversion: str
- topic: str
- traceid: str
- traceparent: str
- tracestate: str
- type: str
-
-
-app = FastAPI()
-dapr_app = DaprApp(app)
-
-# Allow handling event with any structure (Easiest, but least robust)
-# dapr publish --publish-app-id sample --topic any_topic --pubsub pubsub --data '{"id":"7", "desc": "good", "size":"small"}'
-@dapr_app.subscribe(pubsub='pubsub', topic='any_topic')
-def any_event_handler(event_data = Body()):
- print(event_data)
-
-# For robustness choose one of the below based on if publisher is using CloudEvents
-
-# Handle events sent with CloudEvents
-# dapr publish --publish-app-id sample --topic cloud_topic --pubsub pubsub --data '{"id":"7", "name":"Bob Jones"}'
-@dapr_app.subscribe(pubsub='pubsub', topic='cloud_topic')
-def cloud_event_handler(event_data: CloudEventModel):
- print(event_data)
-
-# Handle raw events sent without CloudEvents
-# curl -X "POST" http://localhost:3500/v1.0/publish/pubsub/raw_topic?metadata.rawPayload=true -H "Content-Type: application/json" -d '{"body": "345"}'
-@dapr_app.subscribe(pubsub='pubsub', topic='raw_topic')
-def raw_event_handler(event_data: RawEventModel):
- print(event_data)
-
-
-
-if __name__ == "__main__":
- uvicorn.run(app, host="0.0.0.0", port=30212)
-```
-
-### Creating an actor
-
-```python
-from fastapi import FastAPI
-from dapr.ext.fastapi import DaprActor
-from demo_actor import DemoActor
-
-app = FastAPI(title=f'{DemoActor.__name__}Service')
-
-# Add Dapr Actor Extension
-actor = DaprActor(app)
-
-@app.on_event("startup")
-async def startup_event():
- # Register DemoActor
- await actor.register_actor(DemoActor)
-
-@app.get("/GetMyData")
-def get_my_data():
- return "{'message': 'myData'}"
-```
diff --git a/daprdocs/content/en/python-sdk-docs/python-sdk-extensions/python-flask.md b/daprdocs/content/en/python-sdk-docs/python-sdk-extensions/python-flask.md
deleted file mode 100644
index b4ec58f9..00000000
--- a/daprdocs/content/en/python-sdk-docs/python-sdk-extensions/python-flask.md
+++ /dev/null
@@ -1,60 +0,0 @@
----
-type: docs
-title: "Dapr Python SDK integration with Flask"
-linkTitle: "Flask"
-weight: 300000
-description: How to create Dapr Python virtual actors with the Flask extension
----
-
-The Dapr Python SDK provides integration with Flask using the `flask-dapr` extension.
-
-## Installation
-
-You can download and install the Dapr Flask extension with:
-
-{{< tabpane text=true >}}
-
-{{% tab header="Stable" %}}
-```bash
-pip install flask-dapr
-```
-{{% /tab %}}
-
-{{% tab header="Development" %}}
-{{% alert title="Note" color="warning" %}}
-The development package will contain features and behavior that will be compatible with the pre-release version of the Dapr runtime. Make sure to uninstall any stable versions of the Python SDK extension before installing the `dapr-dev` package.
-{{% /alert %}}
-
-```bash
-pip install flask-dapr-dev
-```
-{{% /tab %}}
-
-{{< /tabpane >}}
-
-## Example
-
-```python
-from flask import Flask
-from flask_dapr.actor import DaprActor
-
-from dapr.conf import settings
-from demo_actor import DemoActor
-
-app = Flask(f'{DemoActor.__name__}Service')
-
-# Enable DaprActor Flask extension
-actor = DaprActor(app)
-
-# Register DemoActor
-actor.register_actor(DemoActor)
-
-# Setup method route
-@app.route('/GetMyData', methods=['GET'])
-def get_my_data():
- return {'message': 'myData'}, 200
-
-# Run application
-if __name__ == '__main__':
- app.run(port=settings.HTTP_APP_PORT)
-```
diff --git a/daprdocs/content/en/python-sdk-docs/python-sdk-extensions/python-grpc.md b/daprdocs/content/en/python-sdk-docs/python-sdk-extensions/python-grpc.md
deleted file mode 100644
index e34c213b..00000000
--- a/daprdocs/content/en/python-sdk-docs/python-sdk-extensions/python-grpc.md
+++ /dev/null
@@ -1,118 +0,0 @@
----
-type: docs
-title: "Getting started with the Dapr Python gRPC service extension"
-linkTitle: "gRPC"
-weight: 100000
-description: How to get up and running with the Dapr Python gRPC extension
----
-
-The Dapr Python SDK provides a built in gRPC server extension, `dapr.ext.grpc`, for creating Dapr services.
-
-## Installation
-
-You can download and install the Dapr gRPC server extension with:
-
-{{< tabpane text=true >}}
-
-{{% tab header="Stable" %}}
-```bash
-pip install dapr-ext-grpc
-```
-{{% /tab %}}
-
-{{% tab header="Development" %}}
-{{% alert title="Note" color="warning" %}}
-The development package will contain features and behavior that will be compatible with the pre-release version of the Dapr runtime. Make sure to uninstall any stable versions of the Python SDK extension before installing the `dapr-dev` package.
-{{% /alert %}}
-
-```bash
-pip3 install dapr-ext-grpc-dev
-```
-{{% /tab %}}
-
-{{< /tabpane >}}
-
-## Examples
-
-The `App` object can be used to create a server.
-
-### Listen for service invocation requests
-
-The `InvokeMethodReqest` and `InvokeMethodResponse` objects can be used to handle incoming requests.
-
-A simple service that will listen and respond to requests will look like:
-
-```python
-from dapr.ext.grpc import App, InvokeMethodRequest, InvokeMethodResponse
-
-app = App()
-
-@app.method(name='my-method')
-def mymethod(request: InvokeMethodRequest) -> InvokeMethodResponse:
- print(request.metadata, flush=True)
- print(request.text(), flush=True)
-
- return InvokeMethodResponse(b'INVOKE_RECEIVED', "text/plain; charset=UTF-8")
-
-app.run(50051)
-```
-
-A full sample can be found [here](https://github.com/dapr/python-sdk/tree/v1.0.0rc2/examples/invoke-simple).
-
-### Subscribe to a topic
-
-When subscribing to a topic, you can instruct dapr whether the event delivered has been accepted, or whether it should be dropped, or retried later.
-
-```python
-from typing import Optional
-from cloudevents.sdk.event import v1
-from dapr.ext.grpc import App
-from dapr.clients.grpc._response import TopicEventResponse
-
-app = App()
-
-# Default subscription for a topic
-@app.subscribe(pubsub_name='pubsub', topic='TOPIC_A')
-def mytopic(event: v1.Event) -> Optional[TopicEventResponse]:
- print(event.Data(),flush=True)
- # Returning None (or not doing a return explicitly) is equivalent
- # to returning a TopicEventResponse("success").
- # You can also return TopicEventResponse("retry") for dapr to log
- # the message and retry delivery later, or TopicEventResponse("drop")
- # for it to drop the message
- return TopicEventResponse("success")
-
-# Specific handler using Pub/Sub routing
-@app.subscribe(pubsub_name='pubsub', topic='TOPIC_A',
- rule=Rule("event.type == \"important\"", 1))
-def mytopic_important(event: v1.Event) -> None:
- print(event.Data(),flush=True)
-
-# Handler with disabled topic validation
-@app.subscribe(pubsub_name='pubsub-mqtt', topic='topic/#', disable_topic_validation=True,)
-def mytopic_wildcard(event: v1.Event) -> None:
- print(event.Data(),flush=True)
-
-app.run(50051)
-```
-
-A full sample can be found [here](https://github.com/dapr/python-sdk/blob/v1.0.0rc2/examples/pubsub-simple/subscriber.py).
-
-### Setup input binding trigger
-
-```python
-from dapr.ext.grpc import App, BindingRequest
-
-app = App()
-
-@app.binding('kafkaBinding')
-def binding(request: BindingRequest):
- print(request.text(), flush=True)
-
-app.run(50051)
-```
-
-A full sample can be found [here](https://github.com/dapr/python-sdk/tree/v1.0.0rc2/examples/invoke-binding).
-
-## Related links
-- [PyPi](https://pypi.org/project/dapr-ext-grpc/)
diff --git a/daprdocs/content/en/python-sdk-docs/python-sdk-extensions/python-workflow-ext/_index.md b/daprdocs/content/en/python-sdk-docs/python-sdk-extensions/python-workflow-ext/_index.md
deleted file mode 100644
index 12a63f8f..00000000
--- a/daprdocs/content/en/python-sdk-docs/python-sdk-extensions/python-workflow-ext/_index.md
+++ /dev/null
@@ -1,105 +0,0 @@
----
-type: docs
-title: "Dapr Python SDK integration with Dapr Workflow extension"
-linkTitle: "Dapr Workflow"
-weight: 400000
-description: How to get up and running with the Dapr Workflow extension
-no_list: true
----
-
-The Dapr Python SDK provides a built-in Dapr Workflow extension, `dapr.ext.workflow`, for creating Dapr services.
-
-## Installation
-
-You can download and install the Dapr Workflow extension with:
-
-{{< tabpane text=true >}}
-
-{{% tab header="Stable" %}}
-```bash
-pip install dapr-ext-workflow
-```
-{{% /tab %}}
-
-{{% tab header="Development" %}}
-{{% alert title="Note" color="warning" %}}
-The development package will contain features and behavior that will be compatible with the pre-release version of the Dapr runtime. Make sure to uninstall any stable versions of the Python SDK extension before installing the `dapr-dev` package.
-{{% /alert %}}
-
-```bash
-pip install dapr-ext-workflow-dev
-```
-{{% /tab %}}
-
-{{< /tabpane >}}
-
-## Example
-
-```python
-from time import sleep
-
-import dapr.ext.workflow as wf
-
-
-wfr = wf.WorkflowRuntime()
-
-
-@wfr.workflow(name='random_workflow')
-def task_chain_workflow(ctx: wf.DaprWorkflowContext, wf_input: int):
- try:
- result1 = yield ctx.call_activity(step1, input=wf_input)
- result2 = yield ctx.call_activity(step2, input=result1)
- except Exception as e:
- yield ctx.call_activity(error_handler, input=str(e))
- raise
- return [result1, result2]
-
-
-@wfr.activity(name='step1')
-def step1(ctx, activity_input):
- print(f'Step 1: Received input: {activity_input}.')
- # Do some work
- return activity_input + 1
-
-
-@wfr.activity
-def step2(ctx, activity_input):
- print(f'Step 2: Received input: {activity_input}.')
- # Do some work
- return activity_input * 2
-
-@wfr.activity
-def error_handler(ctx, error):
- print(f'Executing error handler: {error}.')
- # Do some compensating work
-
-
-if __name__ == '__main__':
- wfr.start()
- sleep(10) # wait for workflow runtime to start
-
- wf_client = wf.DaprWorkflowClient()
- instance_id = wf_client.schedule_new_workflow(workflow=task_chain_workflow, input=42)
- print(f'Workflow started. Instance ID: {instance_id}')
- state = wf_client.wait_for_workflow_completion(instance_id)
- print(f'Workflow completed! Status: {state.runtime_status}')
-
- wfr.shutdown()
-```
-
-- Learn more about authoring and managing workflows:
- - [How-To: Author a workflow]({{% ref howto-author-workflow.md %}}).
- - [How-To: Manage a workflow]({{% ref howto-manage-workflow.md %}}).
- -
-- Visit [Python SDK examples](https://github.com/dapr/python-sdk/tree/main/examples/workflow) for code samples and instructions to try out Dapr Workflow:
- - [Simple workflow example]({{% ref python-workflow.md %}})
- - [Task chaining example](https://github.com/dapr/python-sdk/blob/main/examples/workflow/task_chaining.py)
- - [Fan-out/Fan-in example](https://github.com/dapr/python-sdk/blob/main/examples/workflow/fan_out_fan_in.py)
- - [Child workflow example](https://github.com/dapr/python-sdk/blob/main/examples/workflow/child_workflow.py)
- - [Human approval example](https://github.com/dapr/python-sdk/blob/main/examples/workflow/human_approval.py)
- - [Monitor example](https://github.com/dapr/python-sdk/blob/main/examples/workflow/monitor.py)
-
-
-## Next steps
-
-{{< button text="Getting started with the Dapr Workflow Python SDK" page="python-workflow.md" >}}
diff --git a/daprdocs/content/en/python-sdk-docs/python-sdk-extensions/python-workflow-ext/python-workflow.md b/daprdocs/content/en/python-sdk-docs/python-sdk-extensions/python-workflow-ext/python-workflow.md
deleted file mode 100644
index 8c882ac7..00000000
--- a/daprdocs/content/en/python-sdk-docs/python-sdk-extensions/python-workflow-ext/python-workflow.md
+++ /dev/null
@@ -1,166 +0,0 @@
----
-type: docs
-title: "Getting started with the Dapr Workflow Python SDK"
-linkTitle: "Workflow"
-weight: 30000
-description: How to get up and running with workflows using the Dapr Python SDK
----
-
-Let’s create a Dapr workflow and invoke it using the console. With the [provided workflow example](https://github.com/dapr/python-sdk/tree/main/examples/workflow/simple.py), you will:
-
-- Run a [Python console application](https://github.com/dapr/python-sdk/blob/main/examples/workflow/simple.py) that demonstrates workflow orchestration with activities, child workflows, and external events
-- Learn how to handle retries, timeouts, and workflow state management
-- Use the Python workflow SDK to start, pause, resume, and purge workflow instances
-
-This example uses the default configuration from `dapr init` in [self-hosted mode](https://github.com/dapr/cli#install-dapr-on-your-local-machine-self-hosted).
-
-In the Python example project, the `simple.py` file contains the setup of the app, including:
-- The workflow definition
-- The workflow activity definitions
-- The registration of the workflow and workflow activities
-
-## Prerequisites
-- [Dapr CLI]({{% ref install-dapr-cli.md %}}) installed
-- Initialized [Dapr environment]({{% ref install-dapr-selfhost.md %}})
-- [Python 3.9+](https://www.python.org/downloads/) installed
-- [Dapr Python package]({{% ref "python#installation" %}}) and the [workflow extension]({{% ref "python-workflow/_index.md" %}}) installed
-- Verify you're using the latest proto bindings
-
-## Set up the environment
-
-Start by cloning the [Python SDK repo].
-
-```bash
-git clone https://github.com/dapr/python-sdk.git
-```
-
-From the Python SDK root directory, navigate to the Dapr Workflow example.
-
-```bash
-cd examples/workflow
-```
-
-Run the following command to install the requirements for running this workflow sample with the Dapr Python SDK.
-
-```bash
-pip3 install -r workflow/requirements.txt
-```
-
-## Run the application locally
-
-To run the Dapr application, you need to start the Python program and a Dapr sidecar. In the terminal, run:
-
-```bash
-dapr run --app-id wf-simple-example --dapr-grpc-port 50001 --resources-path components -- python3 simple.py
-```
-
-> **Note:** Since Python3.exe is not defined in Windows, you may need to use `python simple.py` instead of `python3 simple.py`.
-
-
-**Expected output**
-
-```
-- "== APP == Hi Counter!"
-- "== APP == New counter value is: 1!"
-- "== APP == New counter value is: 11!"
-- "== APP == Retry count value is: 0!"
-- "== APP == Retry count value is: 1! This print statement verifies retry"
-- "== APP == Appending 1 to child_orchestrator_string!"
-- "== APP == Appending a to child_orchestrator_string!"
-- "== APP == Appending a to child_orchestrator_string!"
-- "== APP == Appending 2 to child_orchestrator_string!"
-- "== APP == Appending b to child_orchestrator_string!"
-- "== APP == Appending b to child_orchestrator_string!"
-- "== APP == Appending 3 to child_orchestrator_string!"
-- "== APP == Appending c to child_orchestrator_string!"
-- "== APP == Appending c to child_orchestrator_string!"
-- "== APP == Get response from hello_world_wf after pause call: Suspended"
-- "== APP == Get response from hello_world_wf after resume call: Running"
-- "== APP == New counter value is: 111!"
-- "== APP == New counter value is: 1111!"
-- "== APP == Workflow completed! Result: "Completed"
-```
-
-## What happened?
-
-When you run the application, several key workflow features are shown:
-
-1. **Workflow and Activity Registration**: The application uses Python decorators to automatically register workflows and activities with the runtime. This decorator-based approach provides a clean, declarative way to define your workflow components:
- ```python
- @wfr.workflow(name='hello_world_wf')
- def hello_world_wf(ctx: DaprWorkflowContext, wf_input):
- # Workflow definition...
-
- @wfr.activity(name='hello_act')
- def hello_act(ctx: WorkflowActivityContext, wf_input):
- # Activity definition...
- ```
-
-2. **Runtime Setup**: The application initializes the workflow runtime and client:
- ```python
- wfr = WorkflowRuntime()
- wfr.start()
- wf_client = DaprWorkflowClient()
- ```
-
-2. **Activity Execution**: The workflow executes a series of activities that increment a counter:
- ```python
- @wfr.workflow(name='hello_world_wf')
- def hello_world_wf(ctx: DaprWorkflowContext, wf_input):
- yield ctx.call_activity(hello_act, input=1)
- yield ctx.call_activity(hello_act, input=10)
- ```
-
-3. **Retry Logic**: The workflow demonstrates error handling with a retry policy:
- ```python
- retry_policy = RetryPolicy(
- first_retry_interval=timedelta(seconds=1),
- max_number_of_attempts=3,
- backoff_coefficient=2,
- max_retry_interval=timedelta(seconds=10),
- retry_timeout=timedelta(seconds=100),
- )
- yield ctx.call_activity(hello_retryable_act, retry_policy=retry_policy)
- ```
-
-4. **Child Workflow**: A child workflow is executed with its own retry policy:
- ```python
- yield ctx.call_child_workflow(child_retryable_wf, retry_policy=retry_policy)
- ```
-
-5. **External Event Handling**: The workflow waits for an external event with a timeout:
- ```python
- event = ctx.wait_for_external_event(event_name)
- timeout = ctx.create_timer(timedelta(seconds=30))
- winner = yield when_any([event, timeout])
- ```
-
-6. **Workflow Lifecycle Management**: The example demonstrates how to pause and resume the workflow:
- ```python
- wf_client.pause_workflow(instance_id=instance_id)
- metadata = wf_client.get_workflow_state(instance_id=instance_id)
- # ... check status ...
- wf_client.resume_workflow(instance_id=instance_id)
- ```
-
-7. **Event Raising**: After resuming, the workflow raises an event:
- ```python
- wf_client.raise_workflow_event(
- instance_id=instance_id,
- event_name=event_name,
- data=event_data
- )
- ```
-
-8. **Completion and Cleanup**: Finally, the workflow waits for completion and cleans up:
- ```python
- state = wf_client.wait_for_workflow_completion(
- instance_id,
- timeout_in_seconds=30
- )
- wf_client.purge_workflow(instance_id=instance_id)
- ```
-## Next steps
-- [Learn more about Dapr workflow]({{% ref workflow-overview.md %}})
-- [Workflow API reference]({{% ref workflow_api.md %}})
-- [Try implementing more complex workflow patterns](https://github.com/dapr/python-sdk/tree/main/examples/workflow)