The Pyramid Web Framework

The Pyramid Framework was developed in Python as a way for developers to rapidly create web applications. I have worked with it while developing web pages and APIs and other types of projects. Pyramid follows a “start small, grow big” philosophy, making it easy for beginning developers and experienced developers to use as well.

This framework is built to handle incoming requests, route those requests to the appropriate code, and return the responses to the client. Moreover, Pyramid is a very fast and flexible framework, making it a good solution for developing all sizes of projects.

In this blog, I will explain to you about what is Pyramid framework, its core components, working and many more. Let’s start!

What is Pyramid Framework?

The Pyramid Framework is an open-source, Python-based web framework that uses the "start small, finish big, stay finished" philosophy. It is a general-purpose web development framework created as part of the Pylons Project putting minimalism, speed and maximum flexibility at its core.

Basic Example (Hello World)

from pyramid.config import Configurator
from pyramid.response import Response
from wsgiref.simple_server import make_server

def hello_world(request):
    return Response("Hello, World!")

with Configurator() as config:
    config.add_route('home', '/')
    config.add_view(hello_world, route_name='home')
    
    app = config.make_wsgi_app()

server = make_server('0.0.0.0', 6543, app)
print("Server running at http://localhost:6543")
server.serve_forever()

Read Also: Tornado Framework

Core Components of Pyramid

Pyramid is a very flexible and minimalistic framework. The major components of Pyramid (i.e. Configurator, Routes, Views, Requests and Responses) work in tandem to provide an efficient method to manage incoming web requests. However, features such as Traversal, Tweens and Security can enhance the functionality and power of the Pyramid framework when developing larger complex web applications.

1. Configurator

• At the core of configuring Pyramid.

• It creates routes, views and templates etc.

• All configuration in Pyramid is done with the Configuration object.

For example:

from pyramid.config import Configurator

with Configurator() as config:
    config.add_route('home', '/')

2. Routing

• Creates URL Patterns for your app.

• Associates a URL Pattern with a View.

For example:

config.add_route('home', '/')

3. Views

• Functions or classes that produce responses to requests.

• A view can be mapped to one or more routes and vice versa.

For example:

def home_view(request):
    return {'message': 'Hello World'}

4. Request Object

All data about the HTTP request is stored in the Request object – including form submissions, headers and any query parameters that appear in the request URL.

For example:

def home_view(request):
    name = request.params.get('name', 'Guest')
    return {'message': f'Hello {name}'}

5. Response Object

• The output of your application that is sent back to the requesting client.

• A response can be a representation of an object (HTML or JSON), or just the text itself.

For example:

from pyramid.response import Response

def home_view(request):
    return Response('Hello World')

6. Templates (Renderers)

• To render Dynamic HTML.

• Pyramid supports multiple template engines (Jinja2 / Chameleon / etc.)

For example:

return {'name': 'Yuri'}

7. Traverse (Optional Routing)

• A more granular routing approach using a Resource Tree.

• Traverse can be helpful when creating complex applications.

8. Middleware (Tween)

• Components that process requests before or after a view has been called.

• Can be thought of as middleware in other applications.

9. Security

• Responsible for user Authentication and Authorization.

• Controls access of users or groups to resources.

10. Assets & Static Files

Manage static content like CSS, JS, images

For example:

config.add_static_view(name='static', path='static')

11. Events & Subscribers

• You can run your own code based on events happening.

• Assists in Decoupling Components.

Read Also: Introduction to CherryPy

How does a Pyramid work?

Pyramid works by handling user requests through a simple and flexible process. When a request is received, it matches a URL to a specific route, processes it using a view and returns a response. This structure allows developers to control how data flows in the application.

1. User makes Request

The user loads a page of a website or clicks on a link in their browser where an HTTP request ( GET or POST type ) is sent to the application Pyramid.

2. URL Routing Matches

• Pyramid routes the request URL to a matching route in your application.

• Routing maps URL to a specific function e.g. /home → home view

• This allows Pyramid to determine which view to call.

3. View Selected

• Pyramid calls the appropriate view once the route matches.

• A view is a Python function that takes care of the processing and business logic for the request.

• This is where your application does most of its processing.

4. Business Logic Executed

In this view, the business logic of your application is executed.

• Database calls may occur to retrieve data from a database.

• Calculations and processing may occur.

• Condition- and decision-based processing occurs.

This is the core logic of the application.

5. Response Built

The view builds a response by creating an HTTP response of one of the following types:

• HTML (for websites)

• JSON (for APIs)

• Plain text

Pyramid converts the response built in the view to an HTTP response.

6. (Optional) Render Template

If the response is HTML:

The HTML response uses a template (e.g., .html file) as the basis for building a dynamic web page.

The dynamic data is merged with the template to produce the final web page.

7. Response Sent Back to User

Finally, the HTTP response is returned to the user using the browser.

Read Also: Bottle Web Framework

Pyramid Web Framework Real World Applications

Pyramid Web Framework is flexible and powerful as it is used in many real-world applications. From small projects to large systems, developers use it to build scalable and customizable web solutions. Here are some of its common applications:

1. Content Management Systems (CMS)

Users of the Pyramid content management platform are able to create a full online directory of their websites that includes text, images and pages. An example of this would be Plone, which uses the Pyramid framework to build a content management system.

For example: Simple Blog Page

from wsgiref.simple_server import make_server
from pyramid.config import Configurator
from pyramid.response import Response

def blog(request):
    return Response("Welcome to My Blog!")

with Configurator() as config:
    config.add_route('blog', '/')
    config.add_view(blog, route_name='blog')
    app = config.make_wsgi_app()

server = make_server('0.0.0.0', 6543, app)
server.serve_forever()

2. E-commerce Platforms

The Pyramid framework allows developers to create highly customizable e-commerce sites that enable the management of products, user accounts and payment processing.

For example:

def product(request):
    return Response("Product: Laptop - ₹50,000")

config.add_route('product', '/product')
config.add_view(product, route_name='product')

3. Backend Services and RESTful APIs

The Pyramid framework is the basis for a wide range of modern RESTful APIs. It provides front-end (web/mobile) applications with a secure connection to a backend data store, allowing for easy data exchange between the two.

For example:

from pyramid.response import Response
from pyramid.view import view_config

@view_config(route_name='api', renderer='json')
def api_view(request):
    return {"message": "Hello API"}

config.add_route('api', '/api')

4. Enterprise Web Applications

Many enterprise size companies rely on the Pyramid framework to create and maintain their internal business applications, such as employee dashboards, CRM solutions and overall business management tools.

For example:

def dashboard(request):
    return Response("Welcome to Admin Dashboard")

config.add_route('dashboard', '/dashboard')
config.add_view(dashboard, route_name='dashboard')

5. Social Networking

In addition to being able to build enterprise or consumer-based applications, Pyramid is a great option for building social networking-based applications where users can engage with each other, share content and communicate.

For example:

from wsgiref.simple_server import make_server
from pyramid.config import Configurator
from pyramid.response import Response
import json

# Dummy user data
users = {
    "1": {"name": "Rahul", "bio": "Loves coding"},
    "2": {"name": "Rohit", "bio": "Tech enthusiast"}
}

def get_user(request):
    user_id = request.matchdict.get('id')
    user = users.get(user_id)
    
    if user:
        return Response(json.dumps(user), content_type='application/json')
    return Response(json.dumps({"error": "User not found"}), status=404)

if __name__ == '__main__':
    with Configurator() as config:
        config.add_route('user', '/user/{id}')
        config.add_view(get_user, route_name='user')
        
        app = config.make_wsgi_app()
    
    server = make_server('0.0.0.0', 6543, app)
    print("Server running on http://localhost:6543")
    server.serve_forever()

