Author: 6630a6

Looking for a fast, single‑file web framework that lets you prototype APIs and micro‑services in minutes? Python Bottle is the perfect blend of simplicity and power, offering a lightweight solution that doesn’t sacrifice flexibility. In this guide we’ll explore what makes Bottle stand out, walk through a complete “Hello World” example, and uncover advanced features like routing, templating, plugins, and deployment options—all while keeping the codebase under 100 KB.

What Is Bottle?

Bottle is a micro web framework for Python, designed to be easy to install, understand, and extend. It follows the philosophy of “one file, zero dependencies” (apart from the Python standard library), which makes it ideal for:

• Quick prototypes and proof‑of‑concept projects.
• Embedded devices or serverless functions where size matters.
• Learning the fundamentals of web development without the overhead of larger frameworks.

Despite its minimal footprint, Bottle supports routing, request/response handling, templates, static files, and a robust plugin system—features you’d expect from full‑stack frameworks like Flask or Django.

Getting Started: Installation and First App

Installation in One Command

Because Bottle is pure Python, installing it is straightforward:

pip install bottle

If you prefer a single‑file deployment, you can even download bottle.py directly from the official repository and place it alongside your script.

“Hello World” in 10 Lines

Below is a minimal Bottle application that listens on localhost:8080 and returns “Hello, World!” when you visit the root URL.

from bottle import route, run

@route('/')
def hello():
    return "Hello, World!"

run(host='localhost', port=8080, debug=True)

Save this as app.py and run python app.py. Open http://localhost:8080 in your browser to see the result.

Core Features of Bottle

1. Powerful Routing System

Bottle’s routing engine lets you define dynamic URLs with placeholders, regular expressions, and HTTP method constraints.

@route('/user/<id:int>', method='GET')
def get_user(id):
    return f"User ID: {id}"

Supported converters include int, float, path, and custom regex patterns, giving you fine‑grained control over URL matching.

2. Request and Response Objects

Access request data via bottle.request and manipulate outgoing headers with bottle.response:

from bottle import request, response

@route('/login', method='POST')
def login():
    username = request.forms.get('username')
    response.set_cookie('user', username, secret='my_secret')
    return f"Welcome, {username}!"

3. Built‑In Template Engine

Bottle includes a simple yet powerful template language that supports variable interpolation, loops, and conditionals.

# templates/hello.tpl
<h1>Hello {{name}}!</h1>
{% if items %}
  <ul>
  {% for item in items %}
    <li>{{item}}</li>
  {% endfor %}
  </ul>
{% else %}
  <p>No items found.</p>
{% endif %}

Render the template from a route:

from bottle import template

@route('/greet/<name>')
def greet(name):
    items = ['Apple', 'Banana', 'Cherry']
    return template('hello', name=name, items=items)

4. Serving Static Files

Static assets (CSS, JavaScript, images) can be served with a single decorator:

@route('/static/<filename:path>')
def static(filename):
    return static_file(filename, root='./static')

This approach eliminates the need for a separate web server during development.

5. Extensible Plugin Architecture

Bottle’s plugin system lets you inject functionality—like database connections or authentication—into route handlers without cluttering your code.

from bottle import PluginError

class SimpleAuthPlugin(object):
    name = 'simple_auth'
    api = 2

    def __init__(self, secret):
        self.secret = secret

    def apply(self, callback, route):
        def wrapper(*args, **kwargs):
            token = request.get_cookie('auth', secret=self.secret)
            if not token:
                return HTTPError(401, "Unauthorized")
            return callback(*args, **kwargs)
        return wrapper

# Register the plugin
app = Bottle()
app.install(SimpleAuthPlugin(secret='my_secret'))

When to Choose Bottle Over Other Frameworks

• Minimal footprint: If you need a framework that fits on a single file or a tiny Docker image, Bottle wins.
• Rapid prototyping: Write a full API in under an hour with zero configuration.
• Embedded or serverless environments: Bottle’s low memory usage makes it ideal for AWS Lambda, Raspberry Pi, or IoT devices.
• Learning fundamentals: Because Bottle strips away hidden magic, you see exactly how routing, request handling, and templating work under the hood.

