Guide: Pyramid for People - Part 2

    Part 1 - preface and content.


    Pyramid is excellent in building web applications in several ways. Like Pylons, before its introduction, Pyramid can build traditional route-oriented RDBMS applications using SQLAlchemy. Unlike other RDBMS-based web frameworks, Pyramid is also very well equipped to easily build content-oriented applications familiar from the world of Plone and Zope.

    Since this is a tutorial for the Plone conference, we chose a presentation scenario that shows the strengths of Pyramid in content-oriented applications. More precisely, a hierarchical project management system where you can set tasks for teams.

    As we study this tutorial, we will be creating an application called Projector.

    How to install

    This tutorial assumes that you already have Python 2.6 and above installed, you have an Internet connection, and a text editor of your choice. This is enough to get you started with the first step. Other steps may require the installation of additional packages.

    Text note: Windows users need to adapt UNIX isms to suit your work environment.

    Our workspace will look like this:

    someworkingdirectory /
      tutorial_workspace /
        venv ### Target for our virtualenv
        creatingux /


    Open the shell and go into the working directory in it

    • $ mkdir tutorial_workspace; cd tutorial_workspace
    • $ virtualenv --no-site-packages venv
    • $ export PATH = / path / to / tutorial_workspace / venv / bin: $ PATH
    • $ which easy_install
    should output something like:

    • $ easy_install pyramid WebTest nose
    Code examples

    Each step in this guide requires the reader to enter code examples and thus create a working application. The directories in these steps are not Python packages, but be that as it may, the simple directory is full of Python modules. In addition, they are fully working, in separate examples, systematically grow into an entire application.

    Sample files are available for those who do not want to enter the code as part of the learning process. (Note: there are none on that page )

    Creating Simple UX for Pyramid

    In this series of steps, we will build the essence of user experience (UX), with substitutes for logic and data.

    • The simplest possible demonstration of Pyramid
    • Using unit tests and WebTest to speed up development
    • Patterning with Chameleon and ZPT
    • The use of macros and “schemes” (layouts), for the productivity of templates
    • Static Resources
    • AJAX via JSON renderer
    Work flow

    Many projects have a consistent workflow that starts with a client who usually wants to see something in order to understand and approve. Usually the “UI person” in the team works at this stage, getting a working prototype in place, and then the logic is considered full.

    This tutorial simulates such a workflow. In this first part, we will show how a person, without a deep knowledge of Pyramid architecture, can create working prototypes of various kinds in Projector.

    Step 01: Hello World in Pyramid

    What is the easiest way to start in Pyramid? Separate-file module. Without packages, imports, and other such.

    • Getting Pyramid pixels on screen is as simple as possible.
    • Use this as a well-understood base to further complicate
    Technical requirements
    • Create a module with a view so that it acts as an HTTP server
    • Visit URL in your browser

    Microframes are the universal fascination of these days. They give a low load at runtime. And also they do not load the brain: they do so little that you have to think only about the task.

    Pyramid is special because it can act as a separate microframework file. You have a simple Python file that can be executed directly through Python. But Pyramid also scales to huge applications.


    Make sure you do everything as stated here .
    And let's move on: Copy the text below into the newly created file step01 /
    $ mkdir creatingux; cd creatingux
    $ mkdir step01; cd step01

    from  wsgiref.simple_server  import  make_server

    from  pyramid.config  import  Configurator
    from  pyramid.response  import  Response

    # This acts as the view function
    def  hello_world (request):
        return  Response ('hello!')

    def  main ():
        # Grab the config, add a view, and make a WSGI app
        config = Configurator ()
        config.add_view (hello_world)
        app = config.make_wsgi_app ()
        return  app

    if  __name__ == '__main__':
        # When run from command line, launch a WSGI server and app
        app = main ()
        server = make_server ('', 8080, app)
        server.serve_forever ()
    $ python
    We open the browser, look, rejoice.

    Additional questions
    • What happens if you return the string of HTML? Sequence of integers?
    • Put something wrong, such as print xyz, in the view function. Kill your python application and restart, then refresh your browser. What is the exception in the console?
    • Does Pyramid support automatic updating of Python code?

    This simple module does very little for a few lines of code, so creating a web application is similar in spirit to microframes. A view function has been added to the configuration. When called, the view returns a response.


    Prerequisites for megaframes, microframes, and Pyramid are based on this.

    Part 3:

    Also popular now: