Merge pull request #2364 from stevepiercy/feature/alchemy-scaffold-update

update installation and basiclayout

2 files changed, 179 insertions, 169 deletions

diff --git a/docs/tutorials/wiki2/basiclayout.rst b/docs/tutorials/wiki2/basiclayout.rst
index 1ae51eb93..1310e0969 100644
--- a/docs/tutorials/wiki2/basiclayout.rst
+++ b/docs/tutorials/wiki2/basiclayout.rst
@@ -16,15 +16,14 @@ package.  We use ``__init__.py`` both as a marker, indicating the directory in
 which it's contained is a package, and to contain application configuration
 code.
 
-Open ``tutorial/__init__.py``.  It should already contain the
-following:
+Open ``tutorial/__init__.py``.  It should already contain the following:
 
 .. literalinclude:: src/basiclayout/tutorial/__init__.py
   :linenos:
   :language: py
 
-Let's go over this piece-by-piece.  First, we need some imports to support
-later code:
+Let's go over this piece-by-piece. First we need some imports to support later
+code:
 
 .. literalinclude:: src/basiclayout/tutorial/__init__.py
   :end-before: main
@@ -52,10 +51,10 @@ Next in ``main``, construct a :term:`Configurator` object:
   :lineno-match:
   :language: py
 
-``settings`` is passed to the Configurator as a keyword argument with the
-dictionary values passed as the ``**settings`` argument.  This will be a
+``settings`` is passed to the ``Configurator`` as a keyword argument with the
+dictionary values passed as the ``**settings`` argument. This will be a
 dictionary of settings parsed from the ``.ini`` file, which contains
-deployment-related values such as ``pyramid.reload_templates``,
+deployment-related values, such as ``pyramid.reload_templates``,
 ``sqlalchemy.url``, and so on.
 
 Next include :term:`Jinja2` templating bindings so that we can use renderers
@@ -66,16 +65,16 @@ with the ``.jinja2`` extension within our project.
   :lineno-match:
   :language: py
 
-Next include the the package ``models`` using a dotted Python path. The
-exact setup of the models will be covered later.
+Next include the the package ``models`` using a dotted Python path. The exact
+setup of the models will be covered later.
 
 .. literalinclude:: src/basiclayout/tutorial/__init__.py
   :lines: 9
   :lineno-match:
   :language: py
 
-Next include the ``routes`` module using a dotted Python path. This module
-will be explained in the next section.
+Next include the ``routes`` module using a dotted Python path. This module will
+be explained in the next section.
 
 .. literalinclude:: src/basiclayout/tutorial/__init__.py
   :lines: 10
@@ -84,16 +83,16 @@ will be explained in the next section.
 
 .. note::
 
-   Pyramid's :meth:`pyramid.config.Configurator.include` method is the
-   primary mechanism for extending the configurator and breaking your code
-   into feature-focused modules.
+   Pyramid's :meth:`pyramid.config.Configurator.include` method is the primary
+   mechanism for extending the configurator and breaking your code into
+   feature-focused modules.
 
 ``main`` next calls the ``scan`` method of the configurator
 (:meth:`pyramid.config.Configurator.scan`), which will recursively scan our
-``tutorial`` package, looking for ``@view_config`` (and
-other special) decorators.  When it finds a ``@view_config`` decorator, a
-view configuration will be registered, which will allow one of our
-application URLs to be mapped to some code.
+``tutorial`` package, looking for ``@view_config`` and other special
+decorators. When it finds a ``@view_config`` decorator, a view configuration
+will be registered, allowing one of our application URLs to be mapped to some
+code.
 
 .. literalinclude:: src/basiclayout/tutorial/__init__.py
   :lines: 11
@@ -113,31 +112,31 @@ Finally ``main`` is finished configuring things, so it uses the
 Route declarations
 ------------------
 
-Open the ``tutorials/routes.py`` file. It should already contain the
-following:
+Open the ``tutorials/routes.py`` file. It should already contain the following:
 
 .. literalinclude:: src/basiclayout/tutorial/routes.py
   :linenos:
   :language: py
 
