Django bootstrap theme is ready!

You can download a project template for this now: http://www.pythondiary.com/templates/bootstraptheme

It's finally ready for developer consumption, my Django bootstrap theme Django app. With this super simple app in your Django project, you can easily apply a site-wide Bootstrap theme in a matter of minutes. Here's an example base.html you would use in your project's templates directory:

{% extends 'bootstrap_theme/starter.html' %}

{% block title %}Bootstrap Django site{% endblock %}

{% block branding %}Django Project{% endblock %}

{% block content %}
Yes Folks, this is how easy it is to implement bootstrap in Django now.  Be sure to look at the other templates available to see what <b>blocks</b> you can override.
{% endblock %}

Be sure to add bootstrap_theme to your INSTALLED_APPS, and this will work like a charm. Here is a list of available base templates you can extend:

base.html

This is the main template which the ones below extend to create the Bootstrap experience.

starter.html

This is the exact starter template from the Bootstrap documentation, it's the most basic and easiest to extend.

fluid.html

Similar to starter, except it allows users to sign in and out, and has a left navigation bar.

marketing.html

The marketing template directly from the bootstrap examples page tailored to work with Django.

marketing_narrow.html

From the bootstrap example page, another version of a marketing page you can try out.

marketing_clean.html

Yet another marketing page example, also from the bootstrap examples page.

carousel.html

The bootstrap carousel example made for Django, the bonus is that the Carousel is driven from the database, so it's easy to add and edit the big Carousel banner.

Wait, there's more... There's a large amount of templatetags at your disposal as well in the bootstrap library which you can load into any template you need it in. Here's what's included:

buttonlink url icon

You can create bootstrap themed buttons with this tag.

emphasis filter

This filter will add special styling to the text, such as muted which is the default, or anything in the text- CSS components.

abbrev filter

This handy filter will create an abbreviation text.

yesnoicon filter

Depending if the value is True or False a different icon is displayed.

ratingicon filter

This super handy filter will create a specific amount of star icons depending on the value.

link filter

Pass in any model object which has a get_absolute_url and it will automatically make it click-able.

carousel group_name

This is used to display a database driven Carousel. The group_name parameter is which group in the database model to display for this instance.

navbar_gradient first_color last_color

This super handy tag will automatically generate the required CSS style needed for the navbar gradient.

modal title modal_id form_action

This block tag is used to generate a modal dialog box, the last 2 options are optional. The first is the title of the dialog box, the second is the unique div ID for the modal, and the last one is the URL which the form inside the modal will be posted to, if the user saves the changes.

icon slug

This is used to display bootstrap icons easily.

modal_button title modal_id icon

This is used to generate the required A tag to display a modal dialog box generated above. The first option is what to display on the button itself, the second is the div ID chosen, and the last one is an icon slug to place on the button. The last two options are optional and have reasonable defaults.

Don't leave yet, there's still one last thing... An include-able template which can display a Django form very elegantly in bootstrap! Finally you can make your Django generated forms look great and functional with very little effort. Here's an example contact form to get you started:

          <form action="{% url 'contact-form' %}" method="post">{% csrf_token %}
            <fieldset>
              <legend>Contact form</legend>
              {% include "bootstrap_form.html" %}
              <button type="submit" class="btn btn-primary">Send Message</button>
            </fieldset>
          </form>

Wow, that's a lot to take in, in the next release I will be adding a bunch of ready made templates for django-registration so that you can get a new Django website up and running in a matter of hours.

Looking for advertising proposals

As some of you may have noticed, the AdSense bar no longer exists on my blog, this is due to Google recently revoking my AdSense account, I am quite sure it is in regards to mentioning it on a page. Currently users who have an account are able to opt'd out of either being tracked by Analytics or have no ads served to them. I will be removing this feature soon, as I am planning on self-hosting ads from prospect publishers. If you have a Python or Django related project which you would like to adverse on this blog, please contact me. Having a way to fund this website will allow me to publish more quality articles and tutorials. When a new article is posted, this blog receives over 1,000 hits in that single day. These are 1,000 prospect users which use Python and maybe Django who will see your advertisement. These can also be users who are just learning Python, so books and courses are also welcome.

Currently the ad serving system has yet to be implemented, so at this time I am only asking prospect advertisers to provide me with a proposal on how the ads should be served to users and costs they might be willing to pay. For the record this blog has been online for well over a year now and receives many returning users due to the quality of the content which is provided. This website is also much more than a blog, as it has other features which bring users back for more.

