Installation Guide — Transifex v0.9.0 documentation

# Transifex v0.9.0 documentation

# Installation Guide

Before you can use Transifex, you’ll need to get it installed. This guide will guide you to a simple, minimal installation that’ll work while you walk through the introduction.

To avoid spending too much time talking about packaging systems, this guide is based on yum and Fedora. You can substitute those commands with your own distribution’s packaging system commands.

## First things first

### Who should consider installing Transifex?

Good question!

Transifex is a web system for managing complex translation projects and serving files to a community of translators. You can see it live at Transifex.net, our hosted, upstream version of Transifex common for any project which chooses to start receiving translations in a snap. This instance is managed by Indifex, the company sponsoring the development of Transifex.

So, who would be interested in installing Transifex on their systems?

#### Project maintainers

If you’re the administrator of a project or community, then you need to decide whether you would like to setup your own, self-hosted instance of Transifex, or use an upstream, hosted one such as Transifex.net or one of the other public servers available.

The users who usually consider installing their own instance are communities with lots of projects (hundreds) and complex translation workflows. This translates in setting up Tx on one’s own servers and growing a local community of translators instead of using an upstream pool of translators. This choice gives control and freedom to manage the server, however it implies an isolated translation community and higher maintenance costs.

The alternative of a self-managed version is using a common, hosted instance. This allows the sharing of a larger translation community, lower management overhead, and sometimes some extra features available there.

#### Translators

If you’re a translator, you’re probably not interested in installing Transifex itself. Transifex serves the purpose of the server: It distributes translations pulled from a number of upstream projects to people. Currently, you can interact with Transifex using your every-day browser, and there is no specialized Transifex client you can install.

Now that we’ve made clear who we’re talking with, let’s proceed in explaining how a private installation of Transifex can be set up.

## I’m ultra hardcore. Give me just the gist!

The following is what a set of super-fast installation instructions would look like (run as root or under `sudo`):

    yum install python python-setuptools python-imaging
    yum install cvs subversion pysvn mercurial git bzr bzrtools python-urlgrabber
    easy_install transifex

Please note that the above might eventually end up missing something compared to the full instructions below.

## Installing Basic Dependencies

### Python

Being a Python tool, Transifex requires Python. We recommend installing Python 2.5 or later.

You can get Python at http://www.python.org/, or from your favorite distribution. If you’re running Linux or Mac OS X, you probably already have it already installed.

You can verify that Python’s installed by typing `python` from your shell. You should see something like:

    Python 2.5.1 (r251:54863, Jun 15 2008, 18:24:51)
    [GCC 4.3.0 20080428 (Red Hat 4.3.0-8)] on linux2
    Type "help", "copyright", "credits" or "license" for more information.
    >>>

#### A note on `PythonPath`

These applications can be installed anywhere on your system, as long as Python can find them. Python uses the `PythonPath` environment variable for this. The value you use for `PythonPath` should include the parent directories of all the modules you are going to import in your application. It should also include the parent directory of Transifex itself. This is exactly the same situation as setting the Python path for interactive usage. Whenever you try to import something, Python will run through all the directories in `sys.path` in turn, from first to last, and try to import from each directory until one succeeds.

An example might make this clearer. Suppose you have some applications under `/usr/local/django-apps/` (for example, `/usr/local/django-apps/weblog/` and so forth), your settings file is at `/var/www/mysite/settings.py` and you have specified DJANGO_SETTINGS_MODULE as in the above example. In this case, you would need to write your `PythonPath` directive as:

    PythonPath "['/usr/local/django-apps/', '/var/www'] + sys.path"

With this path, `import weblog` and `import mysite.settings` will both work. If you had `import blogroll` in your code somewhere and `blogroll` lived under the `weblog/` directory, you would also need to add `/usr/local/django-apps/weblog/` to your `PythonPath`. Remember: the parent directories of anything you import directly must be on the Python path.

### Version Control Systems

To run Transifex you probably need some versioning systems. By default Transifex only requires Mercurial (hg). Depending of which ones you want to use, you will need to install some of the following packages:

- Bazaar (bzr)
- CVS (cvs)
- Git (git)
- Mercurial (hg)
- Subversion (svn)

Since the above are probably available from your distribution, you can use its own tools to install them. On Fedora you can run the following command:

    yum install cvs subversion pysvn mercurial git bzr bzrtools