-First, on line 2, call :meth:`pyramid.config.Configurator.add_static_view`
-with two arguments: ``static`` (the name), and ``static`` (the path).
+On line 2, we call :meth:`pyramid.config.Configurator.add_static_view` with
+three arguments: ``static`` (the name), ``static`` (the path), and
+``cache_max_age`` (a keyword argument).
 
 This registers a static resource view which will match any URL that starts
 with the prefix ``/static`` (by virtue of the first argument to
-``add_static_view``).  This will serve up static resources for us from within
-the ``static`` directory of our ``tutorial`` package, in this case, via
+``add_static_view``). This will serve up static resources for us from within
+the ``static`` directory of our ``tutorial`` package, in this case via
 ``http://localhost:6543/static/`` and below (by virtue of the second argument
 to ``add_static_view``).  With this declaration, we're saying that any URL that
 starts with ``/static`` should go to the static view; any remainder of its
-path (e.g. the ``/foo`` in ``/static/foo``) will be used to compose a path to
+path (e.g., the ``/foo`` in ``/static/foo``) will be used to compose a path to
 a static file resource, such as a CSS file.
 
-Second, on line 3, the module registers a :term:`route configuration`
-via the :meth:`pyramid.config.Configurator.add_route` method that will be
-used when the URL is ``/``. Since this route has a ``pattern`` equaling
-``/``, it is the route that will be matched when the URL ``/`` is visited,
-e.g., ``http://localhost:6543/``.
+On line 3, the module registers a :term:`route configuration` via the
+:meth:`pyramid.config.Configurator.add_route` method that will be used when the
+URL is ``/``. Since this route has a ``pattern`` equaling ``/``, it is the
+route that will be matched when the URL ``/`` is visited, e.g.,
+``http://localhost:6543/``.
 
 
 View declarations via the ``views`` package
