Once done with fresh installation of Mac OS X Lion, immediate task was setting up my development environment which includes MySQL server, phpMyAdmin and Django.

Steps I followed to get Django development environment back are as below

1. Install Xcode via Mac OS X App Store ( Might be required when you compile and install from source)
2. Install MySQL Server
3. Install phpMyAdmin
4. By default jpeg, freetype, littlecms image library support is missing, you need to install at least jpeg support so ImageField in your django project supports jpeg formats.
1. Install JPEG libraries
1. Download JPEG library source curl -O http://www.ijg.org/files/jpegsrc.v8c.tar.gz
2. Extract tar -xvzf jpegsrc.v8c.tar.gz
3. Switch to jpeg directory cd jpeg-8c
4. Run ./confgure
5. Run make
6. Run sudo make install
2. Install Freetype libraries
1. Download Freetype library source curl -O http://ftp.igh.cnrs.fr/pub/nongnu/freetype/freetype-2.4.5.tar.gz
2. Extract tar -xvzf freetype-2.4.5.tar.gz
3. Switch to freetype directory cd freetype-2.4.5
4. Run ./configure
5. Run make
6. Run sudo make install
5. Install Django using sudo easy_install django
6. Install Python Image Library (PIL) using sudo easy_install PIL
7. Install mysql-python driver using sudo easy_install MySQL-python (Make sure you got mysql in your PATH, otherwise this will fail with mysql_config not found error)
   

That’s all you need to go ahead and start creating Django projects. However I prefer using virtualenv for all my Python projects. If you take this route, you can use pip install <package_name> to install necessary packages for example pip install django, pip install MySQL-python, pip install PIL to install Django, MySQL Python driver and Python Image Library.

Update 1 (25/07/2011): If you get error “django.core.exceptions.ImproperlyConfigured: Error loading MySQLdb module: dlopen(/Users/xxx/xxx/pyprojects/xxx/lib/python2.7/site-packages/_mysql.so, 2): Library not loaded: libmysqlclient.18.dylib
Referenced from: /Users/xxx/xxx/pyprojects/xxx/lib/python2.7/site-packages/_mysql.so
Reason: image not found”, when you validate your project or try to use MySQL-python,

Type export DYLD_LIBRARY_PATH=”$DYLD_LIBRARY_PATH:/usr/local/mysql/lib/” in your terminal and see if problem persists. You can add it to your .profile file to make this persistent so you don’t need to run it every time.

Mac OS X by default ships with Apache web server which we will use to install (configure) phpMyAdmin to manage MySQL server installed previously on Mac OS X 10.7 (aka Lion). At the end of this step-by-step tutorial, you should be able to access phpMyAdmin by opening http://localhost/phpMyAdmin in your preferred browser.

In this tutorial we will be using Terminal to move files around and edit/create files using command line.

Installing phpMyAdmin

1. Start Apache if it’s not already running (You can check by running command “ps -ef | grep httpd” in terminal)
1.  Open System Preferences and Click Sharing
   

   Start Apache Mac OS X

2. Check Web Sharing Checkbox which should start web server (Apache) on your Mac
3. Open http://localhost in browser and you should see default page (on mine it just says “It Works” in H1 Tag)
   

   Mac OS X Apache Homepage

