python-development
Modern Python development with Python 3.12+, Django, FastAPI, async patterns, and production best practices. Use for Python projects, APIs, data processing, or automation scripts.
When & Why to Use This Skill
This Claude skill serves as a comprehensive guide and toolkit for modern Python 3.12+ development. It streamlines the creation of high-performance applications by providing production-ready templates for FastAPI and Django, implementing advanced asynchronous patterns, and enforcing industry best practices like strict type hinting and automated testing. It is designed to accelerate the development lifecycle while ensuring code maintainability and scalability.
Use Cases
- Rapid API Development: Quickly scaffold production-grade RESTful APIs using FastAPI with integrated Pydantic validation and dependency injection patterns.
- Asynchronous Data Processing: Implement efficient I/O-bound operations and streaming services using modern async/await patterns and aiohttp for high-concurrency tasks.
- Project Scaffolding & Standardization: Establish standardized Python project structures using pyproject.toml, ruff for linting, and mypy for strict type checking to ensure team-wide consistency.
- Robust Testing Frameworks: Generate comprehensive unit and integration test suites using pytest and AsyncMock to maintain high code quality and prevent regressions in complex systems.
| name | python-development |
|---|---|
| description | Modern Python development with Python 3.12+, Django, FastAPI, async patterns, and production best practices. Use for Python projects, APIs, data processing, or automation scripts. |
| source | wshobson/agents |
| license | MIT |
Python Development
Project Setup
Modern Python Project Structure
my-project/
├── src/
│ └── my_project/
│ ├── __init__.py
│ ├── main.py
│ └── utils.py
├── tests/
│ ├── __init__.py
│ └── test_main.py
├── pyproject.toml
├── README.md
└── .gitignore
pyproject.toml
[project]
name = "my-project"
version = "0.1.0"
requires-python = ">=3.12"
dependencies = [
"fastapi>=0.100.0",
"pydantic>=2.0",
]
[project.optional-dependencies]
dev = [
"pytest>=7.0",
"ruff>=0.1.0",
"mypy>=1.0",
]
[tool.ruff]
line-length = 88
select = ["E", "F", "I", "N", "W"]
[tool.mypy]
strict = true
Type Hints
from typing import TypeVar, Generic
from collections.abc import Sequence
T = TypeVar('T')
def process_items(items: Sequence[str]) -> list[str]:
return [item.upper() for item in items]
class Repository(Generic[T]):
def get(self, id: int) -> T | None: ...
def save(self, item: T) -> T: ...
Async Patterns
import asyncio
from collections.abc import AsyncIterator
async def fetch_all(urls: list[str]) -> list[dict]:
async with aiohttp.ClientSession() as session:
tasks = [fetch_one(session, url) for url in urls]
return await asyncio.gather(*tasks)
async def stream_data() -> AsyncIterator[bytes]:
async with aiofiles.open('large_file.txt', 'rb') as f:
async for chunk in f:
yield chunk
FastAPI Patterns
from fastapi import FastAPI, Depends, HTTPException
from pydantic import BaseModel
app = FastAPI()
class UserCreate(BaseModel):
email: str
name: str
class UserResponse(BaseModel):
id: int
email: str
name: str
@app.post("/users", response_model=UserResponse)
async def create_user(
user: UserCreate,
db: Database = Depends(get_db)
) -> UserResponse:
result = await db.users.create(user.model_dump())
return UserResponse(**result)
Testing
import pytest
from unittest.mock import AsyncMock, patch
@pytest.fixture
def mock_db():
db = AsyncMock()
db.users.get.return_value = {"id": 1, "name": "Test"}
return db
@pytest.mark.asyncio
async def test_get_user(mock_db):
result = await get_user(1, db=mock_db)
assert result["name"] == "Test"
mock_db.users.get.assert_called_once_with(1)
Best Practices
- Use
rufffor linting and formatting - Use
mypywith strict mode - Prefer
pathlib.Pathoveros.path - Use dataclasses or Pydantic for data structures
- Use
asynciofor I/O-bound operations - Use
contextlib.asynccontextmanagerfor async resources