@@ -148,15 +147,15 @@ The main function of a web framework is mapping each URL pattern to code (a
 corresponding :term:`route`. Our application uses the
 :meth:`pyramid.view.view_config` decorator to perform this mapping.
 
-Open ``tutorial/views/default.py`` in the ``views`` package.  It
-should already contain the following:
+Open ``tutorial/views/default.py`` in the ``views`` package.  It should already
+contain the following:
 
 .. literalinclude:: src/basiclayout/tutorial/views/default.py
   :linenos:
   :language: py
 
 The important part here is that the ``@view_config`` decorator associates the
-function it decorates (``my_view``) with a :term:`view configuration`, 
+function it decorates (``my_view``) with a :term:`view configuration`,
 consisting of:
 
    * a ``route_name`` (``home``)
@@ -172,12 +171,11 @@ Note that ``my_view()`` accepts a single argument named ``request``.  This is
 the standard call signature for a Pyramid :term:`view callable`.
 
 Remember in our ``__init__.py`` when we executed the
-:meth:`pyramid.config.Configurator.scan` method ``config.scan()``?  The
-purpose of calling the scan method was to find and process this
-``@view_config`` decorator in order to create a view configuration within our
-application.  Without being processed by ``scan``, the decorator effectively
-does nothing.  ``@view_config`` is inert without being detected via a
-:term:`scan`.
+:meth:`pyramid.config.Configurator.scan` method ``config.scan()``? The purpose
+of calling the scan method was to find and process this ``@view_config``
+decorator in order to create a view configuration within our application.
+Without being processed by ``scan``, the decorator effectively does nothing.
+``@view_config`` is inert without being detected via a :term:`scan`.
 
 The sample ``my_view()`` created by the scaffold uses a ``try:`` and
 ``except:`` clause to detect if there is a problem accessing the project
@@ -189,12 +187,12 @@ to inform the user about possible actions to take to solve the problem.
 Content models with the ``models`` package
 ------------------------------------------
 
-In a SQLAlchemy-based application, a *model* object is an object composed by
+In an SQLAlchemy-based application, a *model* object is an object composed by
 querying the SQL database. The ``models`` package is where the ``alchemy``
 scaffold put the classes that implement our models.
 
-First, open ``tutorial/models/meta.py``, which should already contain
-the following:
+First, open ``tutorial/models/meta.py``, which should already contain the
+following:
 
 .. literalinclude:: src/basiclayout/tutorial/models/meta.py
   :linenos:
@@ -213,10 +211,10 @@ Next we create a ``metadata`` object from the class
 :class:`sqlalchemy.schema.MetaData`, using ``NAMING_CONVENTION`` as the value
 for the ``naming_convention`` argument.
 
-A ``MetaData`` object represents the table and other schema definitions for
-a single database. We also need to create a declarative ``Base`` object to use
-as a base class for our models. Our models will inherit from this ``Base``,
-which will attach the tables to the ``metadata`` we created, and define our
+A ``MetaData`` object represents the table and other schema definitions for a
+single database. We also need to create a declarative ``Base`` object to use as
+a base class for our models. Our models will inherit from this ``Base``, which
+will attach the tables to the ``metadata`` we created, and define our
 application's database schema.
 
 .. literalinclude:: src/basiclayout/tutorial/models/meta.py
@@ -225,17 +223,25 @@ application's database schema.
   :linenos:
   :language: py
 
-We've defined the ``models`` as a packge to make it straightforward to
-define models separately in different modules. To give a simple example of a
-model class, we define one named ``MyModel`` in a ``mymodel.py``:
+Next open ``tutorial/models/mymodel.py``, which should already contain the
+following:
+
+.. literalinclude:: src/basiclayout/tutorial/models/mymodel.py
+  :linenos:
+  :language: py
+
+Notice we've defined the ``models`` as a package to make it straightforward for
+defining models in separate modules. To give a simple example of a model class,
+we have defined one named ``MyModel`` in ``mymodel.py``:
 
 .. literalinclude:: src/basiclayout/tutorial/models/mymodel.py
   :pyobject: MyModel
+  :lineno-match:
   :linenos:
   :language: py
 
 Our example model does not require an ``__init__`` method because SQLAlchemy
-supplies for us a default constructor if one is not already present, which
+supplies for us a default constructor, if one is not already present, which
 accepts keyword arguments of the same name as that of the mapped attributes.
 
 .. note:: Example usage of MyModel:
@@ -259,14 +265,14 @@ Our ``models/__init__.py`` module defines the primary API we will use for
 configuring the database connections within our application, and it contains
 several functions we will cover below.
 
-As we mentioned above, the purpose of the ``models.meta.metadata`` object is
-to describe the schema of the database. This is done by defining models that
-inherit from the ``Base`` attached to that ``metadata`` object. In Python, code
-is only executed if it is imported, and so to attach the ``models`` table
-defined in ``mymodel.py`` to the ``metadata``, we must import it. If we skip
-this step, then later, when we run
+As we mentioned above, the purpose of the ``models.meta.metadata`` object is to
+describe the schema of the database. This is done by defining models that
+inherit from the ``Base`` object attached to that ``metadata`` object. In
+Python, code is only executed if it is imported, and so to attach the
+``models`` table defined in ``mymodel.py`` to the ``metadata``, we must import
+it. If we skip this step, then later, when we run
 :meth:`sqlalchemy.schema.MetaData.create_all`, the table will not be created
-because the ``metadata`` does not know about it!
+because the ``metadata`` object does not know about it!
 
 Another important reason to import all of the models is that, when defining
 relationships between models, they must all exist in order for SQLAlchemy to
@@ -313,9 +319,9 @@ Finally, we define an ``includeme`` function, which is a hook for use with
 :meth:`pyramid.config.Configurator.include` to activate code in a Pyramid
 application add-on. It is the code that is executed above when we ran
 ``config.include('.models')`` in our application's ``main`` function. This
-function will take the settings from the application, create an engine,
-and define a ``request.dbsession`` property, which we can use to do work
-on behalf of an incoming request to our application.
+function will take the settings from the application, create an engine, and
+define a ``request.dbsession`` property, which we can use to do work on behalf
+of an incoming request to our application.
 
 .. literalinclude:: src/basiclayout/tutorial/models/__init__.py
   :pyobject: includeme
diff --git a/docs/tutorials/wiki2/installation.rst b/docs/tutorials/wiki2/installation.rst
index eb6cf50e0..891305bf5 100644
--- a/docs/tutorials/wiki2/installation.rst
+++ b/docs/tutorials/wiki2/installation.rst
@@ -3,7 +3,7 @@ Installation
 ============
 
 Before you begin
-================
+----------------
 
 This tutorial assumes that you have already followed the steps in
 :ref:`installing_chapter`, except **do not create a virtualenv or install
@@ -13,6 +13,7 @@ Pyramid**.  Thereby you will satisfy the following requirements.
 * :term:`setuptools` or :term:`distribute` is installed
 * :term:`virtualenv` is installed
 
+
 Create directory to contain the project
 ---------------------------------------
 
@@ -32,6 +33,7 @@ On Windows
 
    c:\> mkdir pyramidtut
 
+
 Create and use a virtual Python environment
 -------------------------------------------
 
@@ -54,7 +56,7 @@ On Windows
 
    c:\> set VENV=c:\pyramidtut
 
-Versions of Python use different paths, so you will need to adjust the
+Each version of Python uses different paths, so you will need to adjust the
 path to the command for your Python version.
 
 Python 2.7:
@@ -87,22 +89,23 @@ On Windows
 
    c:\> %VENV%\Scripts\easy_install pyramid
 
+
 Install SQLite3 and its development packages
 --------------------------------------------
 
-If you used a package manager to install your Python or if you compiled
-your Python from source, then you must install SQLite3 and its
-development packages.  If you downloaded your Python as an installer
-from https://www.python.org, then you already have it installed and can skip
-this step.
+If you used a package manager to install your Python or if you compiled your
+Python from source, then you must install SQLite3 and its development packages.
+If you downloaded your Python as an installer from https://www.python.org, then
+you already have it installed and can skip this step.
 
-If you need to install the SQLite3 packages, then, for example, using
-the Debian system and ``apt-get``, the command would be the following:
+If you need to install the SQLite3 packages, then, for example, using the
+Debian system and ``apt-get``, the command would be the following:
 
 .. code-block:: bash
 
    $ sudo apt-get install libsqlite3-dev
 
+
 Change directory to your virtual Python environment
 ---------------------------------------------------
 
@@ -127,7 +130,7 @@ On Windows
 .. _sql_making_a_project:
 
 Making a project
-================
+----------------
 
 Your next step is to create a project.  For this tutorial we will use
 the :term:`scaffold` named ``alchemy`` which generates an application
@@ -146,30 +149,29 @@ files. For example, ``pcreate`` creates the ``initialize_tutorial_db`` in the
 The below instructions assume your current working directory is "pyramidtut".
 
 On UNIX
--------
+^^^^^^^
 
 .. code-block:: bash
 
    $ $VENV/bin/pcreate -s alchemy tutorial
 
 On Windows
-----------
+^^^^^^^^^^
 
 .. code-block:: ps1con
 
    c:\pyramidtut> %VENV%\Scripts\pcreate -s alchemy tutorial
 
-.. note:: If you are using Windows, the ``alchemy``
-   scaffold may not deal gracefully with installation into a
-   location that contains spaces in the path.  If you experience
-   startup problems, try putting both the virtualenv and the project
-   into directories that do not contain spaces in their paths.
+.. note:: If you are using Windows, the ``alchemy`` scaffold may not deal
+   gracefully with installation into a location that contains spaces in the
+   path. If you experience startup problems, try putting both the virtualenv
+   and the project into directories that do not contain spaces in their paths.
 
 
 .. _installing_project_in_dev_mode:
 
 Installing the project in development mode
-==========================================
+------------------------------------------
 
 In order to do development on the project easily, you must "register" the
 project as a development egg in your workspace using the ``setup.py develop``
@@ -178,7 +180,7 @@ you created in :ref:`sql_making_a_project`, and run the ``setup.py develop``
 command using the virtualenv Python interpreter.
 
 On UNIX
--------
+^^^^^^^
 
 .. code-block:: bash
 
@@ -186,36 +188,35 @@ On UNIX
    $ $VENV/bin/python setup.py develop
 
 On Windows
-----------
+^^^^^^^^^^
 
 .. code-block:: ps1con
 
    c:\pyramidtut> cd tutorial
    c:\pyramidtut\tutorial> %VENV%\Scripts\python setup.py develop
 
-The console will show ``setup.py`` checking for packages and installing
-missing packages. Success executing this command will show a line like
-the following::
+The console will show ``setup.py`` checking for packages and installing missing
+packages. Success executing this command will show a line like the following::
 
    Finished processing dependencies for tutorial==0.0
 
 .. _sql_running_tests:
 
 Run the tests
-=============
+-------------
 
-After you've installed the project in development mode, you may run
-the tests for the project.
+After you've installed the project in development mode, you may run the tests
+for the project.
 
 On UNIX
--------
+^^^^^^^
 
 .. code-block:: bash
 
    $ $VENV/bin/python setup.py test -q
 
 On Windows
-----------
+^^^^^^^^^^
 
 .. code-block:: ps1con
 
@@ -223,50 +224,49 @@ On Windows
 
 For a successful test run, you should see output that ends like this::
 
-  .
-  ----------------------------------------------------------------------
-  Ran 1 test in 0.094s
+   ..
+   ----------------------------------------------------------------------
+   Ran 2 tests in 0.053s
 
-  OK
+   OK
 
 Expose test coverage information
-================================
+--------------------------------
 
-You can run the ``nosetests`` command to see test coverage
-information.  This runs the tests in the same way that ``setup.py
-test`` does but provides additional "coverage" information, exposing
-which lines of your project are "covered" (or not covered) by the
-tests.
+You can run the ``nosetests`` command to see test coverage information. This
+runs the tests in the same way that ``setup.py test`` does, but provides
+additional "coverage" information, exposing which lines of your project are
+covered by the tests.
 
 To get this functionality working, we'll need to install the ``nose`` and
 ``coverage`` packages into our ``virtualenv``:
 
 On UNIX
--------
+^^^^^^^
 
 .. code-block:: bash
 
    $ $VENV/bin/easy_install nose coverage
 
 On Windows
-----------
+^^^^^^^^^^
 
 .. code-block:: ps1con
 
    c:\pyramidtut\tutorial> %VENV%\Scripts\easy_install nose coverage
 
-Once ``nose`` and ``coverage`` are installed, we can actually run the
-coverage tests.
+Once ``nose`` and ``coverage`` are installed, we can run the tests with
+coverage.
 
 On UNIX
--------
+^^^^^^^
 
 .. code-block:: bash
 
    $ $VENV/bin/nosetests --cover-package=tutorial --cover-erase --with-coverage
 
 On Windows
-----------
+^^^^^^^^^^
 
 .. code-block:: ps1con
 
@@ -275,34 +275,38 @@ On Windows
 
 If successful, you will see output something like this::
 
-    .
-    Name                  Stmts   Miss  Cover   Missing
-    ---------------------------------------------------
-    tutorial.py              13      9    31%   13-21
-    tutorial/models.py       12      0   100%   
-    tutorial/scripts.py       0      0   100%   
-    tutorial/views.py        11      0   100%   
-    ---------------------------------------------------
-    TOTAL                    36      9    75%   
-    ----------------------------------------------------------------------
-    Ran 2 tests in 0.643s
+   ..
+   Name                         Stmts   Miss  Cover   Missing
+   ----------------------------------------------------------
+   tutorial.py                      8      6    25%   7-12
+   tutorial/models.py              22      0   100%
+   tutorial/models/meta.py          5      0   100%
+   tutorial/models/mymodel.py       8      0   100%
+   tutorial/scripts.py              0      0   100%
+   tutorial/views.py                0      0   100%
+   tutorial/views/default.py       12      0   100%
+   ----------------------------------------------------------
+   TOTAL                           55      6    89%
+   ----------------------------------------------------------------------
+   Ran 2 tests in 0.579s
 
-    OK
+   OK
+
+Our package doesn't quite have 100% test coverage.
 
-Looks like our package doesn't quite have 100% test coverage.
 
 .. _initialize_db_wiki2:
 
 Initializing the database
-=========================
+-------------------------
 
-We need to use the ``initialize_tutorial_db`` :term:`console
-script` to initialize our database.
+We need to use the ``initialize_tutorial_db`` :term:`console script` to
+initialize our database.
 
 .. note::
 
-   The ``initialize_tutorial_db`` command is not performing a migration but
-   rather simply creating missing tables and adding some dummy data. If you
+   The ``initialize_tutorial_db`` command does not perform a migration, but
+   rather it simply creates missing tables and adds some dummy data. If you
    already have a database, you should delete it before running
    ``initialize_tutorial_db`` again.
 
@@ -310,14 +314,14 @@ Type the following command, making sure you are still in the ``tutorial``
 directory (the directory with a ``development.ini`` in it):
 
 On UNIX
--------
+^^^^^^^
 
 .. code-block:: bash
 
    $ $VENV/bin/initialize_tutorial_db development.ini
 
 On Windows
-----------
+^^^^^^^^^^
 
 .. code-block:: ps1con
 
@@ -325,51 +329,51 @@ On Windows
 
 The output to your console should be something like this::
 
-    2015-05-23 16:49:49,609 INFO  [sqlalchemy.engine.base.Engine:1192][MainThread] SELECT CAST('test plain returns' AS VARCHAR(60)) AS anon_1
-    2015-05-23 16:49:49,609 INFO  [sqlalchemy.engine.base.Engine:1193][MainThread] ()
-    2015-05-23 16:49:49,610 INFO  [sqlalchemy.engine.base.Engine:1192][MainThread] SELECT CAST('test unicode returns' AS VARCHAR(60)) AS anon_1
-    2015-05-23 16:49:49,610 INFO  [sqlalchemy.engine.base.Engine:1193][MainThread] ()
-    2015-05-23 16:49:49,610 INFO  [sqlalchemy.engine.base.Engine:1097][MainThread] PRAGMA table_info("models")
-    2015-05-23 16:49:49,610 INFO  [sqlalchemy.engine.base.Engine:1100][MainThread] ()
-    2015-05-23 16:49:49,612 INFO  [sqlalchemy.engine.base.Engine:1097][MainThread] 
-    CREATE TABLE models (
-            id INTEGER NOT NULL, 
-            name TEXT, 
-            value INTEGER, 
-            PRIMARY KEY (id)
-    )
-
-
-    2015-05-23 16:49:49,612 INFO  [sqlalchemy.engine.base.Engine:1100][MainThread] ()
-    2015-05-23 16:49:49,613 INFO  [sqlalchemy.engine.base.Engine:686][MainThread] COMMIT
-    2015-05-23 16:49:49,613 INFO  [sqlalchemy.engine.base.Engine:1097][MainThread] CREATE UNIQUE INDEX my_index ON models (name)
-    2015-05-23 16:49:49,613 INFO  [sqlalchemy.engine.base.Engine:1100][MainThread] ()
-    2015-05-23 16:49:49,614 INFO  [sqlalchemy.engine.base.Engine:686][MainThread] COMMIT
-    2015-05-23 16:49:49,616 INFO  [sqlalchemy.engine.base.Engine:646][MainThread] BEGIN (implicit)
-    2015-05-23 16:49:49,617 INFO  [sqlalchemy.engine.base.Engine:1097][MainThread] INSERT INTO models (name, value) VALUES (?, ?)
-    2015-05-23 16:49:49,617 INFO  [sqlalchemy.engine.base.Engine:1100][MainThread] ('one', 1)
-    2015-05-23 16:49:49,618 INFO  [sqlalchemy.engine.base.Engine:686][MainThread] COMMIT
-
-Success!  You should now have a ``tutorial.sqlite`` file in your current working
-directory.  This will be a SQLite database with a single table defined in it
+   2016-02-21 23:57:41,793 INFO  [sqlalchemy.engine.base.Engine:1192][MainThread] SELECT CAST('test plain returns' AS VARCHAR(60)) AS anon_1
+   2016-02-21 23:57:41,793 INFO  [sqlalchemy.engine.base.Engine:1193][MainThread] ()
+   2016-02-21 23:57:41,794 INFO  [sqlalchemy.engine.base.Engine:1192][MainThread] SELECT CAST('test unicode returns' AS VARCHAR(60)) AS anon_1
+   2016-02-21 23:57:41,794 INFO  [sqlalchemy.engine.base.Engine:1193][MainThread] ()
+   2016-02-21 23:57:41,796 INFO  [sqlalchemy.engine.base.Engine:1097][MainThread] PRAGMA table_info("models")
+   2016-02-21 23:57:41,796 INFO  [sqlalchemy.engine.base.Engine:1100][MainThread] ()
+   2016-02-21 23:57:41,798 INFO  [sqlalchemy.engine.base.Engine:1097][MainThread]
+   CREATE TABLE models (
+           id INTEGER NOT NULL,
+           name TEXT,
+           value INTEGER,
+           CONSTRAINT pk_models PRIMARY KEY (id)
+   )
+
+
+   2016-02-21 23:57:41,798 INFO  [sqlalchemy.engine.base.Engine:1100][MainThread] ()
+   2016-02-21 23:57:41,798 INFO  [sqlalchemy.engine.base.Engine:686][MainThread] COMMIT
+   2016-02-21 23:57:41,799 INFO  [sqlalchemy.engine.base.Engine:1097][MainThread] CREATE UNIQUE INDEX my_index ON models (name)
+   2016-02-21 23:57:41,799 INFO  [sqlalchemy.engine.base.Engine:1100][MainThread] ()
+   2016-02-21 23:57:41,799 INFO  [sqlalchemy.engine.base.Engine:686][MainThread] COMMIT
+   2016-02-21 23:57:41,801 INFO  [sqlalchemy.engine.base.Engine:646][MainThread] BEGIN (implicit)
+   2016-02-21 23:57:41,802 INFO  [sqlalchemy.engine.base.Engine:1097][MainThread] INSERT INTO models (name, value) VALUES (?, ?)
+   2016-02-21 23:57:41,802 INFO  [sqlalchemy.engine.base.Engine:1100][MainThread] ('one', 1)
+   2016-02-21 23:57:41,821 INFO  [sqlalchemy.engine.base.Engine:686][MainThread] COMMIT
+
+Success!  You should now have a ``tutorial.sqlite`` file in your current
+working directory. This is an SQLite database with a single table defined in it
 (``models``).
 
 .. _wiki2-start-the-application:
 
 Start the application
-=====================
+---------------------
 
 Start the application.
 
 On UNIX
--------
+^^^^^^^
 
 .. code-block:: bash
 
    $ $VENV/bin/pserve development.ini --reload
 
 On Windows
-----------
+^^^^^^^^^^
 
 .. code-block:: ps1con
 
@@ -382,14 +386,15 @@ On Windows
 
 If successful, you will see something like this on your console::
 
-  Starting subprocess with file monitor
-  Starting server in PID 8966.
-  Starting HTTP server on http://0.0.0.0:6543
+   Starting subprocess with file monitor
+   Starting server in PID 82349.
+   serving on http://127.0.0.1:6543
 
 This means the server is ready to accept requests.
 
+
 Visit the application in a browser
-==================================
+----------------------------------
 
 In a browser, visit http://localhost:6543/.  You will see the generated
 application's default page.
@@ -399,8 +404,9 @@ page.  You can read more about the purpose of the icon at
 :ref:`debug_toolbar`.  It allows you to get information about your
 application while you develop.
 
+
 Decisions the ``alchemy`` scaffold has made for you
-===================================================
+---------------------------------------------------
 
 Creating a project using the ``alchemy`` scaffold makes the following
 assumptions:
@@ -409,21 +415,19 @@ assumptions:
 
 - You are willing to use :term:`URL dispatch` to map URLs to code.
 
-- You want to use zope.sqlalchemy_, pyramid_tm_ and the transaction_ package
-  to scope sessions to requests.
+- You want to use zope.sqlalchemy_, pyramid_tm_ and the transaction_ package to
+  scope sessions to requests.
 
-- You want to use pyramid_jinja2_ to render your templates.
-  Different templating engines can be used but we had to choose one to
-  make the tutorial. See :ref:`available_template_system_bindings` for some
-  options.
+- You want to use pyramid_jinja2_ to render your templates. Different
+  templating engines can be used, but we had to choose one to make this
+  tutorial. See :ref:`available_template_system_bindings` for some options.
 
 .. note::
 
    :app:`Pyramid` supports any persistent storage mechanism (e.g., object
-   database or filesystem files). It also supports an additional
-   mechanism to map URLs to code (:term:`traversal`).  However, for the
-   purposes of this tutorial, we'll only be using URL dispatch and
-   SQLAlchemy.
+   database or filesystem files). It also supports an additional mechanism to
+   map URLs to code (:term:`traversal`). However, for the purposes of this
+   tutorial, we'll only be using URL dispatch and SQLAlchemy.
 
 .. _pyramid_jinja2:
    http://docs.pylonsproject.org/projects/pyramid-jinja2/en/latest/