Thank you for your time in reading this.

DVD Collection source code now available

For those who were wanting a copy of the DVD Collection software made in Python, I have now open sourced it and it is live on BitBucket!

DVD Collection software

Python Script to encode Django templates

Do you need to display raw Django template code in your Django <1.4 project? Look no further than this script! It's rather crude, but gets the job done. I haven't yet updated a few Django websites to Django 1.5, which has a new template tag to do this for you, so I created this script to use in legacy Django sites, and it works like a charm!

#!/usr/bin/python

import sys

try:
  filename = sys.argv[1]
except IndexError:
  print "This command needs exactly 1 parameter!"
  sys.exit()

data = open(filename, 'r').read()
data = data.replace('{%', '{! templatetag openblock !}').replace('%}', '{! templatetag closeblock !}')
data = data.replace('{{', '{% templatetag openvariable %}').replace('}}', '{% templatetag closevariable %}')

print data.replace('{!', '{%').replace('!}', '%}')

You should Pygments to highlight the syntax like I do on this blog of course. If you are using Django 1.5 or greater, you should use the verbatim template tag over this.

Building a set of indie community focused Django apps

Today I have just started work on an set of Django pluggable apps which can either be used independently or as a whole. The main focus is to provide Indie developers with an entire website framework which can be used to host a database of indie downloads, manage assets, support developer blogs and vlogs, and much more. I am building this as an open source project from the start, and it is hosted on BitBucket with the discussion hosted on Uarica.

The first prototype of the website is done for anyone that's curious on how it currently looks, it can be accessed here.

A birthday present for a friend made in Django

I have a friend whom is a huge, and I really mean huge movie buff. He has the largest movie collection that I know of, and one the largest TVs I have seen. He was previously managing his collection using another website someone built, which I think is personally not very well done and my friend deserves much better!

First I used the standard Python XML libraries to parse and extract all the movies he has on the old website, as I didn't want to re-enter all those movies, and I'm sure he wouldn't either. After it was all extracted and I was able to parse it easily through Python, I created the Django project and models for which the movie titles will live in. I created the first part of the website, including the importing of all his movies in just a mere 4.5 hours(according to my Subversion timestamp). I was truly amazed at what a full featured web application I could create in such little time, I could barely sleep last night as I wanted to continue work and add new features.

Now, the website is nearing completion and I thought I'd share it here with all my loyal readers. This web application has full IMDb integration, which still has a few bugs here and there that need to be ironed out. I am currently debating if I should open source this creation or not...

You can check this application at Cinema-Nick.com.

Will be taking another look at web2py

My last encounter with Web2py was with version 2.0, this was back in October of 2012, of which I have a review for that version. Reviewing their changelog, I can see that this framework has evolved a great amount in just a few short months. There were many features which I praised about the framework, but there were still some things holding me back from using it over Django for my next project. So, with that, I am planning on diving back into web2py, and should have a new review up with the latest version. I have a project, I am thinking I may convert over to web2py and see how that goes. If development becomes quicker, then I will consider web2py for future projects as well.

If you haven't already, I would recommend taking a look at web2py and see what it can offer your project. Both Django and web2py are similar, but at the same time they are very different. They both took the Ruby on Rails idea in their own direction. One thing to note, is that apps in web2py are not like apps in Django. This also makes working with web2py a little difficult at times, as it's not easy for apps to talk to each other, not as easy as it is in Django that is. However, in web2py, it's not an apps purpose to extend the frameworks functionality, it is the job of a plugin. That being said, web2py has grown a large amount since I last used it, so all my hardships I experienced last time around might be resolved.

Django 1.5 review is up

For those interested in Django to see if it's right for your next project, or if you are upgrading from an earlier version, this review is for you.

Source code released for my Django PIM suite

Not sure how many of you were following my previous blog post about a bunch of Django apps I built for my own personal use. I have finally released the source code into BitBucket. Here's a short copy and paste recap of what you can find:

PCBank AKA myFinance

This is a personal budgeting system which I have created, it has matured a lot throughout the past few months. I originally created it in October of 2011, as using a spreadsheet to keep track of all my expenses grew tedious. It can also manage roommates, and split bills accordingly. This is my most used app out of all of the apps I created. It also has an RSS and JSON interface for third party applications to fetch data. I use the RSS for a Live Bookmark to easily access all my online banking websites from my browser toolbar. I use the JSON interface with a mobile app I created so that I can easily check my bank balances on the go without needing to actually sign into my online bank website on an insecure wireless network.