If you’re enabling the tarball support, you also need ‘urlgrabber’:

    yum install python-urlgrabber

## Installing Transifex

There are three basic ways to install Transifex:

- Using Python’s packaging tools (stable version)
- Using your distribution’s packaging tools (stable version)
- Pulling directly from our development repository (stable and development versions)

### Install using Python’s setuptools

Probably the easiest way to install Transifex is by using Python’s common packaging tools. Since Tx is registered on the Python Packaging Index and has defined its own Python dependencies, using this method to install all the required software is quite easy.

First off, you’ll need the following packages installed:

    yum install python-setuptools python-imaging

Note

If `python-imaging` isn’t available in your packaging system, just install `gcc` and the following command will pull and auto-compile this package for you.

By default, `easy_install` installs the software in your system’s standard Python packages directory (eg. `/usr/lib/python2.5/site-packages/transifex`). If you want to do this, running the following as root or with sudo, should do the trick:

    easy_install transifex

#### Using a virtual environment

Alternatively, you can setup a virtual environment using `virtualenv`, and isolate your Transifex installation in its own “shell”. This is particularly useful for testing Tx, for “freezing” Tx’s dependencies, and, your best choice if you don’t have root access on the system.

A set of commands similar to the following will create a virtual environment in the current directory and install Transifex in there:

    sudo easy_install virtualenv    # or: sudo [yum] install virtualenv
    virtualenv txenv                # create the environment
    source txenv/bin/activate       # switch in using it
    easy_install transifex          # nstall Tx in the virtual env

For more information on this way of installing Tx, please refer to the documentation of virtualenv itself.

If you’ve already installed the non-Python dependencies (like some of the versioning systems you might use) mentioned in the previous sections, you could jump to the Initial configuration section to proceed in configuring your setup.

### Install using your distribution’s tools

Transifex has been packaged in a number of Linux distributions. You can check your distribution’s packaging system to see if it is available in yours:

    $ yum info transifex
    Available Packages
    Name       : transifex
    Arch       : noarch
    Summary    : A system for distributed translation submissions
    URL        : http://transifex.org/
    License    : GPLv2
    Description: Transifex is a web-system that facilitates the process of submitting
               : translations in remote and disparate version control systems (VCS).

If Transifex is available for your distribution, you can proceed by installing it just like any other package. In the case of Fedora, the software is split in two packages, and can be installed as follows:

    yum install transifex transifex-extras

To configure your setup, proceed to the Initial configuration section.

### Install manually

You can get the source code in a number of ways.

#### Getting a stable version

Stable releases are available from the following location(s), in addition to alpha, beta, and release candidates:

- http://transifex.org/files/
- http://pypi.python.org/pypi/transifex

Tarball are source packages, whereas eggs are binary distributions for a specific version of Python.

#### Getting a development version

Our development tree is kept pretty stable at all times. This is achieved by reviewing patches before they are submitted, and by having very few core committers. However, you should keep in mind that while the code is stable, the database schema isn’t. During the development of a major release, the DB structure (Django models) change rapidly, so you’ll need to evolve your schema quite often using our out-of-the-box migrations.

Knowing the above, feel free to jump right in and install a development version from our Mercurial repo and enjoy our newest and greatest features.

The current development version of Transifex can be fetched by cloning the mainline repository:

    hg clone http://code.transifex.org/mainline transifex

From here you can also switch to stable versions, which are tagged appropriately:

    cd transifex
    hg tags
    hg update <tag>

To grab a branched development version of Transifex, you can navigate to http://code.transifex.org/ to see the active branches.

#### Install dependencies

##### Django

Transifex is developed on top of a Python Web Framework called Django. We recommend installing the latest version of Django, but anything above 1.1 should do. You can get more information about how to install Django on your system from the official Django documentation.

Usually you can use the package your distribution provides you:

    yum install Django

##### Python dependencies

This is the generic method for creating a development environment for Transifex. We strongly suggest running those commands inside a virtualenv environment instead of running them as root. For an example of a Virtualenv setup, take a look at the Virtualenv example wiki page. You can also install some of these dependencies as packages in your distribution, if they are available.

    easy_install Markdown httplib2 pygments>=1.0 polib>=0.5.1
    easy_install pygooglechart
    easy_install django-pagination django-notification django-authority \
      django-piston south>=0.7 django-sorting django-filter django-staticfiles \
      django-addons
    easy_install -f http://transifex.org/files/deps/ contact_form \
      django-tagging userprofile django-ajax-selects \
      django-threadedcomments>=0.9
    easy_install -f http://effbot.org/downloads/ Imaging==1.1.6