Conversely, for large‑scale applications with complex ORM needs, admin panels, or built‑in authentication, a more feature‑rich framework like Django or Flask (with extensions) might be a better fit.

Best Practices for Production‑Ready Bottle Apps

1. Separate configuration: Store settings (debug mode, secret keys, DB URLs) in environment variables or a dedicated .env file.
2. Use a WSGI server: Deploy with gunicorn or uWSGI instead of Bottle’s built‑in server for better performance and stability.
3. Enable logging: Configure Python’s logging module to capture request details and errors.
4. Apply security headers: Add Content‑Security‑Policy, X‑Frame‑Options, and Strict‑Transport‑Security via a middleware plugin.
5. Write unit tests: Use pytest with Bottle’s TestApp to simulate requests and verify responses.

Example of running Bottle with Gunicorn:

gunicorn -w 4 -b 0.0.0.0:8000 app:app

Here app is the Bottle instance exported from app.py.

Community, Documentation, and Learning Resources

The Bottle ecosystem may be smaller than Flask’s, but it’s vibrant and well‑documented. Key resources include:

• Official Bottle documentation – comprehensive API reference and tutorials.
• GitHub repository – source code, issue tracker, and community contributions.
• Community blogs and YouTube channels that showcase real‑world Bottle projects, such as building RESTful APIs, IoT dashboards, and serverless functions.

Because Bottle is a single file, reading bottle.py itself is an excellent way to understand the inner workings of a web framework.

Conclusion

Python Bottle delivers a remarkable balance of lightweight design and , making it a go‑to choice for developers who value speed, simplicity, and full control over their code. Whether you’re building a quick API endpoint, a micro‑service for a larger architecture, or an embedded web interface on a device, Bottle’s single‑file footprint, powerful routing, and extensible plugin system provide everything you need without the bloat of larger frameworks. Install it today, experiment with the examples above, and discover how quickly you can turn a Python script into a production‑ready web application.

Python Tornado async framework guide – If you’re building real‑time web applications, WebSocket services, or high‑throughput APIs, Tornado’s non‑blocking I/O and native async/await support make it a top choice. In this comprehensive guide we’ll explore Tornado’s core concepts, walk through a step‑by‑step setup, and reveal best practices for writing clean, scalable asynchronous code. Whether you’re a seasoned Python developer or just starting with async programming, this article equips you with everything you need to master Tornado.

Why Choose Tornado for Asynchronous Python?

Tornado was created by FriendFeed (now part of Facebook) to handle thousands of simultaneous connections without spawning a new thread per request. Its key advantages include:

• Event‑driven architecture: Powered by IOLoop, Tornado processes I/O events in a single thread, reducing context‑switch overhead.
• Native async/await support: Since version 5.0, Tornado integrates seamlessly with Python’s asyncio library.
• WebSocket & long‑polling: Built‑in handlers simplify real‑time communication.
• Extensible request handling: Mix classic RequestHandler classes with coroutine‑based handlers for flexible code reuse.
• Production‑ready: Tornado runs as a standalone server or behind a reverse proxy (NGINX, HAProxy) and scales horizontally with tornado.process.fork_processes.

Getting Started: Installation and Project Layout

Step 1 – Install Tornado

Use pip to install the latest stable release. It’s recommended to work inside a virtual environment:

python -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate
pip install tornado

Step 2 – Basic Project Structure

A clean layout helps maintainability as the codebase grows:

my_tornado_app/
├── app.py               # Entry point, IOLoop configuration
├── handlers/
│   ├── __init__.py
│   └── main_handler.py  # Example RequestHandler classes
├── static/              # CSS, JS, images
└── templates/           # HTML/Jinja2 templates

Core Concepts of Tornado

The IOLoop

The IOLoop is Tornado’s event loop. It watches file descriptors, timers, and callbacks, executing them when they become ready. In most applications you’ll interact with it like this:

import tornado.ioloop

if __name__ == "__main__":
    tornado.ioloop.IOLoop.current().start()

When you use async def in a handler, Tornado automatically registers the coroutine with the running IOLoop.