myProjects

This app was created in recent months to keep track of my many projects I do. It keeps track of individual projects, which I can jot down notes about each one. I can create goals under each project and assign a due date for them. This makes seeing all my workload and upcoming goals easy to browse, and add personal notes to.

myServers

Sort of an extension to myProjects above, as it keeps track of my various servers I run and operate. It sorts the servers by hosting provider. Then under each server, I can list the various applications which the server runs. Makes it easy to know where everything is located in my infrastructure.

Let me know what you think, all of these use Bootstrap for theming and some of them have APIs such as iCalendar, RSS, and JSON. PCBank was developed a very long ago, and some of the programming practices in there need some updating. I have included an svnlog.txt file in each app's directory so you can see just how each project grow since 2011. Yes, you heard me... 2011 was one of the early commits.

Using Pyjamas with Bootstrap

For a just for fun experiment, I attempted to re-create the standard Bootstrap, from Twitter theme using Pyjamas. It turned out pretty good too. Here is the source code to compile to JavaScript:

from pyjamas.ui.RootPanel import RootPanel
from pyjamas.ui.Button import Button
from pyjamas import DOM
from pyjamas.ui.Hyperlink import Hyperlink
from pyjamas.ui.SimplePanel import SimplePanel
from pyjamas.ui.ComplexPanel import ComplexPanel
from pyjamas.ui.FlexTable import FlexTable

class CustomPanel(ComplexPanel):
    def __init__(self, Element=None, **kwargs):
        if Element is None:
            Element = DOM.createDiv()
        self.setElement(Element)
        ComplexPanel.__init__(self, **kwargs)

class NavItems(CustomPanel):
    def __init__(self, nav_list=None, **kwargs):
        CustomPanel.__init__(self, Element=DOM.createElement("ul"))
        self.addStyleName("nav")
        self.items = []
        if nav_list == None:
            nav_list = {'Home': self.onClick, 'About': self.onClick, 'Contact': self.onClick}
        for item in nav_list:
            tmp = Hyperlink(item, Element=DOM.createElement("li"))
            tmp.addClickListener(nav_list[item])
            self.items.append(tmp)
        for item in self.items:
            self.add(item)
    def clearActive(self):
        for item in self.items:
            item.removeStyleName("active")
    def onClick(self, sender):
        self.clearActive()
        sender.addStyleName("active")
    def setActive(self, item_id):
        self.clearActive()
        self.items[item_id].addStyleName("active")

class NavBar(SimplePanel):
    def __init__(self, brand="Project name", nav=None, **kwargs):
        SimplePanel.__init__(self, **kwargs)
        self.addStyleName("navbar")
        self.addStyleName("navbar-inverse")
        self.addStyleName("navbar-fixed-top")
        self.setWidget(SimplePanel())
        self.getWidget().addStyleName("navbar-inner")
        self.container = CustomPanel()
        self.getWidget().setWidget(self.container)
        self.container.addStyleName("container")
        self.brand = Hyperlink(brand)
        self.brand.setElement(self.brand.anchorElem)
        self.brand.addStyleName("brand")
        self.container.add(self.brand)
        if nav == None:
            self.nav = NavItems()
        elif isinstance(nav, dict):
            self.nav = NavItems(nav)
        self.container.add(self.nav)
        self.nav.setActive(0)
    def setBrand(self, text):
        self.brand.setText(text)
    def setActive(self, item):
        self.nav.setActive(item)

navbar = NavBar()
state = 0

def alter_brand(sender):
    global state
    navbar.setActive(1)
    if state == 0:
        navbar.removeStyleName("navbar-inverse")
        state = 1
    else:
        navbar.addStyleName("navbar-inverse")
        state = 0

btn = Button("Hello Bootstrap!", alter_brand)
btn.setStyleName("btn btn-primary")

container = CustomPanel()
container.addStyleName("container")
container.add(btn)

RootPanel().add(navbar)
RootPanel().add(container)

tbl = FlexTable()
tbl.addStyleName("table")
tbl.setText(0, 0, "Hello World!")
tbl.setText(1,0,"Python rocks")
tbl.setText(0,1,"Coding in my Pyjamas is awesome!")
tbl.setText(1,1,"Bootstrap works with Pyjamas!")
tbl.addStyleName("table-striped")

container.add(tbl)

