Thursday, March 5, 2015

Using Django Rest Framework with Model Translations

This post first appeared here

If you are a Django developer, you have probably heard of the great Django Rest Framework. It is simply one of the best, most powerful frameworks to build RESTFul Web APIs.

Recently, in one of our company projects we decided to build a Rest API. But as an extra requirement, it had to support model translations in order to provide multilingual content in our database. 
In previous projects we used our own in-house solution. Although its core implementation was basically similar to most model translation API's, it lacked the “API” component, in other words, a set of reusable methods to ease the development pain especially when switching across different projects.
That's when we met django-hvad a very powerful Model Translation API, with an awesome community and a very promising future.
In this post, we are going to understand how we can make Django Rest Framework (DRF) work alongside a Model Translation API such as django-hvad. We assume that you are familiar with the basics of DRF and django-hvad.
Please note that the versions that we are going to be talking about are djangorestframework==2.4.3 and django-hvad==1.0.0 and you can easily install both of them through PIP.
Note also that future versions of django-hvad will have official DRF support as mentioned here, but at the time of the writing of this Post this was still work in progress. Basically in older versions we will need some of the “glue” provided here to make these two work nicely.
After installing DRF and django-hvad, we should create our own “custom” model serializers that will be used as a base to all of our Translatable Models. From there, you just inherit your serializers from TranslatableModelSerializer or HyperlinkedTranslatableModelSerializer
When posting, you should simply add language_code as a normal field as part of your JSON / XML / etc.
After this, things become really straight forward. For example:

The company has been quite impressed with the advantages that django-hvad has brought to the table. 
We are definitely going to use them in future projects that require model translations and a Django Rest Framework API.

Sunday, September 7, 2014

Django + Amazon S3

Let me start by saying that there are a lot of good tutorials on the internet, and my motivation for writing this one is simply because its a "different" way for setting up Django with Amazon S3 storage.

As i said i am taking a different approach and although i am not certain if it is the best approach or not it does seem to work for me. If you find that this is not right please let me know in the comments and ill fix it.


So the main idea here is to simply create a S3 Bucket that will hold both the static files and the media files, where you can set you static files to be public and your media to be private.

Amazon S3 Steps:



If you do not to this you might end up having JavaScript errors like for example:

XMLHttpRequest cannot load http://myApiUrl/login. No 'Access-Control-Allow-Origin' header is present on the requested resource. Origin 'null' is therefore not allowed access

You can use the s3 amazon console and right click on top of the static folder and choose the option `make public`

After crating this folder do not attempt to make it public otherwise it will beat the purpose of this tutorial

"It seems that this is a common issue when uploading files to a new bucket.
Something to do with the DNS propagation means it takes a little while before your bucket can successfully accept files. More info here.
After waiting a few hours running the same command completes successfully."

This means that if you attempt to do a `python collectstatic` and get a broken pipe

it might be just because the DNS propagation is not finished.

Django Configurations:

Install django-storages and boto, read django-storages documentation and then you can just replace this settings.

You may read in other places that you need to set S3 bucket policies but i found that i really did not need to do that, by setting specifically the folders i want to be public.

Sunday, May 19, 2013

Python client Post to REST API using Basic Authentication

This is a simple post request to a REST API using python with basic authentication.

If you want to do a PUT, just uncomment the commented line and replace with the proper URL. Every other CRUD actions will follow the same approach.

Thursday, May 16, 2013

Using celery periodic tasks with Django

Although there are some documents and tutorials regarding this subject, i belive they are not well "explained" or are just a little confusing. So i decided to do my own tutorial.

its pretty simple actually, basically you just have to edit your and add this lines:

Monday, November 5, 2012

Quick guide to using django South migrations

