Flask

Flask is a lightweight WSGI web application framework for Python, built as a thin, well-composed layer over Werkzeug (WSGI, routing, request/response) and Jinja (templating). It is designed to make getting started quick and easy while giving you the freedom to scale up to complex applications on your own terms.

Unlike batteries-included frameworks, Flask deliberately makes no assumptions about your database, project layout, or tooling. It gives you a solid core - routing, request context, sessions, blueprints, and a CLI - and lets you assemble the rest from a rich ecosystem of community extensions, making it a popular choice for everything from small services to large production applications.

What You Get

• A decorator-based routing system built on Werkzeug for mapping URLs to Python view functions
• Request and response objects with context globals (request, session, g) that stay thread- and coroutine-safe
• Blueprints for splitting a large application into reusable, modular components
• Integrated Jinja templating with automatic HTML escaping and template context helpers
• A built-in CLI (flask run, flask shell) plus a development server, and a test client for writing tests

Common Use Cases

• Building REST and JSON APIs for web and mobile clients
• Serving server-rendered web applications with Jinja templates
• Prototyping services quickly in a single file before scaling up
• Backing microservices where you want a minimal, unopinionated core

Under The Hood

Architecture - Flask centers on the Flask application object in src/flask/app.py, which subclasses the shared App scaffold in src/flask/sansio/app.py and drives the WSGI callable. Incoming requests are dispatched through Werkzeug’s routing map to registered view functions, while an application and request context stack (src/flask/ctx.py) pushes context-local proxies - request, session, and g from src/flask/globals.py - for the duration of each request. Blueprints (src/flask/blueprints.py, src/flask/sansio/blueprints.py) let large apps register routes and resources modularly, and a sansio layer cleanly separates protocol-agnostic logic from WSGI-specific I/O.

Tech Stack - Flask is pure Python (requires 3.10+) and stands on four Pallets dependencies declared in pyproject.toml: Werkzeug (WSGI, routing, request/response), Jinja2 (templating), Click (the CLI), itsdangerous (signed sessions), blinker (signals), and MarkupSafe (escaping). Optional extras add asgiref for async views and python-dotenv for env loading. The project builds with Flit, pins its dev toolchain via uv (uv.lock), lints with Ruff, and tests across environments with tox.

Code Quality - The codebase is fully type-annotated (ships py.typed), consistently structured, and backed by a substantial pytest suite of 41 test modules under tests/ covering routing, contexts, blueprints, sessions, async, CLI, and templating. Pre-commit hooks, Ruff formatting/linting, and a dedicated type-check suite enforce quality, and the module layout keeps concerns well separated across small focused files.

API Design - Flask’s public API is a model of ergonomics: a five-line app.py with @app.route gets you a running server, and the surface grows predictably through decorators, blueprints, and app config. Naming is consistent and intention-revealing, the official documentation is thorough with a tutorial and worked examples (examples/tutorial, examples/celery), and the framework asks for almost no boilerplate to start while staying explicit about how requests flow.