2. By default, PHP module is not activated. Uncomment the line ”LoadModule php5_module libexec/apache2/libphp5.so” in file “/private/etc/apache2/httpd.conf” to enable PHP on Mac OS X Apache web server. Default PHP version is PHP 5.3 (PHP 5.3.6 to be precise)
3. Download phpMyAdmin (Latest version at the time of writing this is 3.4.3.1) from phpMyAdmin Site. Download page has quite a few options in terms of language and compresssion formats, so download the most relevant language pack and compression format you are comfortable with. (I downloaded phpMyAdmin-3.4.3.1-english.zip, please note your version may be different )
4. Open Terminal and Extract downloaded package to /usr/local/ by running command  “sudo unzip phpMyAdmin-3.4.3.1-english.zip -d /usr/local/“
5. Rename phpMyAdmin-3.4.3.1-english to phpMyAdmin by using command “sudo mv /usr/local/phpMyAdmin-3.4.3.1-english /usr/local/phpMyAdmin” in Terminal
6. Switch to phpMyAdmin directory using “cd /usr/local/phpMyAdmin” to create phpMyAdmin config file
7. By default config.inc.php file does not exist but phpMyAdmin ships with sample config which we can use. Copy config.sample.inc.php to config.inc.php using “sudo cp config.sample.inc.php config.inc.php“
8. Edit config.inc.php using your favorite editor (I prefer vi) and change $cfg['Servers'][$i]['host'] = ‘localhost’; to $cfg['Servers'][$i]['host'] = ’127.0.0.1′;
   *Well it sounds stupid because localhost and 127.0.0.1 are same in networking world but phpMyAdmin won’t let you (At least me) log in without this change and keeps throwing error “#2002 Cannot log in to the MySQL server”
   **If your MySQL is running on a different host/port, you can change them in this file
   ***You can also use setup wizard offered by phpMyAdmin to configure phpMyAdmin further
   ****You can also add random blowfish secret to config.inc.php to encrypt your session cookies.
9. Configure Apache to enable /phpMyAdmin
1. Create phpMyAdmin apache config file with below text in bold in /etc/apach2/other/ directory using your favorite editor  “sudo vi /etc/apache2/other/phpMyAdmin.conf“Alias /phpMyAdmin /usr/local/phpMyAdmin
   <Directory /usr/local/phpMyAdmin>
       Options Indexes
       Order allow,deny
       Allow from all
   </Directory>
10. Restart Apache by typing command sudo apachectl restart in terminal
11. Open http://localhost/phpMyAdmin in your browser and you should see phpMyAdmin Login Page
    

    Mac OS X phpMyAdmin Login Screen

*Note Default phpMyAdmin does not allow you to login with empty passwords, you can change this behaviour but it is highly recommended to have password for mysql server accounts.

At the time of writing this post, MySQL Server on MySQL site doesn’t have installer package for OS X 10.7 (aka Lion) but 10.6 Package works just fine for 10.7 as well. This may change soon and we may see package for OS X 10.7 as well or may be rename current package to 10.6 & above.

Installing MySQL community server:

1. Download the latest  64-Bit DMG Archive (Apple Disk Image) from MySQL Site (http://dev.mysql.com/downloads/mysql/). Current latest version is 5.5.14 which I’ll be using to install on my machine.
2. Mount the Disk Image (I mean open/double-click the DMG file) and install MySQL server by double-clicking the PKG file (in my case mysql-5.5.14-osx10.6-x86_64.pkg) and follow onscreen instructions. ( It will ask for Master password, as it installs MySQL server in /usr/local )
3. Add /usr/local/mysql/bin to your path by editing .profile file. (Optionally you can create alias to mysql and mysqladmin as mentioned in README File)
4. You can start MySQL server by running “/usr/local/mysql/bin/mysqld_safe &” from terminal but Disk image you downloaded also consists of Startup Package & Preferences Pane which allows you to start/stop MySQL server from System Preferences and even Automatically Start MySQL Server at Startup.

*Please note /usr/local/mysql is only symlink to /usr/local/mysql-5.5.14-osx10.6-x86_64 which means when you upgrade to new version symlink will be changed to point to new version but won’t be deleting the older version. However you need to copy your data directory to new location to make sure your existing databases are intact post upgrade.

Installing MySQL Startup Scripts & Preferences Pane (OPTIONAL)

1. Double Click MySQLStartupItem.pkg and Follow on screen instructions (You will be asked for Master Password)
2. Double Click MySQL.prefPane which will add MySQL to OS X System Preferences and it should like something like below
   

   MySQL Mac OS X Lion Preferences

3. Check Automatically Start MySQL Server on Startup to start MySQL server at boot time.

In next section we will discuss installing phpMyAdmin which will provide us web interface to perform basic MySQL administration tasks on Mac OS X Lion.

From March to July, I’ve read/worked a bit on Python and Django and even deployed couple of Django projects in production  before I ordered the book but I was under the impression I’m voilating Python’s philosophy of “only one way to do it” ,mostly because I rarely used model managers which I found in almost all Django reusable apps I’ve used and that’s one  major thing which I want to learn from this book.

Recieved Practical Django Projects book after couple of days and with all excitement I jumped straightaway into the book and after reading about 50-60 pages I was like this book is for real beginners (myself a beginner that time)  beacuse I learned nothing new from what I knew already but  I did not give up and continued to read. Done reading entire Blog application and I was partially happy that I learned a bit about Django Signals and how to  use them to handle django comments moderation (which is on feature list for one of my projects ) but apart from Django Signals, most of them can be found in Django e-book by JKM and AH and the only difference is they are demonstrated as a part of project here.

Then jumped on to building social code sharing site example (like djangosnippets) and learned few things like modelsManager and using Custom SQL, it’s not that you can’t find them in docs or django e-book but here they are demonstrated using a realtime example.

Rest of the book focus on Writing Reusable apps, coding style, documentating the apps, coding for flexibility, packaging django apps which I think are favorite topics of author. You can find presentations on youtube on similar topics and one of them is here from Djangocon

Overall, Practical Django Projects is a good book but not a great and must have book. Practical Django Projects is a  book for beginner but not the one you can start with, you still have to read Djangobook and documentation before you get on to this book. As it’s titled most of the Django features are demonstrated here using practical projects and James did an excellent job covering most of the features/functionality (like Models/Views/Forms/Admin/Comments/Signals/Sitemaps/Syndication/Templates/Urls). The real problem is once you read Djangobook and gone through documentation, most of the code in this book looks obvious and if you are comfortable with Django documentation which is excellent, then in my opinion you can ignore this book.

Note: This book was released before Django 1.0, so most of the code in the examples will not work (mostly contrib.admin refactored, contrib.comments refactored) and if you are looking to buy now, I would say wait for next version/update.

PS: I bought the companion Practical Django Projects ebook today (for 10USD) and went through it again just before posting this book.

]]> http://www.djangoapp.com/blog/2008/12/24/practical-django-projects-book-review/feed/ 0 http://www.djangoapp.com/blog/2008/12/17/wysiwyg-editor-for-django/ http://www.djangoapp.com/blog/2008/12/17/wysiwyg-editor-for-django/#comments Wed, 17 Dec 2008 15:29:28 +0000 Srik http://www.djangoapp.com/?p=59 Continue reading →]]> Lately I’ve been working on CMS like application for a news portal and one of the major features include integrating WYSIWYG editor to enable journalists post news online with ease. With almost zero expertise in Javascript, I thought this will be a difficult activity but it turned out to be very easy and took less than an hour to integrate once we shortlisted on which editor we will be using.

We have looked at TinyMCE, FCKeditor and WYMeditor and finally decided to go with WYMeditor for many reasons which can be debated and importantly it fulfills all the features we need at this point of time. Integrating WYMeditor in django is easy, for now we have integrated this in admin ( django.contrib.admin )  and we are planning to roll this out for users too in future. Below steps had worked for me and I think it should work for everyone.

• Download jQeury and copy it to somewhere on to MEDIA_ROOT so it can be accessed from browser. for eg., media.example.com/templates/js/jquery.js
• Download WYMeditor and extract it to somewhere on MEDIA_ROOT, so all files under wymeditor directory can be accessed. for eg., media.example.com/templates/js/wymeditor/jquery.wymeditor.pack.js
• Create another javascript file to initialize editor on fields you need as shown below.

  // File Name: editor.js
   
  $(document).ready(function() {
      $("#id_content").wymeditor({ // assuming content is field name with TextField.
          updateSelector: "input:submit", //without this line and next line, you will be able to see editor but content will not be passed through POST.
          updateEvent:    "click"
      });
  });