Using django django South migrations at a basic level is fairly easy (for wasn't really had to bang my head for a while until i decided to write this guide).

First make sure you install south and add to your apps in

"South is an intelligent schema and data migrations for Django projects." 

So after you have created your app and added some fields, you decided to add a new field.

First you have to make sure that your app is already converted to south, if not just run:

./ convert_to_south app
Then everytime you make a change in your models just:

./ schemamigration app --auto
./ migrate app

To undo the migration or change a field just

python migrate profiles 0025

 - Soft matched migration 0025 to 0025_auto__add_field_locumprofile_one_line_description.
Running migrations for profiles:
 - Migrating backwards to just after 0025_auto__add_field_locumprofile_one_line_description.
 < profiles:0026_auto__add_field_locumprofile_plc_accepted_terms

then delete the migration file 0026

change the model

Thats it,  simple!!

Tuesday, May 15, 2012

Install Pip + Heroku + Foreman in Ubuntu 12.04

Heroku has released their own toolkit, so this steps may no longer be required.

Installing rails

You need to have ruby installed on your system
To install ruby, type in:

sudo apt-get install ruby

You can install rails either through gem or apt-get. I installed it using apt-get. You can do that by typing

sudo apt-get install rails

Installing heroku:

For heroku you need to have gem installed, to install gem, using apt-get type:

sudo apt-get install rubygems1.8

Also, before installing heroku you need to install rubydev as directly installing heroku gave me problems. To install rubydev type:

sudo apt-get install ruby1.8-dev

To add the .gem directory to your path type in:

gedit ~/.bashrc

At the end of the file type in:

sudo apt-get install python-pip
sudo apt-get install libpq-dev python-dev

export PATH
(Replace _username_ with your username)

Now type in

source ~/.bashrc

This will add gem to your path. Now install heroku

now install heroku by typing:

sudo gem install heroku

And you are done! Heroku is installed. You may want to install additional tools needed by heroku, documented as following.

sudo gem install foreman

Install virtualenv
sudo apt-get install python-virtualenv

You can also install django in env in order to deploy django to Heroku see this tutorial for further instructions
pip install Django psycopg2

Deploying Django Apps to Heroku (with existing git repository)


So basically i decided to write this tutorial based on this blog and the official tutorial.

The main difference (apart from putting the best of the 2 together) is that this tutorial covers django deployment to heroku assuming that you already have a GIT repository with your remote references (bitbucket , github , etc).

By doing this tutorial the heroku remote reference will be added automatically to your .git , so you will have 2 remote references and you can choose where you want to push to. You can  then git push origin master or git push heroku master.

The above links explain in detail the meaning of every actions, i am merely stating the commands i used in my case (that hopefully will be yours) to deploy my app.

Prerequisites :

- Heroku account
- Heroku command line client
- Python 2.7, Django 1.4, virtualenv, pip , git
- Must use pip to manage dependencies with a requirements.txt file

I am using Ubuntu 12.04 LTS. I have all the dependencies asked by installing them through this tutorial . Make sure you have Django installed in your virtualenv using pip install Django psycopg2

This example uses a repository for one of the projects i was working on, change it according to your needs.


1 . git clone
2 . cd human-computer-interaction/
3 . virtualenv venv --distribute  #you need to create because its not on .git
4 . source venv/bin/activate
5 . pip freeze > requirements.txt   #add the rest of the dependencies by hand like for example Django==1.4 , psycopg2==2.4.5 if it doesn't create automatically

#install dependencies in case you need them
  pip install -r requirements.txt
#add the remote references only if necessary (for example cloning in another computer) using
   git remote rm heroku
   git remote add heroku
#Exclude unnecessary env files from git by creating a .gitignore file and adding env and *.pyc on it

6 . git add .
7 . git commit -m "my django app"    #commit to git
8 . heroku create --stack cedar
9 . git push heroku master

#if you get errors check the log for missing dependencies, etc. then add the dependencies to requirements.txt

10 . heroku run python fastparqsite/ syncdb

#everything should be up and running now

Useful tips:

1 . heroku pg:reset SHARED_DATABASE #delete remote database
2 . chmod 755 fastparqsite/ (and commit it) #if you get a permission denied error this might be useful
3 . pip install -r requirements.txt #install dependencies on local machines after cloning
4 . use guarnicon webserver instead of the default one in heroku (guarnicon is better)
5 . Make sure your has its relative paths properly set, see this example if not you might run into errors.