• It allows you to filter by returned values of object methods.
• It searches for the term anywhere in the value.
• It does a case in-sensitive search.
• It does some basic value clean up.

The code is commented fairly extensively so you should be able to figure out what I’m doing.

import re

FILTER_RE = re.compile('[-[\]{}()*+?.,\\^$|#\s]')
REPLACE_WITH = ''
def filter_helper(object_list, attr, term):
    """
    Helper method for filtering object_lists.

    @param  object_list     An array of objects to filter.
    @param  attr            An attribute on the object to filter the list by.
    @param  term            The filter term to look for in the attribute.
    @return The filtered list
    """

    # remove special characters from the filter term
    escaped_term = FILTER_RE.sub(REPLACE_WITH, term)

    def compare(x):
        """
        Function that compares the value to the filter term.

        @param  x    The object we are looking at.
        @return True if we have a match otherwise False.
        """

        # get the attribute off the object
        v = getattr(x, attr)

        # attribute is a method so get the return value
        if callable(v): v = v()

        # remove special characters from the attribute value
        ev = FILTER_RE.sub(REPLACE_WITH, v)

        # if the term is an exact match or the escaped term is in the escaped attr
        if term == v or re.search(escaped_term, ev, re.I):
            return True
        return False

    # run the compare function through the list to create the filtered list
    return filter(compare, object_list)

To use the helper you would do something like:

object_list = Users.all().fetch(1000)
filtered = filter_helper(object_list, 'display_name', 'Rich')

This would filter a list of users to only users with the word “rich” in it’s display name.

You can download the full source here.

• It allows you to sort by returned values of object methods.
• It allows you to sort the objects in ascending or descending value order.
• It allows sorting by multiple attributes.
• It does some basic value clean up before sorting for sort consistency.

The code is commented fairly extensively so you should be able to figure out what I’m doing.

def sort_helper(object_list, sort_list, db_field_map=None):
    """
    Helper method for sorting object_lists.

    @param  object_list     An array of objects to sort.
    @param  sort_list       An array of names to sort by.
    @param  db_field_map    An optional dictionary that maps a sort name to an object's property or method.
    @return The sorted list
    """

    def clean(x):
        """
        Function that cleans the value to sort by.

        @param  x    The attribute on the object.
        @return The cleaned up value for sorting.
        """

        # attribute is a method so get the returned value
        v = x() if callable(x) else x

        # attribute is a string so convert it to lower case
        if type(v) == str or type(v) == unicode:
            v = v.lower()

        # attribute is a datetime so convert it to an epoch value
        elif type(v) == datetime.datetime:
            v = time.mktime(v.timetuple())

        # return the value
        return v

    # reverse the sort order so we get the correct sub-sorting
    sort_order = reversed(sort_list)

    # Generate the actual list of attributes we'll be sorting by
    for sort_item in sort_order:

        # -name so sort this attribute descending
        if sort_item[0] == '-':
            base_sort_item = sort_item[1:]
            reverse = True

        # Otherwise sort in ascending order
        else:
            base_sort_item = sort_item
            reverse = False

        # Check if the name is in the db field map
        if db_field_map:
            if not base_sort_item in db_field_map:
                continue
            db_field = db_field_map[base_sort_item]
        else:
            db_field = base_sort_item

        # Do the actual sort now
        try:
            object_list = sorted(object_list, key=lambda x: clean(getattr(x, db_field)), reverse=reverse)
        except Exception, e:
            logging.exception('sort_helper - %s' % unicode(e))

    return object_list

To use the helper you would do something like:

object_list = Users.all().fetch(1000)
sorted = sort_helper(object_list, ['-created', 'display_name'])

This would sort a list of users in decending created order then ascending display name.

You can download the full source here.

I contacted Mediacom to find out if service was available for our new home. They responded that our house was not serviceable. The image below (from connect iowa) illustrates why this is so frustrating. The red square is the lot we are building on. The red/pink overlay is where cable is available. I bet there isn’t a thousand feet between the two.

  function getBackgroundPage(id, src) {

    // get the firefox hidden window
    var win = Components.classes["@mozilla.org/appshell/appShellService;1"].
                   getService(Components.interfaces.nsIAppShellService).
                   hiddenDOMWindow;

    // if the iframe was previously loaded store it and callback
    var iframe = win.document.getElementsById(id);
    if (iframe)
      return iframe.contentWindow;

    // create the iframe
    iframe = win.document.createElement("iframe");
    iframe.setAttribute("id", id);
    iframe.setAttribute("style", "display:none;");

    // load the source
    iframe.setAttribute("src", src);
    win.document.documentElement.appendChild(iframe);

    // return the content window
    return iframe.contentWindow;

Now you can access your background page by including the script in your overlay and doing:

  var bgp = getBackgroundPage("id for background page", "url of the background page");

** UPDATE **
instead of setting the style to display:none you should instead set the attribute “collapsed” to true. This causes docshell errors in some cases.

iframe.setAttribute(“style”, “display:none;”);
iframe.setAttribute(“collapsed”, “true”);

After much trial and error the website for my company “Web Tech Studios” is now live. Please, look it over and let me know what you think. You can also follow me on twitter @webtechstudios.

With Firefox 3.5 we were able to fix this by creating the diamond using only html and some specialized css tags. Using the tags: -moz-transform, -moz-border-radius, and -moz-box-shadow we rotate the div 45 degrees and add a shadow to them.

  display: inline-block !important;
  border: 2px solid #494949 !important;
  background: none !important;
  background-color: white !important;
  -moz-transform: rotate(45deg) !important;
  -moz-border-radius: 4px !important;
  -moz-box-shadow: grey 2px 2px 2px !important;

This also rotates the content within the div. To fix that we rotate the image back 45 degrees.

  -moz-transform: rotate(-45deg) !important;

And viola, a diamond with all the html event goodness, made with only html and css. Safari and Chrome support these transforms with -webkit-transform so this same effect can be used there.

First create a file called template.py in your application. Then we create a method that will cache a template when called and return the rendered template.

from django.template import Context, loader

template_cache = {}
def render_cached(template_name, dictionary=None):
    global template_cache

    t = template_cache.get(template_name, None)
    if not t or settings.DEBUG:
        template_cache[template_name] = t = loader.get_template(template_name)

    dictionary = dictionary or {}
    context_instance = Context(dictionary)
    return t.render(context_instance)

This method takes two arguments the template name and a dictionary to use for the template context. It first gets the template out of the cache. It then looks if the template was retrieved or if your debug setting is on. If either of these cases exist, it uses the base django loader to retrieve the parsed template and store it in the cache dictionary. Then we create a context instance for the dictionary and return the rendered code.

To be able to use the method you just import and call it.

from template import render_cached
html = render_cached("sometemplate.html", {})

• New Search Clovers for selection based searching functionality
• Updated Bing provider
• Updated compatibility for ff 3.6betas
• Improve sqlite performance
• Trim leading and trailing spaces from searches to improve accuracy
• Updated kwiclick skin
• Replace getBoxObjectFor with getBoundingClientRect
• Clover preferences to fine tune functionality
• Turn on/off clover from statusbar button
• Updated wikipedia provider increases accuracy of searching and results

Here is the video for the 2.4 release which was submitted to the extend firefox contest. This is a pretty good explanation of the things you can do with KwiClick.