This code requires the latest version of Pyjamas, version 0.8.1a as of this writing. It won't work in 0.8, which I'm curious on why. You can see a full working demo here.

Full map of Django 1.5 generic class views

Something which I have had yet to see anywhere online is an Epydoc of Django's class-based views. Without further adieu, I provide the Python community with a generated epydoc of Django 1.5's class-based views in all it's glory!

Django 1.5 class views Epydoc

On this note, I plan on adding additional Epydocs as well of other packages which seem interesting but are under-documented. Hopefully this first Epydoc helps a bunch of you out there. Enjoy!

Idea Collaboration in spirit of GitHub

Do you sometimes have too many ideas and no time to implement them? Or would you like some collaborative input on these ideas? How about the ability for you to fork someone else's idea, or for someone to be-able to fork yours into a new direction? Most idea collaboration software is closed, where only a small team can collaborate and grow this idea into something. These existing software suites do not provide a means for public collaboration. Forums are the closest you have for idea collaboration, however forums do not allow you to easily take over an idea and send it off in a new direction. My latest idea was to create an idea collaboration software suite, something with features that will appeal to the open source community, with features like forking of ideas into new branches to enhance collaboration. It was also a priority to enable easily access to analytical data, where you can easily see what other similar projects are using to develop their ideas or see what projects are using the same tools as you are. Having this type of data at your disposal can help grow ideas quicker, as cross-references between ideas can be made. If your seeking help on a specific tool, you can easily and effortlessly see who else is using that tool and seek assistance from them or from their open source code directly.

This collaboration suite is not only for open source projects, but it can be used to collaborate on almost any type of idea you can dream of. If you have an interesting idea and want to see how much interest it may spark, plant the idea here and see if it grows. There is no commitment to maintain the idea you plant yourself, as someone more specialized in the field can easily fork it and grow it themselves. Each branch is tracked and can be easily cross-referenced to see the differences in one direction from another.

Uarica: Idea Collaboration will see many new features in the near future. Currently the main features are available for public consumption, such as Forking, general notes, idea asset management(used for analytical data), user profiles, ability to follow users, like ideas, and more. This website was build using Django in roughly 1 day, and is a testament on how rapidly something can be built using Django. It is currently deployed on RedHat OpenShift platform.

Future features will include full GitHub and BitBucket project integration for open source projects. You will be-able to access both the Issues and full source code repo. BitBucket's API is very nice, and supports both of these features. I haven't yet played with GitHub's API, and I am hoping I can do the same with it. User profiles currently include the ability to link to both websites via a standard link. Ideas can also link to both sites as well.

Another feature which should be added shortly is a Twitter feed for each user profile and idea, so all of your tweets will appear in your profile and in the ideas page. This will allow people to easily see what you have been up to. Feeds for GitHub and BitBucket are also planned.

Currently closed door ideas are not available, but are supported in the backend. These types of ideas will be made available to the general public once the site gains enough open door ideas, and once more features that compete with existing project management suites are added.

I also hope to look into APIs that can help accelerate ideas and implement them. There are a vast amount of resources on the Internet, and being able to use them easily in a single collaboration suite would be very nice to have. For example, the ability to turn an idea into a Kickstarter project with the click of a button comes to mind. Perhaps integration with existing project management software such as BaseCamp. Google Drive integration is already planned, as it provides a nice cloud whiteboard for easily collaboration and document storage.

The latest feature I just added(in about an hour of coding) is a petition add-on. This allows you to effortlessly create a petition attached to your idea. It supports a goal, a closing date, and user liking. Petitions are especially useful when attempting to get your idea out there, especially in front of political parties or large companies. There is an example petition on the Uarica idea, which closes at the end of this month with a goal of only 50 signatures. Petitions are available to anybody to view, but in order to place your signature on it, you will need to be signed-in. When forking an idea, petitions don't go with it for obvious reasons. I may add the ability to copy over completed petitions, if there is demand for it.

Let me know what you think of this idea in the comments below.

Why DRY programming is so important

