Update Python instruction (#7)

* Update Python instruction

* Fix typo

Author: justinyoo

README.md

@@ -77,13 +77,13 @@ This is a self-paced workshop by following the links below:
 
 Check out the complete example of each application. They're also vibe-coded with GitHub Copilot, therefore, they might not be perfect, and you don't have to follow the app.
 
-| Language         | Location                             |
-|------------------|--------------------------------------|
-| Python           | [python](./complete/python/)         |
-| JavaScript       | [javascript](./complete/javascript/) |
-| Java             | [java](./complete/java/)             |
-| .NET             | [dotnet](./complete/dotnet/)         |
-| Containerization | [containerization](./complete/)      |
+| Language            | Application | Location                             |
+|---------------------|-------------|--------------------------------------|
+| Python Backend      | FastAPI     | [python](./complete/python/)         |
+| JavaScript Frontend | React       | [javascript](./complete/javascript/) |
+| Java Backend        | Spring Boot | [java](./complete/java/)             |
+| .NET Frontend       | Blazor      | [dotnet](./complete/dotnet/)         |
+| Containerization    | Container   | [containerization](./complete/)      |
 
 ## Read More...
 

docs/00-setup.md

@@ -317,4 +317,4 @@ Refer to the [README](../README.md) doc for preparation.
 
 ---
 
-OK. You've completed the "Development Environment" step. Let's move onto [STEP 01: Python](./01-python.md).
+OK. You've completed the "Development Environment" step. Let's move onto [STEP 01: Python Backend Development](./01-python.md).

docs/01-python.md

@@ -1,121 +1,113 @@
-# 01: Python
+# 01: Python Backend Development
 
-## 시나리오
+## Scenario
 
-Contoso 아웃도어 컴파니의 마케팅 팀에서는 제품 홍보를 위한 마이크로 소셜 미디어 웹사이트를 빠르게 론칭하고 싶어 합니다. 개발팀의 Python 개발자인 당신은 GitHub Codespaces 안에서 GitHub Copilot을 이용해 간단한 백엔드 API를 만들어 달라는 요청을 받았습니다. 이에 따라 FastAPI를 사용하여 SNS 기능을 구현하고, 간단히 SQLite 데이터베이스를 연동해 CRUD를 수행하려고 합니다.
+Contoso is a company that sells products for various outdoor activities. A marketing department of Contoso would like to launch a micro social media website to promote their products for existing and potential customers.
 
-## 사전 준비사항
+As a Python developer, you're going to build a Python backend app using FastAPI. For now, you're using the in-memory feature of SQLite.
 
-[README](../README.md) 문서를 참조하여 개발 환경을 준비합니다.
+## Prerequisites
 
-## 순서
+Refer to the [README](../README.md) doc for preparation.
 
-- [개발 과정 프롬프트](#개발-과정-프롬프트)
-  - [FastAPI 앱 프로젝트 준비](#fastapi-앱-프로젝트-준비)
-  - [CRUD API 구현](#crud-api-구현)
-  - [가상환경으로 앱 실행](#가상환경으로-앱-실행)
-  - [API 확인](#api-확인)
-  - [기본 데이터베이스 테이블 생성](#기본-데이터베이스-테이블-생성)
-- [서비스 종료](#서비스-종료)
+## Getting Started
 
-## 개발 과정 프롬프트
+  - [Check GitHub Copilot Agent Mode](#check-github-copilot-agent-mode)
+  - [Prepare Custom Instructions](#prepare-custom-instructions)
+  - [Prepare Virtual Environment](#prepare-virtual-environment)
+  - [Build FastAPI Backend App](#build-fastapi-backend-app)
 
-아래는 FastAPI 앱을 개발하여 간단한 SNS 기능을 구현하는 과정입니다.
+### Check GitHub Copilot Agent Mode
 
-- FastAPI 앱 프로젝트 준비
-- CRUD API 구현
-- 가상환경으로 앱 실행
-- API 확인
-- 기본 데이터베이스 테이블 생성
+1. Click the GitHub Copilot icon on the top of GitHub Codespace or VS Code and open GitHub Copilot window.
 
-### FastAPI 앱 프로젝트 준비
+   ![Open GitHub Copilot Chat](./images/setup-02.png)
 
-1. 가상환경 생성
+1. If you're asked to login or sign up, do it. It's free of charge.
+1. Make sure you're using GitHub Copilot Agent Mode.
 
-   Python 프로젝트 디렉토리를 생성하고, 다음 명령어로 가상환경(venv)을 만듭니다:
+   ![GitHub Copilot Agent Mode](./images/setup-03.png)
 
-    ```bash
-    python -m venv .venv
-    ```
+1. Select model to either `GPT-4.1` or `Claude Sonnet 4`.
 
-1. 가상환경 활성화 및 FastAPI 설치
+### Prepare Custom Instructions
 
-   **Windows**
+1. Set the environment variable of `$REPOSITORY_ROOT`.
 
-    ```pwsh
-    .venv/Scripts/activate
-    ```
+   ```bash
+   # bash/zsh
+   REPOSITORY_ROOT=$(git rev-parse --show-toplevel)
+   ```
 
-   **MacOS**, **Linux** 또는 **GitHub Codespaces**
+   ```powershell
+   # PowerShell
+   $REPOSITORY_ROOT = git rev-parse --show-toplevel
+   ```
 
-    ```bash
-    source .venv/bin/activate
-    ```
+1. Copy custom instructions.
 
     ```bash
-    pip install fastapi uvicorn
+    # bash/zsh
+    cp -r $REPOSITORY_ROOT/docs/custom-instructions/python/. \
+          $REPOSITORY_ROOT/.github/
     ```
 
-1. main.py 빈 파일 생성
-
-### CRUD API 구현
-
-FastAPI를 활용하여 소셜 네트워크 서비스의 모든 핵심 기능을 REST API로 구현합니다.
-
-```text
-FastAPI를 사용하여 openapi.yaml 명세를 기반으로 소셜 네트워크 서비스의 백엔드 API를 구현해. openapi.yaml의 정의에 따라 포스트, 댓글, 좋아요 기능을 포함하는 모든 엔드포인트를 구현한다. 명세에 맞게 적절한 HTTP 메소드, 상태 코드, 요청/응답 형식을 구현하낟. Pydantic 모델을 사용하여 데이터 검증을 구현하고, 예외 처리도 포함해주세요. 데이터는 데이터베이스 없이 간단한 메모리로 관리한다. main.py 파일 하나에 모두 구현한다.
-```
-
-### 가상환경으로 앱 실행
-
-```bash
-source .venv/bin/activate
-```
-
-```bash
-uvicorn python.main:app --reload
-```
-
-### API 확인
-
-브라우저에서 http://127.0.0.1:8000/docs 접속
-
-### 기본 데이터베이스 테이블 생성
-
-애플리케이션에 필요한 데이터를 저장할 SQLite 데이터베이스 스키마를 구성합니다.
+    ```powershell
+    # PowerShell
+    Copy-Item -Path $REPOSITORY_ROOT/docs/custom-instructions/python/* `
+              -Destination $REPOSITORY_ROOT/.github/ -Recurse -Force
+    ```
 
-```text
-SQLite 데이터베이스를 사용하여 openapi.yaml 명세를 참고하여 현재 정의된 API를 구현한다. 애플리케이션 시작 시 자동으로 데이터베이스와 테이블을 생성하는 코드를 구현하되, 테이블이 이미 존재하는 경우 다시 생성하지 않도록 'CREATE TABLE IF NOT EXISTS' 구문을 사용하세요. 
-```
+### Prepare Virtual Environment
 
-서버를 재시작한 후에도 SQLite 데이터베이스에 저장된 포스트 데이터가 유지되는지 확인합니다.
+1. Make sure that you're using GitHub Copilot Agent Mode with the model of `Claude Sonnet 4` or `GPT-4.1`.
+1. Use prompt like below to prepare virtual environment for Python app development.
 
-## 서비스 종료
+    ```text
+    I'd like to write a Python application. But before that, I need to set up a virtual environment. Follow the instructions below.
+    
+    - Your working directory is `python`.
+    - Identify all the steps first, which is you're going to do.
+    - Use `.venv` for the virtual environment.
+    - Use `uv` as the Python package manager.
+    ```
 
-FastAPI 서버 등 현재 실행 중인 백엔드 서비스를 종료하려면, 터미널에서 **Ctrl + C**를 누르세요.  
-이렇게 하면 서버가 정상적으로 종료되어 포트(예: 8000번)를 다른 백엔드 서비스가 사용할 수 있습니다.
+### Build FastAPI Backend App
+
+1. Make sure that you're using GitHub Copilot Agent Mode with the model of `Claude Sonnet 4` or `GPT-4.1`.
+1. Add [`product-requirements.md`](../product-requirements.md) and [`openapi.yaml`](../openapi.yaml) to GitHub Copilot.
+1. Use prompt like below to build a FastAPI backend application.
+
+    ```text
+    I'd like to build a FastAPI application as a backend API. Carefully read the entire PRD and `openapi.yaml`. Then, follow the instructions below.
+    
+    - Your working directory is `python`.
+    - Identify all the steps first, which is you're going to do.
+    - Use FastAPI as the API app framework.
+    - Use SQLite as the database.
+    - Use in-memory feature of SQLite.
+    - The database should always be initialized whenever starting the app.
+    - Use `openapi.yaml` that describes all the endpoints and data schema.
+    - Use the port number of `5050`.
+    - Entrypoint is `main.py`.
+    - The API application should render Swagger UI page through a default endpoint.
+    - The API application should render exactly the same OpenAPI document through a default endpoint.
+    - DO NOT add anything not defined in `openapi.yaml`.
+    - DO NOT modify anything defined in `openapi.yaml`.
+    ```
 
-만약 서버가 백그라운드에서 실행 중이거나 포트가 여전히 점유 중이라면, 아래 명령어로 프로세스를 확인하고 종료할 수 있습니다.
+1. Once the application is built, verify if it's written properly or not.
 
-```bash
-lsof -i :8000
-kill <PID>
-```
+    ```text
+    Run the Python app and verify if the app is properly running. Also verify the OpenAPI endpoint renders exactly the same content as `openapi.yaml`.
 
-lsof 명령어를 수행하면 아래처럼 나옵니다. "--reload" 옵션으로 서비스를 띄웠기 때문에 코드 변경을 감시하는 서버가 하나 더 띄워져서 두 개가 나옵니다. 
+    If app running fails, analyze the issues and fix them.
+    ```
 
-```bash
-(base) tykimos@MacBook-Air-2 crewai % lsof -i :8000
-COMMAND   PID    USER   FD   TYPE             DEVICE SIZE/OFF NODE NAME
-Python  12707 tykimos    3u  IPv4 0x9fddcce1c1588271      0t0  TCP localhost:irdmi (LISTEN)
-Python  12710 tykimos    3u  IPv4 0x9fddcce1c1588271      0t0  TCP localhost:irdmi (LISTEN)
-```
+1. Open a web browser and navigate to `http://localhost:5050`.
 
-이 경우 코드 변경 감시 서버만 종료하면 되지만 확인이 힘들다면 둘 다 종료시킵니다.
+1. Click the `[keep]` button of GitHub Copilot to take the changes.
 
-```bash
-kill 12707
-kill 12710
-```
+---
 
-그럼 다른 백엔드 서비스를 동일한 포트에서 실행할 수 있습니다.
+OK. You've completed the "Python" step. Let's move onto [STEP 02: JavaScript Frontend Development](./02-javascript.md).

docs/02-javascript.md

@@ -1,4 +1,4 @@
-# 02: JavaScript
+# 02: JavaScript Frontend Development
 
 ## 시나리오
 

docs/03-java.md

@@ -1,4 +1,4 @@
-# 03: Java
+# 03: Java Migration from Python
 
 ## 시나리오
 

docs/04-dotnet.md

@@ -1,4 +1,4 @@
-# 04: .NET
+# 04: .NET Migration from JavaScript
 
 ## Scenario
 

docs/README.md

@@ -2,11 +2,11 @@
 
 Here are the self-paced learning instruction materials. Use them and build apps!
 
-| Step                        | Link                                               |
-|-----------------------------|----------------------------------------------------|
-| 00: Development Environment | [00-setup.md](./00-setup.md)                       |
-| 01: Python                  | [01-python.md](./01-python.md)                     |
-| 02: JavaScript              | [02-javascript.md](./02-javascript.md)             |
-| 03: Java                    | [03-java.md](./03-java.md)                         |
-| 04: .NET                    | [04-dotnet.md](./04-dotnet.md)                     |
-| 05: Containerization        | [05-containerization.md](./05-containerization.md) |
+| Step                                | Link                                               |
+|-------------------------------------|----------------------------------------------------|
+| 00: Development Environment         | [00-setup.md](./00-setup.md)                       |
+| 01: Python Backend Development      | [01-python.md](./01-python.md)                     |
+| 02: JavaScript Frontend Development | [02-javascript.md](./02-javascript.md)             |
+| 03: Java Migration from Python      | [03-java.md](./03-java.md)                         |
+| 04: .NET Migration from JavaScript  | [04-dotnet.md](./04-dotnet.md)                     |
+| 05: Containerization                | [05-containerization.md](./05-containerization.md) |

docs/custom-instructions/python/copilot-instructions.md

@@ -0,0 +1,70 @@
+# Python Development Rules
+
+You are a senior Python developer and an expert in Python, FastAPI, SQLite and scalable API development.
+  
+## Key Principles
+
+- Write concise, technical responses with accurate Python examples.
+- Use functional, declarative programming; avoid classes where possible.
+- Prefer iteration and modularization over code duplication.
+- Use descriptive variable names with auxiliary verbs (e.g., is_active, has_permission).
+- Use lowercase with underscores for directories and files (e.g., routers/user_routes.py).
+- Favor named exports for routes and utility functions.
+- Use the Receive an Object, Return an Object (RORO) pattern.
+
+## Python/FastAPI
+
+- Use def for pure functions and async def for asynchronous operations.
+- Use type hints for all function signatures. Prefer Pydantic models over raw dictionaries for input validation.
+- File structure: exported router, sub-routes, utilities, static content, types (models, schemas).
+- Avoid unnecessary curly braces in conditional statements.
+- For single-line statements in conditionals, omit curly braces.
+- Use concise, one-line syntax for simple conditional statements (e.g., if condition: do_something()).
+
+## Error Handling and Validation
+
+- Prioritize error handling and edge cases:
+  - Handle errors and edge cases at the beginning of functions.
+  - Use early returns for error conditions to avoid deeply nested if statements.
+  - Place the happy path last in the function for improved readability.
+  - Avoid unnecessary else statements; use the if-return pattern instead.
+  - Use guard clauses to handle preconditions and invalid states early.
+  - Implement proper error logging and user-friendly error messages.
+  - Use custom error types or error factories for consistent error handling.
+
+## Dependencies
+
+- FastAPI
+- Pydantic v2
+- Async database libraries like asyncpg or aiomysql
+- SQLAlchemy 2.0 (if using ORM features)
+
+## FastAPI-Specific Guidelines
+
+- Use functional components (plain functions) and Pydantic models for input validation and response schemas.
+- Use declarative route definitions with clear return type annotations.
+- Use def for synchronous operations and async def for asynchronous ones.
+- Minimize @app.on_event("startup") and @app.on_event("shutdown"); prefer lifespan context managers for managing startup and shutdown events.
+- Use middleware for logging, error monitoring, and performance optimization.
+- Optimize for performance using async functions for I/O-bound tasks, caching strategies, and lazy loading.
+- Use HTTPException for expected errors and model them as specific HTTP responses.
+- Use middleware for handling unexpected errors, logging, and error monitoring.
+- Use Pydantic's BaseModel for consistent input/output validation and response schemas.
+
+## Performance Optimization
+
+- Minimize blocking I/O operations; use asynchronous operations for all database calls and external API requests.
+- Implement caching for static and frequently accessed data using tools like Redis or in-memory stores.
+- Optimize data serialization and deserialization with Pydantic.
+- Use lazy loading techniques for large datasets and substantial API responses.
+
+## Key Conventions
+
+1. Rely on FastAPI’s dependency injection system for managing state and shared resources.
+2. Prioritize API performance metrics (response time, latency, throughput).
+3. Limit blocking operations in routes:
+   - Favor asynchronous and non-blocking flows.
+   - Use dedicated async functions for database and external API operations.
+   - Structure routes and dependencies clearly to optimize readability and maintainability.
+
+Refer to FastAPI documentation for Data Models, Path Operations, and Middleware for best practices.