Skip to main content

Compile web assets

Project description


You may need a coffeescript compile, a browserify transform and then
want to run uglify to minimize the source for production javascript
files. Or a maybe a SASS compile and minimization.

Chimney is a simple build system primarily intended for web
assets. There are many build systems and most asset compilers are
capable of watching for changes, but it becomes difficult to manage
when more steps are added to the pipeline.


At each step of the process, there is some input, some output and a
transformation process. Chimney simply calls these "compilers" for
simplicity, but they can be any kind of Python code.

To declare a new type of compiler, define a subclass of ``Compiler``:

from chimney.compilers import Compiler

class coffee(Compiler):
def run(self):
# perform compile


Targets are the goal of compilation. This might be a final executable
or an combined javascript file for a page.

Here is an example of a javascript target that needs to be built from
several coffee files (this is using the above compiler):

import chimney

coffee('smoke.js', ['', '']),

This will compile each of the .coffee dependencies to their .js output
forms using the ``coffee`` compiler defined above, then combine those
files into ``smoke.js``.

Next, there should be a step to minify ``smoke.js`` if needed. That's
easy with chimney, simply add another task to the above definition:

coffee('smoke.js', ['', '']),
uglify('smoke.min.js', 'smoke.js'),

Chimney already provides compilers for the most popular web
assets. Others can easily be added to your script by extending the
Compiler class.

Watching for changes

To automatically re-execute tasks when their dependencies change,
the function ```` will first execute all tasks normally
but then it will watch for any filesystem changes.

To get this functionality, the api is slightly different. Instead of
expecting a list of tasks, the function ```` requires
a function. This is called when new files are added so the dependencies
can be recalculated. For example:

def create_tasks():
return [
coffee('smoke.js', ['', '']),
uglify('smoke.min.js', 'smoke.js'),

Whenever the coffee files are changed, ``smoke.js`` will be re-created
using the ``coffee`` compiler. Then ``smoke.min.js`` will be created, too.
When new files are added, the function ``create_tasks`` will be re-executed
to build a new set of tasks. This is useful for dynamically building

By default, the reload will start chimney on all new files, which may
be too often. You can provide a list of (shell) patterns to match
to limit reloading:

def create_tasks():
return [
coffee('smoke.js', ['', '']),
uglify('smoke.min.js', 'smoke.js'),
], reload_patterns=['*.coffee'])

Project details

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

chimney-0.4.tar.gz (9.0 kB view hashes)

Uploaded source

Supported by

AWS AWS Cloud computing and Security Sponsor Datadog Datadog Monitoring Fastly Fastly CDN Google Google Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Sentry Sentry Error logging StatusPage StatusPage Status page