RequestHandler and Asynchronous Methods

Every HTTP endpoint is represented by a subclass of tornado.web.RequestHandler. To make a handler asynchronous, simply define an async method and use await for I/O operations:

import tornado.web
import aiohttp

class AsyncFetchHandler(tornado.web.RequestHandler):
    async def get(self):
        url = self.get_argument('url')
        async with aiohttp.ClientSession() as session:
            async with session.get(url) as resp:
                data = await resp.text()
        self.write({"fetched": data[:200]})

WebSocketHandler

Tornado’s WebSocketHandler abstracts the WebSocket handshake and message framing. Below is a minimal echo server:

import tornado.websocket

class EchoWebSocket(tornado.websocket.WebSocketHandler):
    async def open(self):
        print("WebSocket opened")

    async def on_message(self, message):
        await self.write_message(f"Echo: {message}")

    def on_close(self):
        print("WebSocket closed")

Building a Real‑World Async API with Tornado

1. Define URL Routes

Routes map URLs to handler classes. Use a list of tuples and pass it to tornado.web.Application:

import tornado.web
from handlers.main_handler import AsyncFetchHandler, EchoWebSocket

def make_app():
    return tornado.web.Application([
        (r"/fetch", AsyncFetchHandler),
        (r"/ws", EchoWebSocket),
    ], debug=True)  # Debug enables auto‑reload during development

2. Run the Server

The entry point creates the application, binds to a port, and starts the IOLoop:

import tornado.ioloop
from app import make_app

if __name__ == "__main__":
    app = make_app()
    app.listen(8888)  # Change to 80/443 behind a proxy if needed
    print("Tornado server listening on http://localhost:8888")
    tornado.ioloop.IOLoop.current().start()

3. Adding Database Access

For async database operations, choose a driver that supports asyncio (e.g., aiopg for PostgreSQL, motor for MongoDB). Example with motor:

import motor.motor_tornado

client = motor.motor_tornado.MotorClient("mongodb://localhost:27017")
db = client.mydb

class UserHandler(tornado.web.RequestHandler):
    async def get(self, user_id):
        user = await db.users.find_one({"_id": user_id})
        if user:
            self.write(user)
        else:
            self.set_status(404)
            self.write({"error": "User not found"})

Performance Tuning and Best Practices

• Use asyncio compatible libraries: Mixing blocking I/O (e.g., requests) with Tornado will stall the event loop. Prefer aiohttp, aiomysql, etc.
• Leverage tornado.httpclient.AsyncHTTPClient for internal calls: It reuses a connection pool and integrates natively with the IOLoop.
• Enable debug=True only in development: Debug mode adds overhead and should be disabled in production.
• Set proper timeouts: Use request_timeout and connect_timeout on HTTP clients to avoid hanging connections.
• Scale with multiple processes: tornado.process.fork_processes spawns workers equal to CPU cores, distributing load without GIL contention.

Example: Forking Workers

import tornado.process
import tornado.web

def main():
    app = make_app()
    app.listen(8888)
    tornado.process.fork_processes(0)  # 0 = number of CPU cores
    tornado.ioloop.IOLoop.current().start()

if __name__ == "__main__":
    main()

Testing Tornado Applications

Tornado provides AsyncHTTPTestCase for unit testing async handlers. Combine it with unittest or pytest for a full test suite.

import tornado.testing
import tornado.web
from handlers.main_handler import AsyncFetchHandler

class FetchTest(tornado.testing.AsyncHTTPTestCase):
    def get_app(self):
        return tornado.web.Application([(r"/fetch", AsyncFetchHandler)])

    @tornado.testing.gen_test
    async def test_fetch_success(self):
        response = await self.fetch("/fetch?url=http://example.com")
        self.assertEqual(response.code, 200)
        self.assertIn(b"fetched", response.body)

Deploying Tornado in Production

1. Containerize with Docker: Build a lightweight image using python:3.12-slim and expose port 8888.
2. Use a reverse proxy: NGINX can handle TLS termination, static file serving, and request buffering.
3. Monitor with Prometheus: Export metrics via tornado.metrics or custom endpoints.
4. Graceful shutdown: Capture SIGTERM and stop the IOLoop after completing pending coroutines.