• Add all jquery.js, jquery.wymeditor.js and editor.js javascript files to ModelAdmin for models which you need Editor using admin Media class as shown below

  import settings
  media = settings.MEDIA_URL
  class ArticleAdmin(admin.ModelAdmin):
      #Your JS file paths may vary
      class Media:
          js = (media+'templates/js/jquery.js', media+'templates/js/wymeditor/jquery.wymeditor.js', media+'templates/js/editor.js')

That’s it, reload the admin page and you should see a WYMeditor.

It worked straightaway on localhost where I’m using django.views.static.serve to serve static files but when I moved this to production I had few problems with editor loading from media subdomain throwing error in firebug ( WYMeditor: error while parsing language file and to avoid the same I manually loaded lang file as well. )

Well I think auto_now and auto_now_add are often used in development but for some reason Django core developers want to get rid of that and most likely auto_now and auto_now_add will be removed in version 2.0 (As mentioned during Django Technical Design, Djangocon 2008, video embedded below).  May be they want to reduce core size by removing the code which can be implemented easily or improve the same with new TimeStampField (Hinted by James Bennett during the same discussion, though I agree with Russel Keith having it doesn’t hurt)  but still no clarity if auto_now and auto_now_add will be part of Django 2.0 or not and I think one should avoid using them.

It’s easy to achieve the same by overriding save method as shown below using example model. ( Most of the code is self explanatory and focus should be on created and updated fields)

Before (with auto_now and auto_now_add) :

1
2
3
4
5
6
7
8
9

class Article(models.Model):
    title = models.CharField(max_length=100)
    slug = models.SlugField(blank=True)
    content = models.TextField()
    created = models.DateTimeField(auto_now_add=True)
    updated = models.DateTimeField(auto_now=True)
 
    def __unicode__(self):
        return self.title

After( Same functionality without auto_now and auto_now_add ):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

from datetime import datetime
class Article(models.Model):
    title = models.CharField(max_length=100)
    slug = models.SlugField(blank=True)
    content = models.TextField()
    created = models.DateTimeField(editable=False)
    updated = models.DateTimeField(editable=False)
 
    def __unicode__(self):
        return self.title
 
    def save(self, **kwargs):
        if not self.id:
            self.created = datetime.now() # Edit created timestamp only if it's new entry
        self.updated = datetime.now()
        super(Article,self).save()

You can make created and updated fields editable in admin by removing editable=False from DateTimeField and adding a bit of code in save method to modify created and update timestamps as per your wish instead of current timings. (Hint: for new entry check created and updated are None and for existing entry(while editing), check the updated and created values with existing values)

Below is the Djangocon 2008 presentation where auto_now and auto_now_add are discussed (34:00)

[There is a video that cannot be displayed in this feed. Visit the blog entry to see the video.]

Installing Django/Python/Python modules is same in all versions of windows and hence below steps are valid for Windows XP and Windows Vista. Those who are using Windows Vista, just make sure you run all installations as Administrator ( Right click setup file and run as administrator )

Let’s begin by installing Python (If you already have a working Python installation, skip this section)

Python Installation:

1. Download latest Python binary for Windows from http://python.org/download/. Make sure you are using right binary file for your processor and always get the latest release
2. Install Python by double clicking the setup file you have downloaded in above setup and follow onscreen instructions.(Use defaults if possible or make sure you don’t have spaces and special characters in your installation path)
3. Edit your path settings and add Python to same. To edit path settings, right click My Computer and select properties which will open other window. Click advanced tab and then Environment variables and select PATH and click edit and add python installation path and it’s scripts (In my case C:\Python26\Tools\Scripts;C:\Python26; ) and click ok to save and comeout of that properties window by clicking ok.
4. Launch command prompt and then type python, you should see message like below. (If you get command not found, then most likely path is wrongly setup)