Non-Python dependencies (like versioning systems) need to be installed with traditional ways (like your system’s packaging mechanism).

##### Translation-specific packages

Transifex requires a couple of standard packages to support translations. Currently these are the following:

- gettext (standard Internationalization library)
- intltool (for dynamic `POT`-file generation)

On Fedora you can run:

    yum install gettext intltool

## Initial configuration

### Initialize the database

After you have all dependencies and packages installed, the Transifex installation should be very simple. Customize `settings/*.conf` and `urls.py` to accommodate your server’s needs.

To enable Transifex’s notifications you’ll need to switch the relevant setting called ENABLE_NOTICES to `True`.

To have your widget code viewable from outside your transifex instance you have to set your `STATIC_URL` variable to an absolute URL (by using relative paths you can still view the widgets on your own installation)

Note

Ensure the database server defined in the settings files is properly configured and running, and that your selected database is using UTF-8. Depending on the backend, this is achieved in different ways; for example, in MySQl, you might want to modify `my.cnf` or create the database with a command similar to the following:

    CREATE DATABASE db_name DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;

For more information refer to the Django Documentation Section “Creating the database“.

Once you’re done configuring, run inside the project directory:

    ./manage.py txcreatedirs        # Create necessary directories
    ./manage.py syncdb              # Setup DB tables, create superuser
    ./manage.py migrate             # Setup more DB tables
    ./manage.py txcreatelanguages   # Create a standard set of languages
    ./manage.py txcreatenoticetypes # Create a standard set of notice types
    ./manage.py build_static        # Copy all the addons files to the static dir
    ./manage.py runserver 8088      # Start the development server

The first command will create the necessary directories on the disk. Note that the user you’re running the software as, needs to have write access to these directories (check out your configuration files to see what these are).

`syncdb` will create the database tables, and ask you to create an admin user (superuser), who will have access to the admin panel. The latter is by default accessible through `/admin/`, something you can customize by modifying the file `transifex/urls.py`.

Now, you can fire up your browser at `http://localhost:8088/`, grab a cup of coffee and lean back.

### Import some data

Transifex uses the fixtures feature of Django to load some initial data in the database. The following commands require you having run `./manage.py syncdb` at least once before in order for the database tables to exist.

The following commands loads a bunch of sample data to play around with.

    ./manage.py loaddata txcommon/fixtures/sample_data.json
    ./manage.py loaddata txcommon/fixtures/sample_users.json

The last command created two users: ‘guest’ and ‘editor’. The ‘guest’ has the basic rights of a logged-in user of the site, while the ‘editor’ account has more advanced privileges like modifying projects, etc. Together with the ‘admin’ user created with the ‘syncdb’ step above, you should have 3 accounts now, each with its own access level.

You can now fire up your browser to check out the newly imported data.

Note that the registered projects have not been actually checked out by Transifex yet. To have translation files downloaded and fresh statistics produced, run a fresh checkout:

    ./manage.py txstatsrefresh

This command is usually used in a cronjob to refresh Transifex’s cache and translation statistics every once in a while for translators.

### Internationalization (i18n) support

To be able to use Transifex with a localized interface, it is necessary to create the translations objects files (.mo) using one of the following commands, for example:

    ./manage.py txcompilemessages -l pt_BR
    or
    ./manage.py txcompilemessages

At this point you’re ready to read about running Transifex to proceed to further customization of your instance.

## Debugging

Debugging is enabled through a separete `SETTINGS` file, which enables some additional applications and features. Some of these additional applications might require installation using `easy_install`, but you can enable any number you want by editing the `settings_debug.py` file.

Some of these applications define their own models, so the first time you’ll use the file, a ‘syncdb’ using that file will be needed to have the respective database tables created:

    ./manage.py syncdb --settings settings_debug

From that point on, you can run the debug server as follows:

    ./manage.py runserver --settings settings_debug

## Testing

For testing the whole project you can run:

    ./manage.py test

For testing a specific application inside Transifex you can run:

    ./manage.py test projects

Alternatively, by installing the `django-nose` package, the following command can prove useful:

    nosetests --with-django <location-of-test-file>