With the introduction of DRY(Don't Repeat Yourself) programming model, lots of existing programming languages and their associated frameworks have been jumping on broad. Some frameworks such as Ruby on Rails and Django were built from the ground up to use DRY. Django includes so many DRY helpers that creating a full featured application takes no longer than a couple days of work. With the introduction to DRY programming, it's hard to believe why so many developers still choose to use tools which include so much manual labor... Why are these programmers reinventing the wheel every single day? One of the most common tasks done in web development and design is building a data-driven form. I recently downloaded a plugin from the wordpress website to see just exactly how far this framework has progressed over the years in terms of developer friendliness and DRY principals. I was truly disappointed to see a simple Contact form require so much code. The code itself is a total of 90.6KB, a whopping 1,280 lines(with comments and blank lines). This code also contains the front-end layer for the admin interface in Wordpress along with how it's suppose to integrate with the website. In comparsion, here is the Django DRY version of a contact form(easily extendable to include new fields and includes Captcha as well):

# contact_form.py
from django import forms
from django.views.generic.edit import FormView
from django.core.mail import mail_admins
from django.contrib import messages
from django.template.loader import render_to_string
from captcha.fields import ReCaptchaField

class ContactForm(forms.Form):
    your_name = forms.CharField()
    your_email = forms.EmailField()
    message = forms.CharField(widget=forms.Textarea)
    captcha = ReCaptchaField()
    def send_email(self, ipaddr):
        body = render_to_string('contact.txt', {'name':self.cleaned_data['your_name'],
                                                'email':self.cleaned_data['your_email'],
                                                'ipaddr':ipaddr,
                                                'message':self.cleaned_data['message']})
        mail_admins('Website contact form', body)

class ContactView(FormView):
    template_name = 'contact_form.html'
    form_class = ContactForm
    success_url = '/'
    def form_valid(self, form):
        form.send_email(self.request.META['REMOTE_ADDR'])
        messages.success(self.request, "Your message has been sent!")
        return super(ContactView, self).form_valid(form)
    def form_invalid(self, form):
        messages.error(self.request, "There was an error submitting the form, please review and try again.")
        return super(ContactView, self).form_invalid(form)

That's really it, I added some extra functionality to it, and it's easy to add new fields. The best part is, when adding new fields, you don't even need to touch the HTML code, it's all inclusive. You can see this exact form live on this website. Here is the most basic template without all the bootstrap magic:

          <form action="{% url 'contact-form' %}" method="post">{% csrf_token %}
              <legend>Contact form</legend>
              {{form.as_p}}
              <button type="submit">Send Message</button>
          </form>

There are a few different form formatters you can use, table, p, and ul. You can also make your own and include that into any template with a form. Here is one for bootstrap:

{% for field in form %}
<div class="control-group{% if field.errors %} error{% endif %}">
  <label class="control-label" for="{{field.id_for_label}}">{{field.label}}</label>
  <div class="controls">
    {{field}}
    {% if field.errors %}<span class="help-inline">{% for err in field.errors %}{{err}}{% endfor %}</span>
    {% else %}{% if field.help_text %}<span class="help-inline">{{field.help_text}}</span>{% endif %}{% endif %}
  </div>
</div>
{% endfor %}

All the error messages are provided by their respective FormFields, if the email address entered isn't really an email address, then the user will automatically see an appropriate error message. I only needed to write the user facing HTML code once for the bootstrap look and feel. Then for each form on the website you see there, I merely include this bootstrap look and feel, the Django forms system takes care of the rest regardless of what fields the form has. If you create an account and use the website a bit, you see some dynamic forms controlled using jQuery, still using that same template above, just a different Django form field or widget. My consulting website's Quote form has a form that uses TinyMCE and a jQuery UI date dropdown. All of this was added to these websites in way under 1,000 lines of code. Django takes care of all the repetitive details for me. This is also why I don't charge an arm and a leg for a web development job, as the job with Django compared to some other frameworks out there is super easy! With the bootstrap-ajax jQuery plugin, you can effortlessly submit forms over AJAX. Their example code is made in Django by the way(This definitely shows the growing popularity of Django).

Now, I normally don't do comparisons on this website, but after peeking at a wordpress plugin and seeing how not DRY it was, I needed to show prospect Django developers what they will be in for, if they plan on moving to a DRY framework. I do hope to add some tutorials and other articles soon showing how to create full applications using Django with less code than competing frameworks out there. Once you go Django, you seriously won't go back. I never did, and now I am a very proud Django web developer who advocates not re-inventing the wheel. Other fun DRY features of Django besides forms and forms based on database tables, is:

Pagination

Pagination is widely used in web applications, and Django includes both a low-level Paginator class that can be used with almost any data types. This class is the basis for the pagination used in the generic views for paginating database tables.

Built-in role-based permission system

Controlling access to resources couldn't be easier than in Django. You can easily restrict users based on either what group they are in or what fine-grained permissions they have on a particular database table. The permissions themselves are assigned and managed easily through an automatically generated interface. The API to check for permissions is very easy to use and can be used in either the Python source code or the HTML templates.

Validators

With custom easy to create validators, you can extend your database table and forms to only accept specifically formatted data from the user. Existing validators exist for Email addresses, IP addresses, URLs, and number ranges. A custom validator can effortlessly be attached to a data model, such a database field or form.

Signals

Signals are used to run specific functions when a specific event in the application occurs. It can be used to uncache something which was recently modified for example. You can even build your own signals, which is normally used in 3rd party apps to allow developers an easy API to watch and react to specific application events.

Caching

With caching support and a set of pluggable backends, you can easily cache data in your application for a variety of purposes. Caching can occur at any level, you can cache every single page request, cache specific URLs, only cache anonymous requests, specific blocks in a template, or even Python objects at the lowest level. Mastering this component will speed up your application and prevent any unneeded database queries. If you cache page requests, you can even use a supporting web server to serve the cached item and bypass Django entirely for some requests, speeding up your application even more.

Since all of these components are shared with an entire Django project, each app, both yours and 3rd party ones are free to communicate with one another with little effort. You can easily create related database fields to a 3rd party app, such as a blog, forum, eShop, etc... All these apps will share the same user information, allowing your users to use a single identity throughout. Since all the data easily relatable, analytics couldn't be easier. You can more easily create a unified product, where users on your forum can easily link a post to a discussion about an item in the eShop. The forum post can contain most, if not all the metadata from the item being sold for easy reference. Users of the website can like an eShop item and this information can be displayed in the forum with little work required. The users can also have a unified profile, where it contains a list of their forum posts, their eShop likes, recent purchases, and reviews on products. Why should a user need to have 2 or more accounts on a single website? I see this a lot, and I absolutely hate it. This is why DRY is so important! It's not only beneficial for the developer, but it can also help the end user's experience as well.

Deployed Uarica on OpenShift

You may have heard of a cloud hosting provider called RedHat OpenShift. I just spend a few hours moving a Django app from my Rackspace Cloud server over there. It was a website I recently deployed, so no data needed to be migrated. First, I needed to move the source code into a GIT repository, which was very easy for the most part. I also needed to change the settings.py and create a setup.py file, easy enough. Once I ran git push, the site was online fairly quickly... Except for the static files. I spend a couple hours attempting to get static files to work with RedHat's OpenShift platform, with no success. I went through their documentation, the forums, and finally their IRC channel. There was no hope in sight. In the end, I used the Django-cumulus package to copy all the static files to my Rackspace CloudFiles account and pointed the STATIC_URL there and was done with it.

So after much frustration with static files, the site is now live and working under RedHat's service. You can see it live here: Uarica.com. I plan on putting out a tutorial for deploying a Django app using their service, my current tutorial doesn't show enough on how to get it working right, especially with static files, which is the most trickiest part of hosting a Django app it seems.

Rethinking my hosting options...

I have recently deployed a new web application using Django, into my Rackspace Cloud server. This server doesn't seem to have enough resources to host as many apps as I currently have deployed. This is leading the uWSGI instance to throttle down lesser used instances. Since this new app is new, and there is currently not much traffic going to it, each time it's not used for an hour, the instance goes idle. Then the next request after the idle takes about 1-2 minutes to spin up the instance. If I plan on advertising this app, I'd rather have an app that functional on each request. If too many apps are up and the server runs low on memory, then nginx returns a Bad Gateway error, which I saw a few times after deploying the app. So far, it seems PythonDiary is unaffected, as it has a large amount of hourly traffic to keep the instance from idling.

If I plan on upgrading my Rackspace Cloud server, it will cost a little more than I would currently like to spend in my budget for hosting at this time. This has lead me to rethink my hosting options...

So far I am really eyeballing PythonAnywhere, as they are very affordable, and Python centric. With the hosting plan offered by them, it allows up to 10 domain names, which is perfect. I don't quiet have that many just yet, but I am nearing that amount. I also looked at RedHat OpenShift, which is free at first. Currently, I do not think I want to spend the time and effort moving everything to a new platform, so I am thinking of just moving my latest asset to RedHat's offering and see where this new asset goes first. This will remove the pressure that my other apps have been experiencing under my current server. I am also thinking of looking into Google App Engine for my personal profile page, but the lack of a relational database still scares me. A large amount of Django's ORM features depend on a solid relational database.

What hosting provider do you currently prefer for hosting your Python web application?