Development Environment in Python

Overview

Some of the steps needed to setup a development environment includes:

Operating system 	- e.g Linux / Mac
Project structure  	- project structure
Virtualenv   		- isolated installation of the project
Pip     		- a tool for installing and managing Python packages
Git     		- source control
Webserver     		- where we can manage our applications
Fabric    		- automated deployment

Project Structure

Create an empty top-level directory for our new project.

helloflask/
    -static/
        -css
        -font
        -img
        -js
    -templates
    -routes.py

Then cd into the directory
cd helloflask

Virtualenv

Many developers uses virtualenv (virtual environment) on their computer, which
is useful when you want to run several applications on the same computer. 

Virtualenv will manage all dependencies and enables multiple side-by-side
installations of Python, one for each project.

It doesn't install separate copies of Python, but provides a way to keep
different project environments isolated.

If we want to run more than one (which is often the case) web application on
that host, then you should really install 'Virtualenv'. 

If you don't use virtualenv , you will have it all globally installed.

Installing Virtualenv

Download and Install Virtualenv into a virtual environment

# If you are using Linux/Mac:
sudo pip install virtualenv

Setup a new project

Navigate to the directory you want your project in:

$ virtualenv venv      		# this creates the folder venv
$ source venv/bin/activate    	# start working on your new project
(venv)$ pip install Flask    	# installs Flask

For more information on how to download install virtualenv, see this article.

Pip

PIP is a tool for installing and managing Python packages.

PIP comes with a command-line interface, which makes installing Python software
packages as easy as issuing one command

pip install some-package-name

Users can also easily implement the package's subsequent removal

pip uninstall some-package-name

Pip has a feature to manage full lists of packages and corresponding version
numbers through a "requirements" file.

This permits the efficient re-creation of an entire group of packages in a
separate environment (e.g. another computer) or virtual environment. 

This can be achieved with a properly formatted requirements.txt file

pip install -r requirements.txt

This makes dependencies easy, you can create a requirements file based on a set of
packages installed in your virtual environment.

pip freeze > requirements.txt

When deploying to a server it is important to register which requirements we need. 

The requirements file can be done automatically using the freeze command for pip. 

This command will generate a plain text file that contains the names of the
required Python packages and their versions, for example Flask==0.9

To do this we freeze the installed packages and store this setup in a
requirements.txt file

$ cat requirements.txt
Flask==0.9
Jinja2==2.6
Werkzeug==0.8.3

The requirements file can be used to rebuild a virtual environment or to deploy a
virtual environment into the machine.

Start coding

Now that we have a clean Flask environment to work in, we'll create our simple
application. 

The simplest Flask App looks something like this:

Put this code into the file and name it 'hello.py'

from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello():
    return 'Hello World!'

Github – Central Repository

Now it's time to create the repository on Github. The purpose of setting up a
Github project, is so that we can push files from our local computer to Github
and then pull the files from Github to our web server.

Create a new Github account and create a new project (helloflask)

Git – Local Computer

By using a versioning system, we can store all our files in a Github repository.

The first thing you need to do on your local computer is to install and setup git.

Install Git

To install git, simple run:

sudo apt-get install git

Setup Git

Put in your username and email into the .gitconfig file (~/.gitconfig)

git config --global user.name "pythonforbeginners"
git config --global user.email pythonforbeginners@example.com

Git Ignore

Since our current directory contains a lof of extra files, we'll want to
configure our repository to ignore these files with a .gitignore file:
venv
*.pyc

Next, we’ll create a new git repository and save our changes.

# Initialize Git in our project directory
git init

This creates a git repository in the current directory. 

Add all of our files to our initial commit

git add .

Check the status, this will list all files

git status

With the files added to the Git index, we can now commit them to our repo:

$ git commit -m 'Initial commit'

Now we have created a local Git repository for our application (local) files. 

Setup Github as the origin

git remote add origin git@github.com:USERNAME/helloflask.git
git push -u origin master

Web Server – Host

Now its time to start up the web server and do some configuration. 

If you want to use Apache as a web server, you can install it like this:

sudo apt-get install apache2

Configure a virtual host (vhost) in /etc/apache2/sites-available/siteX

Install virtualenv just like you did on your local computer. 

Set up the environment for the website, here I use /var/www

Cd into that folder and clone the project that you setup on Github, by typing:

git clone git@github.com:USERNAME/helloflask.git

Initialize and activate your virtualenv

virtualenv helloflask
cd helloflask
source bin/activate

Install dependencies

pip install -r requirements.txt

Fabric

Fabric is used for deployment. You can of course always manually upload the code
and restart the web server to reflect the configuration changes.

Using fabric in a development environment, where you have multiple servers with
multiple people pushing the code multiple times per day, this can be incredible
very useful.

Fabric can configure the system, execute commands on local/remote server, deploy
your application, do rollbacks etc. 

It does that by using its command-line utility that will run a fabfile containing
instructions on how to deploy to a server.

A common practice when developing is to use Git to deploy and Fabric to automate
it.

Install Fabric

pip install fabric

Fabric expects a fabfile named fabfile.py which defines all of the actions we can
take. 

The fabfile.py should be in your project's root directory.

I like to use this script that asks the server to pull from the git repository
and restart apache. [source]

from fabric.api import *            # import fabrics API functions
env.hosts = ['user@example.com:22'] # add the remote server information 
def pushpull():
    local('git push')      		    # runs the command on the local environment
    run('cd /path/to/project/; git pull') # runs the command on the remote environment 

#Run it with:
$ fab pushpull

For more information on how to use fabric in a development environment, please
refer to this article.