6. Data & Analytics Applications

Pyramid can be utilized for developing dashboards, reporting tools and other applications that display data visually or provide fundamental analysis type insights to users regarding their data.

For example:

from wsgiref.simple_server import make_server
from pyramid.config import Configurator
from pyramid.response import Response
import json

# Sample analytics data
data = {
    "visitors": 1200,
    "sales": 300,
    "conversion_rate": "25%"
}

def analytics(request):
    return Response(json.dumps(data), content_type='application/json')

if __name__ == '__main__':
    with Configurator() as config:
        config.add_route('analytics', '/analytics')
        config.add_view(analytics, route_name='analytics')
        
        app = config.make_wsgi_app()
    
    server = make_server('0.0.0.0', 6543, app)
    print("Server running on http://localhost:6543")
    server.serve_forever()

Read Also: Python Interview Questions and Answers

Pyramid vs Flask vs Django: Key Differences

Choosing between Pyramid, Flask and Django depends on your project needs. Let’s compare them simply so you can understand which one fits best based on flexibility, complexity and use case.

Advantages of Pyramid Web Framework

Pyramid is a flexible and lightweight Python web framework that lets developers start small and grow applications as needed. It offers simplicity, scalability and powerful customization options, making it suitable for both beginners and advanced users.

1. Flexibility:

Pyramid lets you build small and large applications. You can start simple and add features as your project grows without changing the framework.

2. Minimal Restrictions:

As compared to other frameworks, Pyramid does not have any strict rules. Developers can choose tools, libraries and structures based on their needs.

3. Scalable:

It works well for both beginners and large-scale applications. You can easily expand your app without rewriting everything.

4. Easy to Learn:

You can start with a simple setup and gradually learn advanced concepts. Beginners can build basic apps quickly.

5. Powerful URL Routing:

Pyramid provides flexible and powerful routing, which makes it easy to manage URLs and connect them to views.

6. Strong Documentation:

It has clear and detailed documentation, which helps developers understand and implement features easily.

Disadvantages of Pyramid Web Framework

While Pyramid is flexible, it can be harder to learn for beginners due to fewer built-in features compared to other frameworks. Developers may need to spend extra time configuring tools and components for building complete applications.

1. Learning Curve Is Steeper Than Alternatives:

While setting up a basic pyramid is fairly simple, using more advanced features, such as configuring a pyramid, defining an application's routing and managing security, could be difficult for an inexperienced user to learn.

2. Less Popular Than Other Frameworks:

Other frameworks (i.e. Django and Flask) have larger user communities than pyramids do, which translates to fewer available resources for an inexperienced user to learn about the framework and its use.

3. More Manual Configuration:

A pyramid will need many manual configurations in addition to its basic setup. In fact, in many cases it will require more manual configurations than one or more of the previously mentioned frameworks may require to be set up and/or used.

Wrapping Up

The Pyramid web framework for Python allows you to create applications ranging from basic to very complex in a flexible manner. By utilizing organized core elements (routes and views) it is able to provide a mechanism for processing requests in a timely fashion. Although it takes time to set up, its ease of scalability, flexibility and true productivity make it an excellent choice.

FAQs

1. Are beginners able to use Pyramids?

Pyramids are considered beginner-friendly, but there can be an initial learning curve. Beginners can use some of the more straightforward applications but will take a while to get accustomed to the flexibility of Pyramid.

2. What programming language is Pyramid written?

Pyramid is a framework written in Python; therefore, having basic knowledge of Python is necessary to develop applications with Pyramid.

3. Is Pyramid capable of supporting large web-based applications?

Pyramid has a scalable architecture and is used to build very large, complex applications.

4. Does Pyramid use an MVC (model-view-controller) architecture?

Pyramid does not adhere strictly to the MVC architecture; however it does use the basic concepts of MVC by utilizing routes, views and models.