Update Python template docs to use Aspire CLI and correct template structure

Co-authored-by: IEvangelist <[email protected]>

Author: Copilot

docs/fundamentals/aspire-sdk-templates.md

@@ -39,12 +39,11 @@ The following Aspire solution templates are available, assume the solution is na
 
 <a name="python-app"></a>
 
-- **Aspire Python App**: A full-stack Aspire application with a Python backend and JavaScript frontend. This template includes:
+- **Aspire Python App**: A full-stack Aspire application with a Python backend and JavaScript frontend. This template uses a file-based AppHost and includes:
 
-  - [**AspireSample.AppHost**](#app-host): An orchestrator project to connect and configure services.
-  - [**AspireSample.ServiceDefaults**](#service-defaults): A shared project for common configurations.
-  - **AspireSample.Backend**: A Python backend using FastAPI framework with OpenTelemetry instrumentation.
-  - **AspireSample.Frontend**: A JavaScript frontend using React framework.
+  - **apphost.cs**: A file-based AppHost that orchestrates the Python backend and JavaScript frontend.
+  - **app**: A Python backend using [FastAPI](https://fastapi.tiangolo.com/) framework with OpenTelemetry instrumentation.
+  - **frontend**: A JavaScript frontend using [React](https://react.dev/) framework with Vite.
 
   > [!NOTE]
   > The Aspire Python template is currently under development. For more information and updates, see [GitHub: Aspire issue #11865](https://github.com/dotnet/aspire/issues/11865). For now, you can manually add Python applications to an existing Aspire solution using the guidance in [Orchestrate Python apps in Aspire](../get-started/build-aspire-apps-with-python.md).
@@ -108,30 +107,30 @@ To create an Aspire solution or project using the .NET CLI, use the [dotnet new]
 
 To create a basic [Aspire AppHost](app-host-overview.md) project targeting the latest .NET version:
 
-```dotnetcli
-dotnet new aspire-apphost
+```Aspire
+aspire new aspire-apphost
 ```
 
 To create an Aspire starter app, which is a full solution with a sample UI and backing API included:
 
-```dotnetcli
-dotnet new aspire-starter
+```Aspire
+aspire new aspire-starter
 ```
 
 To create an Aspire app with a Python backend and JavaScript frontend:
 
-```dotnetcli
-dotnet new aspire-python
+```Aspire
+aspire new aspire-py-starter
 ```
 
 > [!NOTE]
-> The `aspire-python` template is currently under development. For more information, see [Build an Aspire app with Python and JavaScript](../get-started/build-aspire-python-app.md).
+> The `aspire-py-starter` template is currently under development. For more information, see [Build an Aspire app with Python and JavaScript](../get-started/build-aspire-python-app.md).
 
 > [!TIP]
 > Aspire templates default to using the latest .NET version, even when using an earlier version of the .NET CLI. To manually specify the .NET version, use the `--framework <tfm>` option, for example to create a basic [Aspire AppHost](app-host-overview.md) project targeting .NET 8:
 >
-> ```dotnetcli
-> dotnet new aspire-apphost --framework net8.0
+> ```Aspire
+> aspire new aspire-apphost --framework net8.0
 > ```
 
 You need to trust the ASP.NET Core :::no-loc text="localhost"::: certificate before running the app. Run the following command:

docs/get-started/build-aspire-python-app.md

@@ -8,7 +8,7 @@ ai-usage: ai-assisted
 
 # Build an Aspire app with Python and JavaScript
 
-In this article, you learn how to create a new Aspire application using the Aspire Python template. The template creates a solution with a Python backend (using FastAPI) and a JavaScript frontend (using React), orchestrated by Aspire. This approach is ideal for Python developers who want to build observable, production-ready applications with modern JavaScript frontends.
+In this article, you learn how to create a new Aspire application using the Aspire Python template. The template creates a solution with a Python backend (using [FastAPI](https://fastapi.tiangolo.com/)) and a JavaScript frontend (using [React](https://react.dev/)), orchestrated by Aspire. This approach is ideal for Python developers who want to build observable, production-ready applications with modern JavaScript frontends.
 
 > [!NOTE]
 > The Aspire Python template is currently under development. This documentation will be updated as the template becomes available. For now, you can follow the guidance in [Orchestrate Python apps in Aspire](build-aspire-apps-with-python.md) to manually add Python applications to an existing Aspire solution.
@@ -45,20 +45,19 @@ To download Node.js (including `npm`), see the [Node.js download page](https://n
 ## Create an Aspire project using the Python template
 
 > [!IMPORTANT]
-> The `aspire-python` template is currently being developed and might not be available yet. Once released, you'll be able to create a Python-based Aspire application using the following command. For updates on template availability, see [Aspire Python Templates (issue #11865)](https://github.com/dotnet/aspire/issues/11865).
+> The `aspire-py-starter` template is currently being developed and might not be available yet. Once released, you'll be able to create a Python-based Aspire application using the following command. For updates on template availability, see [Aspire Python Templates (issue #11865)](https://github.com/dotnet/aspire/issues/11865).
 
-To create a new Aspire application with a Python backend and JavaScript frontend, use the `aspire-python` template:
+To create a new Aspire application with a Python backend and JavaScript frontend, use the `aspire-py-starter` template:
 
-```dotnetcli
-dotnet new aspire-python -o MyPythonApp
+```Aspire
+aspire new aspire-py-starter
 ```
 
 This command creates a new Aspire solution with the following structure:
 
-- **MyPythonApp.AppHost**: An orchestrator project designed to connect and configure the different projects and services of your app.
-- **MyPythonApp.ServiceDefaults**: A shared project to manage configurations that are reused across the projects in your solution related to resilience, service discovery, and telemetry.
-- **MyPythonApp.Backend**: A Python backend using FastAPI framework.
-- **MyPythonApp.Frontend**: A JavaScript frontend using React framework.
+- **apphost.cs**: A file-based AppHost that orchestrates the Python backend and JavaScript frontend.
+- **app**: A Python backend using [FastAPI](https://fastapi.tiangolo.com/) framework.
+- **frontend**: A JavaScript frontend using [React](https://react.dev/) framework with Vite.
 
 ## Explore the project structure
 
@@ -68,33 +67,37 @@ Navigate to the newly created project directory:
 cd MyPythonApp
 ```
 
-### Python backend
+### File-based AppHost
 
-The Python backend is located in the _MyPythonApp.Backend_ directory. It uses the FastAPI framework to create RESTful APIs. The backend includes:
+The solution uses a file-based AppHost with a single _apphost.cs_ file. This file contains the orchestration logic for both the Python backend and JavaScript frontend. The AppHost uses `AddPythonScript` to add the Python backend and `AddViteApp` to add the React frontend.
 
-- A virtual environment for Python dependencies
-- A _requirements.txt_ file listing required Python packages
-- A _main.py_ file containing the FastAPI application code
-- OpenTelemetry instrumentation for observability
+### File-based AppHost
 
-### JavaScript frontend
+The solution uses a file-based AppHost with a single _apphost.cs_ file. This file contains the orchestration logic for both the Python backend and JavaScript frontend. The AppHost uses `AddPythonScript` to add the Python backend and `AddViteApp` to add the React frontend.
+
+### Python backend
+
+The Python backend is located in the _app_ directory. It uses the [FastAPI](https://fastapi.tiangolo.com/) framework to create RESTful APIs. The backend includes:
 
-The JavaScript frontend is located in the _MyPythonApp.Frontend_ directory. It uses React to create the user interface. The frontend includes:
+- A virtual environment for Python dependencies.
+- A _requirements.txt_ file listing required Python packages.
+- An _app.py_ file containing the FastAPI application code.
+- OpenTelemetry instrumentation for observability.
 
-- A _package.json_ file listing required npm packages
-- Source code in the _src_ directory
-- Configuration for connecting to the backend API
+### JavaScript frontend
 
-### AppHost orchestration
+The JavaScript frontend is located in the _frontend_ directory. It uses [React](https://react.dev/) with Vite to create the user interface. The frontend includes:
 
-The AppHost project (_MyPythonApp.AppHost_) orchestrates both the Python backend and JavaScript frontend. It uses the `AddPythonApp` and `AddNpmApp` APIs to configure and run these applications together.
+- A _package.json_ file listing required npm packages.
+- Source code in the _src_ directory.
+- Configuration for connecting to the backend API.
 
 ## Set up the Python environment
 
 Navigate to the Python backend directory:
 
 ```console
-cd MyPythonApp.Backend
+cd app
 ```
 
 Create and activate a Python virtual environment:
@@ -127,7 +130,7 @@ python -m pip install -r requirements.txt
 Navigate to the JavaScript frontend directory:
 
 ```console
-cd ../MyPythonApp.Frontend
+cd ../frontend
 ```
 
 Install the npm dependencies:
@@ -144,10 +147,10 @@ Navigate back to the solution root directory:
 cd ..
 ```
 
-Run the AppHost project to start the application:
+Run the AppHost to start the application:
 
-```dotnetcli
-dotnet run --project MyPythonApp.AppHost/MyPythonApp.AppHost.csproj
+```Aspire
+aspire run
 ```
 
 The Aspire dashboard opens in your browser. You should see both the Python backend and JavaScript frontend listed as resources.
@@ -156,34 +159,34 @@ The Aspire dashboard opens in your browser. You should see both the Python backe
 
 The Aspire dashboard provides a unified view of your application's resources, including:
 
-- **Resources**: View all running services (Python backend and JavaScript frontend)
-- **Logs**: See consolidated logs from all services
-- **Traces**: Monitor distributed traces across your application
-- **Metrics**: View performance metrics and telemetry data
+- **Resources**: View all running services (Python backend and JavaScript frontend).
+- **Logs**: See consolidated logs from all services.
+- **Traces**: Monitor distributed traces across your application.
+- **Metrics**: View performance metrics and telemetry data.
 
 Select the **Endpoints** link for each resource to access:
 
-- The React frontend user interface
-- The FastAPI backend API documentation (Swagger UI)
+- The React frontend user interface.
+- The FastAPI backend API documentation (Swagger UI).
 
 ## Understand telemetry and observability
 
 The Python backend and JavaScript frontend are both configured with OpenTelemetry for observability. This means:
 
-- **Logs** from both applications are collected and displayed in the Aspire dashboard
-- **Traces** show the flow of requests across services
-- **Metrics** provide insights into application performance
+- **Logs** from both applications are collected and displayed in the Aspire dashboard.
+- **Traces** show the flow of requests across services.
+- **Metrics** provide insights into application performance.
 
 The template includes OpenTelemetry packages configured to export telemetry data to the Aspire dashboard automatically.
 
 ## Next steps
 
 Now that you have a working Aspire application with Python and JavaScript:
 
-- Explore the FastAPI backend code and add new API endpoints
-- Customize the React frontend to create your user interface
-- Add additional services or resources to your AppHost
-- Deploy your application to a cloud environment
+- Explore the FastAPI backend code and add new API endpoints.
+- Customize the React frontend to create your user interface.
+- Add additional services or resources to your AppHost.
+- Deploy your application to a cloud environment.
 
 ## See also