Stefan ihm sein Blog

Tea Timer 1.7.1 is final now. Thank you for testing. Tea Timer also rembers now if you don’t want to update to a specific version and won’t show the update dialog until the next update.

Download | ChangeLog

In CSS there is no concept of sections or nested blocks. But since CSS files usually become very long, you may want to fold groups of style definitions to get a better overview:

/* start foldme */
p { color: #000 }
/* end foldme */

Since this is not possible with the CSS bundle shiped with Textmate, I added this on myself:

1. I first added a snipped called section to the CSS bundle:

   /* start ${1:section} */
   $0
   /* end $1 */
   

   It gets activated by the tab trigger sec. The scope selector is source.css.

2. I then modified the language definition and added |/\* start \w+ \*/ to the foldingStartMarker and |/\* end \w+ \*/ to the foldingStopMarker. They should look like this now:

   foldingStartMarker = '/\*\*(?!\*)|\{\s*($|/\*(?!.*?\*/.*\S))|/\* start \w+ \*/';
   foldingStopMarker = '(?<!\*)\*\*/|^\s*\}|/\* end \w+ \*/';
   

That’s all you need to do.

Sorry for that buggy 1.7 release. Thanks to you, who helped me fixing them by giving good error descriptions. Also thanks you, who trolled and thus showed me how much you need this little widget. ;-)

To be sure, I really fixed everything, I’ve decided let you test the new release, before I make it final. Please download the curren tip from the repository at bitbucket.org. If you find anything, please create an issue or just write a comment here. Thanks!

PS: I’ve decided to leave the update message the way it is. Normally, you only have to see it once or twice a year and it takes just one click to get rid of it. :)

I just released Tea Timer 1.7 which implements a few wishes from you:

• There’s now a rewind button for resetting an ongoing countdown to its initial value.
• The timer will be reset to the initial value, not the last pause value, after the alarm.
• The current widget’s settings will also be saved as default settings for new widgets.

Unfortunately it was not possible (neither with Python nor with Apple Script) to implement a backlink from Growl to Tea Timer to stop the alarm when you click on the Growl notification.

Anyway, Download Tea Timer 1.7 and enjoy!

It took me nearly three months to fix five small issues with the documentation. But now I finally released Collectors v1.0. :-)

You can read everything important in the RC1 posting.

Collectors made a huge jump von v0.1 to v1.0 over the last weeks, since we added lots of changes and consider what we’ve done as stable. If we don’t find any bugs, we’ll release the final v1.0 at the end of next week. The changes are:

• [NEW] Documentation!
• [NEW] Tests!
• [NEW] Collectors can use different storage backends now
• [NEW] Storage backend for PyTables
• [NEW] Storage backend for MS Excel
• [NEW] Collector.collect() as alias to Collector.__call__()
• [CHANGE] Monitor is now called Collector
• [CHANGE] Shortcut functions moved to shortcuts package

You can download and install Collectors via PyPI. If you find any bugs or have ideas for further enhancement, please let us know.

The Documentation can be found here.

After reading The Hitchhiker’s Guide to Packaging I update my packages for django-lastfm and django-sphinxdoc.

There are no functionional improvements, so you don’t need to update them.

In my last post I wrote about code highlighting in HTML formatted text, but since I’m now using reStructuredText for markup things, I want to share how I added synthax highlighting for this.

Within your project directory (the same that contains the settings.py) create a file called rst_directive.py and fill it with the following code:

# -*- coding: utf-8 -*-
"""
    The Pygments reStructuredText directive
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    This fragment is a Docutils_ 0.5 directive that renders source code
    (to HTML only, currently) via Pygments.

    To use it, adjust the options below and copy the code into a module
    that you import on initialization.  The code then automatically
    registers a ``sourcecode`` directive that you can use instead of
    normal code blocks like this::

        .. sourcecode:: python

            My code goes here.

    If you want to have different code styles, e.g. one with line numbers
    and one without, add formatters with their names in the VARIANTS dict
    below.  You can invoke them instead of the DEFAULT one by using a
    directive option::

        .. sourcecode:: python
            :linenos:

            My code goes here.

    Look at the `directive documentation`_ to get all the gory details.

    .. _Docutils: http://docutils.sf.net/
    .. _directive documentation:
       http://docutils.sourceforge.net/docs/howto/rst-directives.html

    :copyright: Copyright 2006-2009 by the Pygments team, see AUTHORS.
    :license: BSD, see LICENSE for details.
"""