Sample Dockerfile:

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
EXPOSE 8888
CMD ["python", "app.py"]

Common Pitfalls and How to Avoid Them

• Blocking code in async handlers: Even a single time.sleep() will block the entire server. Replace with await asyncio.sleep().
• Improper exception handling: Uncaught exceptions terminate the coroutine silently. Use try/except blocks and self.set_status(500) for API errors.
• Mixing asyncio loops: Ensure only one event loop runs per process. Avoid calling asyncio.run() inside a Tornado handler.
• Large payloads without streaming: For file uploads/downloads, use stream_request_body=True and chunked responses to keep memory usage low.

Conclusion

Python Tornado remains a powerful, battle‑tested async framework that excels at handling thousands of concurrent connections with minimal

Python microservices gRPC tutorial – In today’s cloud‑native world, building scalable, low‑latency services is essential. While REST APIs remain popular, gRPC offers a binary protocol, contract‑first design, and built‑in support for streaming, making it a perfect fit for Python microservices. This step‑by‑step guide walks you through setting up a gRPC‑based microservice architecture in Python, from installing dependencies to containerizing the service for production. By the end, you’ll have a fully functional example you can extend, test, and deploy with confidence.

Why Choose gRPC for Python Microservices?

• Performance: gRPC uses HTTP/2 and Protocol Buffers, delivering faster serialization and lower bandwidth usage than JSON over HTTP/1.1.
• Strong typing: The .proto contract enforces data schemas across services, reducing runtime errors.
• Streaming support: Built‑in client, server, and bidirectional streaming simplify real‑time data pipelines.
• Cross‑language interoperability: A single .proto file can generate client and server code for Python, Go, Java, and more.
• Built‑in load balancing & authentication: gRPC integrates with modern service meshes like Istio.

Prerequisites

1. Python 3.9+ installed on your workstation.
2. Basic familiarity with microservice architecture concepts.
3. Docker (optional, but recommended for deployment).
4. Text editor or IDE of your choice.

Step 1 – Set Up the Python Environment

Create a virtual environment

python -m venv grpc-env
source grpc-env/bin/activate  # On Windows use `grpc-env\Scripts\activate`

Install required packages

pip install grpcio grpcio-tools protobuf

These packages provide the core gRPC runtime (grpcio) and the code‑generation tools (grpcio-tools) that compile .proto definitions into Python modules.

Step 2 – Define the Service Contract with Protocol Buffers

All gRPC communication starts with a .proto file that describes messages and RPC methods. Create a folder proto/ and add calculator.proto:

syntax = "proto3";

package calculator;

// The request message containing two numbers.
message Operands {
  double a = 1;
  double b = 2;
}

// The response message containing the result.
message Result {
  double value = 1;
}

// The Calculator service definition.
service Calculator {
  // Unary RPC.
  rpc Add (Operands) returns (Result);
  rpc Subtract (Operands) returns (Result);

  // Server‑streaming RPC.
  rpc PrimeFactors (Operands) returns (stream Result);
}

This contract defines a simple Calculator microservice with two unary methods (Add, Subtract) and one server‑streaming method (PrimeFactors).

Step 3 – Generate Python Code from the .proto File

python -m grpc_tools.protoc -I./proto --python_out=./generated --grpc_python_out=./generated ./proto/calculator.proto

The command creates two files in generated/:

• calculator_pb2.py – contains the message classes.
• calculator_pb2_grpc.py – contains the service stub and base classes.

Step 4 – Implement the gRPC Server

Server code (server.py)

import grpc
from concurrent import futures
import time
import math

# Import the generated classes
import generated.calculator_pb2 as calc_pb2
import generated.calculator_pb2_grpc as calc_pb2_grpc

