coding-python

What this skill does

## Purpose
This skill equips the AI to generate, debug, and optimize Python 3.12+ code using core features and libraries, focusing on practical implementations for data handling, async operations, and web services.

## When to Use
Use this skill for tasks involving data analysis (e.g., with pandas/numpy), building RESTful APIs (e.g., FastAPI), asynchronous processing (e.g., async/await), data validation (e.g., pydantic), or environment management (e.g., venv/uv). Apply it when code requires type hints for maintainability or dataclasses for simple structs, especially in projects needing fast iteration.

## Key Capabilities
- **Python 3.12 Features**: Use async/await for non-blocking I/O; define dataclasses with `@dataclass` decorator; enforce type hints via `from typing import List` (e.g., `def func(x: int) -> str:`).
- **Standard Library**: Leverage `asyncio` for event loops (e.g., `asyncio.run(main())`); use `venv` for isolated environments (e.g., `python -m venv myenv`).
- **uv Tool**: Alternative to venv; install with `pip install uv`, then create env via `uv venv myenv` and activate with `source myenv/bin/activate`.
- **Libraries**: FastAPI for async web apps (e.g., define routes with `@app.get("/")`); pandas for data frames (e.g., `df = pd.DataFrame(data)`); numpy for arrays (e.g., `np.array([1, 2, 3])`); pydantic for models (e.g., `from pydantic import BaseModel; class Item(BaseModel): name: str`).

## Usage Patterns
To accomplish tasks, structure code as follows: Import necessary modules first (e.g., `import asyncio, fastapi`); use async functions for I/O-bound operations (e.g., `async def fetch_data(): await asyncio.sleep(1)`); wrap scripts in virtual environments for dependency isolation. For projects, initialize with `python -m venv .venv` then install dependencies via `pip install fastapi pandas numpy pydantic`. When generating code, ensure type hints are included (e.g., `def add(a: float, b: float) -> float: return a + b`). For async patterns, run the event loop explicitly: `asyncio.run(main())`. Always check for compatibility with Python 3.12+ by specifying in shebang or requirements.txt.

## Common Commands/API
- **CLI Commands**: Create venv with `python -m venv env_name --prompt env_name` (use `--copies` flag for Windows); activate via `source env_name/bin/activate` on Unix or `env_name\Scripts\activate` on Windows; run scripts with `uv run script.py --watch` for auto-reload. Install packages: `pip install fastapi[all]` or `uv add fastapi`.
- **API Endpoints/Methods**: In FastAPI, define an endpoint like: `from fastapi import FastAPI; app = FastAPI(); @app.get("/items/{item_id}") async def read_item(item_id: int): return {"item_id": item_id}`. For pandas, use `df.groupby('column').mean()`; for numpy, `np.dot(array1, array2)`; for pydantic, validate data with `item = Item(name="example")`.
- **Config Formats**: Use JSON for FastAPI configs (e.g., `{"debug": true}` in settings.py); environment variables for keys (e.g., `os.environ.get('API_KEY')`); requirements.txt for dependencies (e.g., `fastapi>=0.95.0\npandas==2.0.0`).

## Integration Notes
Integrate this skill by setting up a Python project: First, create a venv and install libraries with `pip install -r requirements.txt`. For external services, use env vars for authentication (e.g., set `export API_KEY=your_key` and access via `os.getenv('API_KEY')` in code). When combining with other tools, import as needed (e.g., for async database queries, use `async with database.connect() as conn:`). Ensure compatibility: Python 3.12+ is required, so specify in pyproject.toml with `[tool.poetry.dependencies] python = "^3.12"`. For testing, use pytest with `pytest --asyncio-mode=auto` to handle async tests.

## Error Handling
Always wrap potentially failing code in try-except blocks: `try: result = await fetch_data() except asyncio.TimeoutError as e: print(f"Timeout: {e}")`. Handle specific library errors, like pandas' `KeyError` for missing columns (e.g., `try: df['nonexistent'] except KeyError: df['nonexistent'] = 0`). For pydantic, catch `ValidationError` (e.g., `from pydantic import ValidationError; try: item = Item(name=123) except ValidationError as e: log_error(e)`). Use FastAPI's exception handlers: `@app.exception_handler(RequestValidationError) async def validation_exception_handler(request, exc): return JSONResponse(status_code=400, content={"detail": exc.errors()})`. Log errors with `import logging; logging.error("Message")` and ensure graceful shutdown in async code via `try-finally`.

## Usage Examples
1. **Build a FastAPI Endpoint**: To create a simple async API for data retrieval, use: `from fastapi import FastAPI; import asyncio; app = FastAPI(); async def get_data(): await asyncio.sleep(1); return {"data": "fetched"}; @app.get("/") async def root(): return await get_data()`. Run with `uvicorn main:app --reload --port 8000`.
2. **Data Analysis with Pandas and Numpy**: For processing a dataset, import libraries and compute: `import pandas as pd; import numpy as np; df = pd.DataFrame({'A': [1, 2]}); result = np.mean(df['A']); print(result)  # Outputs mean value`. Use in a script: Save as analyze.py and run via `python analyze.py`.

## Graph Relationships
- Related to: coding cluster (e.g., shares tags with "coding-general" for broader scripting; connects to "web-dev" via FastAPI for API building; links to "data-science" through pandas/numpy for analysis workflows).