# Options
# ~~~~~~~

# Set to True if you want inline CSS styles instead of classes
INLINESTYLES = False

from pygments.formatters import HtmlFormatter

# The default formatter
DEFAULT = HtmlFormatter(noclasses=INLINESTYLES)

# Add name -> formatter pairs for every variant you want to use
VARIANTS = {
    # 'linenos': HtmlFormatter(noclasses=INLINESTYLES, linenos=True),
}


from docutils import nodes
from docutils.parsers.rst import directives, Directive

from pygments import highlight
from pygments.lexers import get_lexer_by_name, TextLexer

class Pygments(Directive):
    """ Source code syntax hightlighting.
    """
    required_arguments = 1
    optional_arguments = 0
    final_argument_whitespace = True
    option_spec = dict([(key, directives.flag) for key in VARIANTS])
    has_content = True

    def run(self):
        self.assert_has_content()
        try:
            lexer = get_lexer_by_name(self.arguments[0])
        except ValueError:
            # no lexer found - use the text one instead of an exception
            lexer = TextLexer()
        # take an arbitrary option if more than one is given
        formatter = self.options and VARIANTS[self.options.keys()[0]] or DEFAULT
        parsed = highlight(u'\n'.join(self.content), lexer, formatter)
        return [nodes.raw('', parsed, format='html')]

directives.register_directive('sourcecode', Pygments)

Open the file __init__.py in the same directory and add the following line:

import rst_directive

Furthermore you might want to create a CSS file containing all the style definitions in your static media directory. The following python script will do the job:

# Call it this way:
# python gen_css.py pygments.css
import sys

from pygments.formatters import HtmlFormatter

f = open(sys.argv[1], 'w')

# You can change style and the html class here:
f.write(HtmlFormatter(style='colorful').get_style_defs('.highlight'))

f.close()

Now you can highlight code using the sourcecode directive:

*Hello World!* in Python is so easy:

.. sourcecode:: python

    print 'Hello World!'

That’s it! If you have any questions, leave a comment.

Two months ago I wrote about Django, Pygments and Beautiful Soup.

A few days after the post I switched from HTML markup to reStructuredText and thus didn’t need my filter anymore and forgot to post more about it.

Today I received a comment asking me to publish the source code of the template filter—so here it is:

# encoding: utf-8

"""
A filter to highlight code blocks in html with Pygments and BeautifulSoup.

    {% load highlight_code %}

    {{ var_with_code|highlight|safe }}
"""

from BeautifulSoup  import BeautifulSoup
from django import template
from django.template.defaultfilters import stringfilter
import pygments
import pygments.formatters
import pygments.lexers


register = template.Library()

@register.filter
@stringfilter
def highlight(html):
    soup = BeautifulSoup(html)
    codeblocks = soup.findAll('pre')
    for block in codeblocks:
        if block.has_key('class'):
            try:
                code = ''.join([unicode(item) for item in block.contents])
                lexer = pygments.lexers.get_lexer_by_name(block['class'])
                formatter = pygments.formatters.HtmlFormatter()
                code_hl = pygments.highlight(code, lexer, formatter)
                block.contents = [BeautifulSoup(code_hl)]
                block.name = 'code'
            except:
                raise
    return unicode(soup)

Copy the code into a file called templatetags/highlight_code.py within a new or an existing Django app.

highlight() searches the passed HTML code for <pre>-tags with a class denoting the lexer to be used, e.g.:

<p><em>Hello World!</em> in Python:</p>
<pre class="python">
print 'Hello World'
</pre>

Furthermore you might want to create a CSS file containing all the style definitions in your static media directory. The following python script will do the job:

# Call it this way:
# python gen_css.py pygments.css
import sys

from pygments.formatters import HtmlFormatter

f = open(sys.argv[1], 'w')

# You can change style and the html class here:
f.write(HtmlFormatter(style='colorful').get_style_defs('.highlight'))

f.close()

I hope I explained all this well enough—if not, leave a comment and I’ll update this post. :-)

Just released version 0.2 of django-sphinxdoc. It can now display the documentation itself, the general index and the module index. The source and static views as well as the search functionality is not implemented yet.

I’m still pondering whether to use a Google custom search or the Sphinx JavaScript search. Maybe it would be even better if I used Haystack …

You can find a quick guide as well as some other guides in django-sphinxdoc’s documentation section (which is of course powered by django-sphinxdoc ;-)).

The download can be found at bitbucket.org.