Python 2.6 (r26:66721, Oct 2 2008, 11:35:03) [MSC v.1500 32 bit (Intel)] on win32
Type “help”, “copyright”, “credits” or “license” for more information.
>>>exit( )
*NOTE: Version numbers and processor models may be different

If you face any problem , make sure you have set PATH variable correctly.

Once we have Python working fine, we will move to next step to setup Django.

Django Installation:

1. Download Django from Django Site . There are two versions available,  Latest official version (Recommened for production) which can be downloaded directly or development version through svn. You need SVN client ( Tortise SVN, Free SVN client for Windows) .
2. If you are going with official version, extract the package and copy only the django(leave the docs, tests and examples etc.,) directory to site-packages ( site-packages will be under your Python installation path ( <python-installation path>\Lib\site-packages\ )
3. Add django to Environmental variables ( Like you did for Python installation step 3), just edit path settings and add <python-installation path>\Lib\site-packages\django\bin;
4. That’s it we are almost done installing django, Launch command prompt and type django-admin.py command and it should throw output similar to Type ‘django-admin.py help’ for usage.
5. Launch Python interpreter and run the commands import django and django.get_version() and output should look like below

D:\PROFILES\chundis>python
Python 2.6 (r26:66721, Oct  2 2008, 11:35:03) [MSC v.1500 32 bit (Intel)] on win32
Type “help”, “copyright”, “credits” or “license” for more information.
>>> import django
>>> django.get_version()
’1.0.1 final’
>>> exit()
D:\PROFILES\chundis>

If you have any problems with step 4 and 5 of Django installation , just make sure you have copied the correct django directory to site-packages.

We are done with Django installation but we need to install dependancies before we can start writing Django Apps.

We still need to install Database and database driver for Python, so that our Django apps can use Database. Also we need to install Python Imaging Library (PIL) for Django to validate images and without this module, you won’t be able to use ImageField()

Database Installation:

If you don’t have any preference, then try mySQL or Postgres.  Postgres comes with pgAdmin by default (A GUI based app to manage database) and for mySQL, there are GUI tools like phpMyAdmin and SQLyogi. I prefer mySQL with SQLYog Community Edition

1. mySQL for windows can be downloaded from  http://dev.mysql.com/downloads/ and Postgres for windows can be download from http://www.postgresql.org/download/windows
2. Both the databases has Windows installers, so installation is pretty much like any other Windows application. Just double click the installer and follow onscreen instructions. There will be a option to select run as service (so make sure you select that, so it will run automatically on windows startup)

Next we need to install Python driver(adapter/module) for Python to communicate with database,

Database Driver installation

Depending on the choice of database you made during previous section (Database installation), you need to install Database driver for Python.

1. If you are using mySQL then Python module for mySQL can be download here ( http://sourceforge.net/projects/mysql-python/ ) or if you decide to use Postgres, then  Python module for PostGre can be downloaded here ( http://www.pygresql.org/readme.html#home-sites-of-the-different-packages ). Make sure you download the latest driver for your Python version. (Most of the drivers are packaged different for different Python versions)
2. Install database driver by executing the binary. (VIsta users, use run as administrator)
3. To test the database and database driver
   1. Create a database
   2. Launch command prompt and create django project using django-admin.py startproject <projectname>
   3. Change Database settings in settings.py under project directory above command created.
   4. cd (Change Directory) to you project directory execute python manage.py validate and it should display 0 errors found

And finally we need Imaging library to support images.

Python Imaging Library installation
On windows this is a straight forward installation, though it troubles a lot on Unix flavor OS to get jpeg support.

1. Download the windows executable from http://www.pythonware.com/products/pil/ and execute it to install PIL (Vista users, run as administrator)

That’s it, your windows box is now Django ready and you can start writing Django apps.

I’m pretty sure all those features are on mind of some of the programmers and we will see an blog app soon  but if they delay longer then I may end up writing one to move this from wordpress to Django.  Anyways we will have a migration guide from WordPress to Django as another post in form of  my migration experiences when when I migrate. Till such time, I’ll use Django badge I wish this site were powered by Django on footer.