class CalculatorServicer(calc_pb2_grpc.CalculatorServicer):
    """Implements the Calculator service defined in calculator.proto."""

    def Add(self, request, context):
        result = request.a + request.b
        return calc_pb2.Result(value=result)

    def Subtract(self, request, context):
        result = request.a - request.b
        return calc_pb2.Result(value=result)

    def PrimeFactors(self, request, context):
        """Server‑streaming RPC that yields prime factors of `a`."""
        n = int(request.a)
        factor = 2
        while n > 1:
            while n % factor == 0:
                yield calc_pb2.Result(value=factor)
                n //= factor
            factor += 1

def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
    calc_pb2_grpc.add_CalculatorServicer_to_server(CalculatorServicer(), server)
    server.add_insecure_port('[::]:50051')
    server.start()
    print("🔧 gRPC server listening on port 50051...")
    try:
        while True:
            time.sleep(86400)  # Keep server alive for 1 day
    except KeyboardInterrupt:
        server.stop(0)

if __name__ == '__main__':
    serve()

Key points:

• We use a ThreadPoolExecutor for concurrency, allowing multiple RPCs to be handled in parallel.
• The PrimeFactors method demonstrates server‑streaming by yielding Result messages.

Step 5 – Build the gRPC Client

Client code (client.py)

import grpc
import generated.calculator_pb2 as calc_pb2
import generated.calculator_pb2_grpc as calc_pb2_grpc

def run():
    # Establish a channel to the server (insecure for demo purposes)
    channel = grpc.insecure_channel('localhost:50051')
    stub = calc_pb2_grpc.CalculatorStub(channel)

    # Unary calls
    add_response = stub.Add(calc_pb2.Operands(a=15, b=27))
    print(f"Add: 15 + 27 = {add_response.value}")

    sub_response = stub.Subtract(calc_pb2.Operands(a=15, b=27))
    print(f"Subtract: 15 - 27 = {sub_response.value}")

    # Server‑streaming call
    print("Prime factors of 84:")
    for factor in stub.PrimeFactors(calc_pb2.Operands(a=84, b=0)):
        print(f"  - {int(factor.value)}")

if __name__ == '__main__':
    run()

The client demonstrates both unary and streaming RPCs. In production, you’d replace the insecure channel with grpc.secure_channel and configure TLS certificates.

Step 6 – Dockerize the Microservice

Containerization ensures consistent runtime across environments. Create a Dockerfile in the project root:

# Use official Python slim image
FROM python:3.11-slim

# Set working directory
WORKDIR /app

# Copy only requirements first for caching
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy source code
COPY . /app

# Expose gRPC port
EXPOSE 50051

# Default command runs the server
CMD ["python", "server.py"]

Generate requirements.txt:

grpcio==1.64.0
grpcio-tools==1.64.0
protobuf==5.27.0

Build and run the container:

docker build -t python-grpc-calculator .
docker run -p 50051:50051 python-grpc-calculator

Now the service is accessible at localhost:50051 from any client, including the client.py script running on the host machine.

Step 7 – Test the Service with Automated Unit Tests

Testing with pytest and grpc-testing

pip install pytest pytest-mock

Create test_calculator.py:

import grpc
import pytest
from concurrent import futures

import generated.calculator_pb2 as calc_pb2
import generated.calculator_pb2_grpc as calc_pb2_grpc
from server import CalculatorServicer

@pytest.fixture(scope="module")
def grpc_server():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=2))
    calc_pb2_grpc.add_CalculatorServicer_to_server(CalculatorServicer(), server)
    port = server.add_insecure_port('localhost:0')
    server.start()
    yield f'localhost:{port}'
    server.stop(0)

def test_add(grpc_server):
    channel = grpc.insecure_channel(grpc_server)
    stub = calc_pb2_grpc.CalculatorStub(channel)
    resp = stub.Add(calc_pb2.Operands(a=10, b=5))
    assert resp.value == 15

def test_prime_factors(grpc_server):
    channel = grpc.insecure_channel(grpc_server)
    stub = calc_pb2_grpc.CalculatorStub(channel)
    factors = [int(r.value) for r in stub.PrimeFactors(calc_pb2.Operands(a=30, b=0))]
    assert factors == [2, 3, 5]

Run the tests:

pytest -q

Best Practices for Python gRPC Microservices

• Use TLS everywhere: Replace insecure_channel with