> ## Documentation Index
> Fetch the complete documentation index at: https://genai.codewithsiva.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# 00-Introduction & Getting Started

> Welcome to the Advanced Python & FastAPI Workshop. Set up your development environment with Python 3.12+, VS Code and uv.

# Introduction & Getting Started

Welcome to the **Advanced Python & FastAPI Workshop**! This course is designed to take you from writing basic Python scripts to developing robust, production-ready REST APIs using FastAPI, Pydantic, and modern database patterns.

## Workshop Aim & Objectives

The primary aim of this workshop is to bridge the gap between the Python concepts taught in academics and the modern, practical skills required to build scalable backend applications. It also lays a strong foundation for students towards their Generative AI learning journey.

By the end of this workshop, you will be able to:

* Understand CPython memory management, mutability side-effects, and scope resolutions.
* Master advanced function concepts including positional/keyword arguments, packing/unpacking (`*args`/`**kwargs`), scope resolution (LEGB), closures, decorators, iterators, generator functions, and functional programming patterns.
* Write clean, concise, and memory-efficient comprehensions and generator streams.
* Use advanced object-oriented design patterns, abstract classes, and magic methods.
* Build resilient data validation schemas using **Pydantic v2**.
* Structure scalable web applications with **FastAPI** using modular routers and advanced dependency injection.
* Design database schemas and manage asynchronous connections using **SQLAlchemy 2.0 ORM** and **Alembic** migrations.
* Secure APIs with **JWT Authentication** and role-based access control.
* Build interactive frontend user interfaces and data-driven dashboards using **Streamlit**.
* Deploy and containerize applications to production using **Docker** and cloud environments.

## Workshop Curriculum

Here is a roadmap of the topics we will cover during this workshop:

1. **Introduction & Setup (This Module):** Setting up Python 3.12+, VS Code, and Astral's Rust-based `uv` manager.
2. **Advanced Python Fundamentals:** Mutability, floating-point precision, integer caching, string operations, and ternary operators.
3. **Data Structures & Comprehensions:** Lists, tuples, dictionaries, sets, queues with `deque`, and comprehension mechanics.
4. **Python Functions & Internals:** positional/keyword args, print parameters (`sep`/`end`), LEGB scope resolution, and packing/unpacking (`*args`/`**kwargs`).
5. **Python Modules, Packages & StdLibs (03b):** Namespace imports, directory packaging (`__init__.py`), and core modules (`math`, `random`, `os`, `pathlib`, `python-dotenv`).
6. **Advanced Python Concepts (04):** Closures, decorators, and context managers (`with` statements).
7. **Functional Programming (05):** Lambda expressions, generator functions (`yield`), and built-ins (`map`, `filter`, `zip`).
8. **Advanced OOP (06):** Magic methods (`__repr__`, `__call__`), inheritance, properties (`@property`), and abstract base classes.
9. **Exception & Data Handling (06b):** Asynchronous and synchronous error handling (`try-except-else-finally`), custom exceptions, and text/CSV/JSON processing.
10. **Data Validation (07):** Modeling schemas, nested validation, serialization, and custom constraints using **Pydantic**.
11. **Project Essentials (08):** Configurations, project structuring, and package lockfiles.
12. **FastAPI Essentials (09):** Path & query parameters, request bodies, dependency injection, and automatic OpenAPI documentation.
13. **SQL Databases & ORM (10):** Asynchronous database connections, SQLAlchemy models, relationships, and database migrations.
14. **Authentication & Security (11):** Hashing passwords with `passlib`, generating JWT tokens, and securing API endpoints.
15. **Prototyping with Streamlit (12):** Building user interfaces, widgets, state management, and connecting Streamlit frontends to FastAPI backends.
16. **Deployment (13):** Containerizing applications with Docker, managing multi-stage builds, handling environment variables, and deploying to production.

## Getting Started: Setting Up Your Environment

To write and execute code in this workshop, we need to set up a clean, modern development environment.

**Step 1: Install Python 3.12+**

We will use features from recent Python versions (like modern type hinting and syntax).

1. Go to the [Official Python Download Page](https://www.python.org/downloads/).
2. Download and run the installer for your OS (macOS, Windows, or Linux).
3. **Important (Windows users):** Ensure you check the box that says **"Add python.exe to PATH"** before clicking install.

**Verify Installation**

Open your terminal (macOS/Linux) or Command Prompt/PowerShell (Windows) and run:

```bash theme={null}
python --version
# or
python3 --version
```

*Expected Output: `Python 3.12.x` (or higher).*

**Step 2: Install and Configure VS Code**

We recommend **Visual Studio Code (VS Code)** as your editor because of its speed, lightweight nature, and excellent Python ecosystem support.

1. Download and install [VS Code](https://code.visualstudio.com/).
2. Open VS Code, go to the Extensions view (shortcut: `Ctrl+Shift+X` or `Cmd+Shift+X`), and install the following recommended plugins:
   * **Python** (by Microsoft): Syntax highlighting, debugging, and code formatting.
   * **Pylance** (by Microsoft): Fast, feature-rich static type checking.
   * **Ruff** (by Astral Software): An extremely fast Python linter and formatter.
   * **Jupyter** (by Microsoft): For running interactive Jupyter notebooks (`.ipynb`) directly inside VS Code.

***

**Step 3: Package Managers — `pip` vs `uv`**

Historically, Python developers used `pip` (Python's default package installer) combined with `virtualenv` or `venv` to manage dependencies.

While `pip` is standard, we will be using **`uv`** for this workshop.

**What is `uv`?**

Developed by Astral (the creators of Ruff), **`uv`** is an extremely fast Python package installer and resolver written in Rust. It serves as a drop-in replacement for `pip`, `pip-tools`, `virtualenv`, and `poetry`. It is typically **10x to 100x faster** than `pip` and manages virtual environments automatically.

**Installing `uv`**

The easiest way to install `uv` globally is using `pip`:

```bash theme={null}
pip install uv
```

Alternatively, you can install it using standalone installers:

* **macOS/Linux:** `curl -LsSf https://astral.sh/uv/install.sh | sh`
* **Windows:** `powershell -c "irm https://astral.sh/uv/install.ps1 | iex"`

**Verify installation:**

```bash theme={null}
uv --version
```

**Step 4: Initializing a New Project with `uv`**

Let's initialize a sandbox directory to practice code and manage our virtual environments cleanly.

1. Create a new directory and navigate into it:
   ```bash theme={null}
   mkdir python-workshop
   cd python-workshop
   ```

2. Initialize a new project with `uv`:
   ```bash theme={null}
   uv init
   ```
   *This command automatically creates a basic project structure including a `pyproject.toml` file, a `.python-version` lock, and a simple `main.py` file.*

3. Create and activate a virtual environment:
   ```bash theme={null}
   # Create a virtual environment
   uv venv

   # Verify and activate it:
   # On macOS/Linux:
   source .venv/bin/activate
   # On Windows:
   .venv\Scripts\activate
   ```

4. Install required packages (for example, `fastapi`):
   ```bash theme={null}
   uv add fastapi
   ```
   *Notice how incredibly fast the installation completes compared to standard pip!*

## Let's get Started!

Now that your development environment is ready, let's jump into the first module and explore how Python handles variables, scopes, caching, and object references behind the scenes:

[Go to Module 1: Advanced Fundamentals →](/workshop/01-advanced-fundamentals)