I’ve built a Python proof of concept (using md5 as a hash function) suitable for Linux.

import hashlib
import struct
 
 
class GRandom:
    def __init__(self):
        self.audio = open("/dev/dsp","rb")
        self.hash = hashlib.md5()
 
    def get_raw_block(self):
        buffer = self.audio.read(self.hash.block_size*8)
        bytes = struct.unpack("%iB"%len(buffer), buffer)
 
        longs = []
        for i in range(self.hash.block_size/4):
            temp = 0
            for b in bytes[i*32:(i+1)*32]:
                temp = (temp << 1) ^ (b & 1)
            longs.append(temp)
        return struct.pack("%iI"%len(longs), *longs)
 
    def get_block(self):
        self.hash.update(self.get_raw_block())
        return self.hash.digest()

The amount of generated bits per second is given by (sample rate)*(digest size)/(block size). So for 8KHz (default) sampling rate and md5 we’ll get a theoretical speed of ~250Kbs. SHA type hashes have higher digest to block size ration thus may result in higher speeds. Another source of speed up may be to change the sample rate of the microphone. But setting it to high may have negative effects on the entropy. The code may get a considerable performance gain by porting it to c/c++, as it uses both bit manipulations and calculates hashes. Anyways, even the Python implementation’s speed allows us it be used for many cases where true randomness is required, such as generating passwords.

The guidelines weren’t just empty words, they were written while working on the Hebrew adaptation to the Fusion theme and in the same time writing a new proof-of-concept version of cssrtl.py. The original intent was to release a more mature version of that code when it will be completed. However, due to the apparent shortage of time in the present and foreseeable future, I can’t see myself complete the project any time soon. So following the “release early” mantra, I’ve decided to release the code as-is. As I said, the code is in working state, but not polished, so it may be of benefit but may contain bugs. If you find any bugs or have any suggestions, I would be glad to hear.

Download

You can download the new version from here: cssrtl.py-2.0.tar.bz2. The code is available under the GPLv2 or any later version.

Usage

The new version works by creating a seperate css “fix” file that fixes the directionality of the css styles.

./cssrtl.py < main.css > main-rtl.css

Afterward, just link the main-rtl.css after main.css in your HTML files.

So when Jon Flowers asked in the comments of the original tarsum post about the possibility of getting the checksums of files in the tar file without extracting all the archive, I’ve decided to re-tackle the problem.

This time I’ve chose python and by using the tarfile and hashlib modules I came up with a solution that allowed me to go over tar files to calculate the checksum values without extracting all of them to the disk. However some sacrifices where made in the form of back-compatibility of the output. I’ve tried to make the interface similar to the old one, and have kept all the command line options. Instead of specifying a program name to calculate the checksum values (such as sha1sum) as argument to --checksum you specify the name of the checksum algorithm such as md5, sha1, sha256, sha512 (or any other supported by hashlib).

Other changes where made so tar files can be piped directly into tarsum (which also works transparently with bzip2 and gzip compression).

tarsum < sometarfile.tar.gz > sometarfile.tar.gz.md5

Performance-wise, according to some tests I’ve carried out, the new version is faster with big tar files than the old one, but it’s the other way around with small archives (which I find less important).

#! /usr/bin/env python
 
# Copyright (C) 2008-2009 by Guy Rutenberg
 
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the
# Free Software Foundation, Inc.,
# 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
import hashlib
import tarfile
 
def tarsum(input_file, hash, output_file):
        """
        input_file  - A FILE object to read the tar file from.
        hash - The name of the hash to use. Must be supported by hashlib.
        output_file - A FILE to write the computed signatures to.
        """
        tar = tarfile.open(mode="r|*", fileobj=input_file)
 
        chunk_size = 100*1024
        store_digests = {}
 
        for member in tar:
            if not member.isfile():
                continue
            f = tar.extractfile(member)
            h = hashlib.new(hash)
            data = f.read(chunk_size)
            while data:
                h.update(data)
                data = f.read(chunk_size)
            output_file.write("%s  %s\n" % (h.hexdigest(), member.name))
 
def main():
    parser = OptionParser()
 
    version=("%prog 0.2.1\n"
             "Copyright (C) 2008-2009 Guy Rutenberg <http://www.guyrutenberg.com/contact-me>")
    usage=("%prog [options] TARFILE\n"
           "Print a checksum signature for every file in TARFILE.\n"
           "With no FILE, or when FILE is -, read standard input.")
    parser = OptionParser(usage=usage, version=version)
    parser.add_option("-c", "--checksum", dest="checksum", type="string",
        help="use HASH as for caclculating the checksums. [default: %default]", metavar="HASH",
        default="md5")
    parser.add_option("-o", "--output", dest="output", type="string",
        help="save signatures to FILE.", metavar="FILE")
 
    (option, args) = parser.parse_args()
 
    output_file = sys.stdout
    if option.output:
        output_file = open(option.output, "w")
 
    input_file = sys.stdin
    if len(args)==1 and args[0]!="-":
        input_file = open(args[0], "r")
 
    tarsum(input_file, option.checksum, output_file)
 
if __name__ == "__main__":
    from optparse import OptionParser
    import sys
    main()
 
# vim: ai ts=4 sts=4 et sw=4

You can get a wget’able version here: tarsum-0.2.bz2.

Update 2009-08-12: Removed excess argument to tarsum() and switched the filemode to r|* (from r:*). Bumped version string.

• deletion
• insertion
• substitution
• transposition

The distance of two strings are the minimal number of such operations needed to transform the first string to the second. The algorithm can be used to create spelling correction suggestions, by finding the closest word from a given list to the users input. See Damerau–Levenshtein distance (Wikipedia) for more info on the subject.

Here is an of the algorithm (restricted edit distance version) in Python. While this implementation isn’t perfect (performance wise) it is well suited for many applications.

"""
Compute the Damerau-Levenshtein distance between two given
strings (s1 and s2)
"""
def DamerauLevenshteinDistance(s1, s2):
    d = {}
    lenstr1 = len(s1)
    lenstr2 = len(s2)
    for i in xrange(-1,lenstr1+1):
        d[(i,-1)] = i+1
    for j in xrange(-1,lenstr2+1):
        d[(-1,j)] = j+1
 
    for i in xrange(0,lenstr1):
        for j in xrange(0,lenstr2):
            if s1[i] == s2[j]:
                cost = 0
            else:
                cost = 1
            d[(i,j)] = min(
                           d[(i-1,j)] + 1, # deletion
                           d[(i,j-1)] + 1, # insertion
                           d[(i-1,j-1)] + cost, # substitution
                          )
            if i>1 and j>1 and s1[i]==s2[j-1] and s1[i-1] == s2[j]:
                d[(i,j)] = min (d[(i,j)], d[i-2,j-2] + cost) # transposition
 
    return d[lenstr1-1,lenstr2-1]

#!/usr/bin/python
import urllib
import urllib2
import re
import socket
import os
socket.setdefaulttimeout(30)
#adjust the site here
search_term="site:guyrutenberg.com"
def main():
    headers = {'User-Agent': 'Mozilla/5.0 (X11; U; Linux i686 (x86_64); en-US; rv:1.8.1.4) Gecko/20070515 Firefox/2.0.0.4'}
    url = "http://www.google.com/search?q="+search_term
    regex_cache = re.compile(r'<a href="(http://\d*\.\d*\.\d*\.\d*/search\?q\=cache.*?)".*?>Cached</a>')
    regex_next = re.compile('<a href="([^"]*?)"><span id=nn></span>Next</a>')
 
    #this is the directory we will save files to
    try:
        os.mkdir('files')
    except:
        pass
    counter = 0
    pagenum = 0
    more = True
    while(more):
        pagenum += 1
        print "PAGE "+str(pagenum)+": "+url
        req = urllib2.Request(url, None, headers)
        page = urllib2.urlopen(req).read()
        matches = regex_cache.findall(page)
        for match in matches:
            counter+=1
            tmp_req = urllib2.Request(match.replace('&amp;','&'), None, headers)
            tmp_page = urllib2.urlopen(tmp_req).read()
            print counter,": "+match
            f = open('files/'+str(counter)+'.html','w')
            f.write(tmp_page)
            f.close()
        #now check if there is more pages
        match = regex_next.search(page)
        if match == None:
            more = False
        else:
            url = "http://www.google.com"+match.group(1).replace('&amp;','&')
 
if __name__=="__main__":
    main()
 
# vim: ai ts=4 sts=4 et sw=4

Before using the script you need to adjust the search_term variable near the beginning of the script. In this variable goes the search term for which all the available cache would be downloaded. E.g. to retrieve the cache of all the pages of http://www.example.org you should set search_term to site:www.example.org

The next problem I faced was how to start the Trac automatically upon startup. The solution was to use an init.d script for stating Trac. After some searching, I didn’t find an init.d script for tracd that were satisfactory (mostly poorly written). So I went on an wrote my own init.d script for tracd.

#!/bin/sh
### BEGIN INIT INFO
# Provides:          tracd
# Required-Start:    networking
# Required-Stop:     networking
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Start the tracd standalone Trac web server.
### END INIT INFO
# (C) 2008 Guy Rutenberg <http://www.guyrutenberg.com>
 
## Options you should probably change ##
HOSTNAME=127.0.0.1 # to which hostname should we listen
# If you only want to serve one project keep this variable
# empty and set the PROJECT_ENV variable 
ENV_PARENT_DIR=/home/guyru/trac.guyrutenberg.com
PROJECT_ENV=
PORT=9090
# add any additional options (such as authentication) here. If you only have one
# project you should probably add -s here
ADDITIONAL_OPTS=
 
## Options you should probably not change ##
DAEMON=/usr/bin/tracd
NAME=tracd
DESC="web server"
PIDFILE=/var/run/$NAME.pid
SCRIPTNAME=/etc/init.d/$NAME
SSD="/sbin/start-stop-daemon"
 
test -x $DAEMON || exit 1
 
set -e
 
. /lib/lsb/init-functions
 
DAEMON_OPTS="--daemonize --pidfile=$PIDFILE --port=$PORT --hostname=$HOSTNAME $ADDITIONAL_OPTS"
if [ -n "$ENV_PARENT_DIR" ]; then
	DAEMON_OPTS="$DAEMON_OPTS --env-parent-dir=$ENV_PARENT_DIR"
else
	DAEMON_OPTS="$DAEMON_OPTS $PROJECT_ENV"
fi
 
case "$1" in
  start)
	log_daemon_msg "Starting $DESC" $NAME
	if ! $SSD --start --quiet\
	--pidfile $PIDFILE --exec $DAEMON -- $DAEMON_OPTS ; then
            log_end_msg 1
	else
            log_end_msg 0
	fi
    ;;
  stop)
	log_daemon_msg "Stopping $DESC" $NAME
	if $SSD --stop --retry 30\
	--pidfile $PIDFILE ; then
	    rm -f $PIDFILE
	    log_end_msg 0
	else
	    log_end_msg 1
	fi
	;;
  restart|force-reload)
	$0 stop
	[ -r  $PIDFILE ] && while pidof -x $NAME |\
		 grep -q `cat $PIDFILE 2>/dev/null` 2>/dev/null ; do sleep 1; done
	$0 start
	;;
  *)
	echo "Usage: $SCRIPTNAME {start|stop|restart|force-reload}" >&2
	exit 1
	;;
esac
 
exit 0

The script begins with a configuration section. You should go over each variable and make sure its value suits you need. The first part is configuration variables you are more likely to change. It includes:

• HOSTNAME – This tells tracd on what hostname to listen. From my experience setting it to anything other than 127.0.0.1 or localhost will cause it to operate on all available hostnames. If you use tracd in conjunction with mod_proxy (this is usually the case if you have Lighttpd) you would want to leave the hostname on 127.0.0.1 so the tracd server won't be accessed directly.
• ENV_PARENT_DIR - If you have multiple projects (all under then same directory) set this to the parent directory. If you only want to serve one project you should leave this empty and set the next variable.
• PROJECT_ENV - Set this to the project environment directory of you project if you serve only one. This variable is ignored if ENV_PARENT_DIR is set to anything but empty.
• PORT - This simply tells tracd on what port to listen.
• ADDITIONAL_OPTS - This variable allows you to pass additional parameters to the tracd. It's the place to add you authentication flags. If you have only a single project and would like to omit the project name in the url (e.g. something like http://trac.example.com) add the -s flag to this variable.

The other part of the configuration allows you to easily adjust the script to your machine. It has variables for specifying the path to the tracd executable and the paths of other things required of the correct operation of the script. In most cases you wouldn't have to change this part.

Now copy the script to /etc/init.d/trac and adjust the configuration to your needs. To enable the script on startup you should use your distro specific tools for managing the rc scripts. On fedora that means you will have to do chkconfig trac on. On Ubuntu you should do update-rc.d trac defaults.

I hope you will find the script useful. If you have any comments or suggestions regarding the script please comment.

UPDATE (13/10/2008):
Here is an version of the script for download.
UPDATE (17/2/2009):
See Starting tracd without Root Privileges at Startup for a different way to start tracd that doesn't require root privileges.

Download

You can download the script from here: cssrtl.py.

Usage

Using the script is pretty simple. Just pass the name of the script to cssrtl.py and he will automatically translate it for you.

Example:
python cssrt.py main.css

You can use the -o flag to specify a different output file instead of overwriting the existing file.

If the CSS style for the body tag is missing a direction statement, you should add the -d flag to the list of command line arguments. This will cause the script to add one for you when translating the layout.

See python cssrtl.py --help for more information.

Limitations

While this script is pretty useful as it is, it still isn’t perfect. The major limitation, is that the script doesn’t automatically mirrors images used in the layout. So if your layout contains images you will need to flip them manually (however the script will position them in right place by automatically). Another limitation is that the script doesn’t alway handle correctly scripts with IE hacks, so it always good to keep a backup and manually check the result on IE.

Overall, despite some (minor) limitations, the script is very useful, and it helped me a lot when having to translate CSS layouts to RTL. I’ve successfully used it to translate Wordpress, Joomla, Druple and MediaWiki themes with minimal intervention on my side, thus saving a lot of my time. If you find the script useful, it will be nice of your to send a word. Also the script is released under the GPL so if you have any patches/improvements, please send them.

x =  a if condition else b

As you probably guessed a is assigned to x if condition evaluates to true and b is assigned otherwise. This is pretty much equivalent to the C conditional expressions. But as I said, this structure was only introduced in 2.5. Previous versions of Python are still widely deployed and in use, so how do you achieve the same thing in older version of Python?

To create a conditional expression in earlier versions of Python, we can utilize the tuple for the values and the tuple’s index for the condition. For example:

x = (b,a)[condition]

will yield the wanted result. x will be assigned a if condition is true and b otherwise. It works because Python treats the condition inside the index as 1 if condition is true, and as 0 if false.

This method provides very nice and clean alternative to the conditional expressions available in Python 2.5. However it does require some special attention in some cases.

Let’s say we want to assign x the value of f() if condition is true, and the value of g() otherwise. But we won’t to make sure that only the function that is assigned to x is ran, not both of them. In this case the intuitive way:

x = (g(),f())[condition]

will not be any good, because Python will generate first the tuple, and to so evaluate both f() and g(). To prevent it we will need to change a bit the order of things. Consider the following snippet:

x = ((g,f)[condition])()

It will do what we wanted because the conditional expression gives back the function itself first, so neither f() nor g() are evaluated. After the conditional expression returned then the selected function is called. While this method works it has some drawbacks. For example if f and g would require arguments, and this arguments would be different for each function, the above method couldn’t be utilized. However this is only a small drawback, and under this circumstances one can just go for regular if..else structure.

Overall the method described above, offers clean and simple alternative to the built in conditional expressions in Python 2.5, which is also compatible with previous versions.

Update: radio.py-0.4 is now available.

I like listening to music and radio while working, and fortunately there are numerous ways to do that. Unfortunately, most ways that allow you to listen to radio are very resource consuming/memory hogs (such as listening to streaming-media via web-browsers) or very unfriendly to users (listening via mplayer for example). So, I set out to find a way that will use as little system resources as possible while keeping it user-friendly. One other requirement that I had, that I will be able to do all that from the command-line, so it will work great with GNU Screen and won’t require an X server (if I work without one).

I used for some time mplayer for listening to radio. I had a file with a list of web-radio streams URLs which I would copy and pass to mplayer -playlist. This method answered two of the requirements (minimal resources and command-line interface), but wasn’t really user friendly. So, I wrote a little wrapper script in python around mplayer – radio.py. After quick installation (download and extract the tar archive and copy radio.py to somewhere in you PATH), radio.py will allow you to listen to stations easily, and it will also do couple more things for you.

To listen to a station just call radio.py with the station’s name, e.g. in the command-line enter radio.py BBC1 to listen for BBC radio channel 1. To view a list of know stations run radio.py --list. Currently there aren’t many stations (just stations I thought that are needed or I listen to). You can easily edit radio.py to add new stations (the script is documented and very clear). If you do so, please write a comment or email me so I will be able to add those stations to next release by default.

So, as you seen radio.py allows you to easily listen to radio, as easy as writing the station’s name. But, as I said, it can do more things that I thought should be in a radio script. It has both a sleep feature (that turns off the radio after specified amount of time) and a wake-up feature (that starts the radio after a specified amount of time). This two features can be used together, and practically allow you to use radio.py as an alarm clock.

You can find more information about radio.py options by calling radio.py --help. I hope you will find this script useful as I do.

Download:
radio-0.3.tar.gz.

#!/usr/bin/python
 
"""
packsource.py
 
Version: 1.0
 
This script takes a tar.gz source archive created by KDevelop and turns
it into a source package, which the will be able just to use
./configure ; make ; make install
to build (instead of using autotools).
 
Synopsis:
        python packsource.py SomeProject-1.4.tar.gz
 
The SomeProject-1.4.tar.gz will be overwritten with a new tar containg
the source package.
 
"""
 
###########################################################################
 #   Copyright (C) 2007 by Guy Rutenberg                                   #
 #   guyrutenberg@gmail.com                                                #
 #                                                                         #
 #   This program is free software; you can redistribute it and/or modify  #
 #   it under the terms of the GNU General Public License as published by  #
 #   the Free Software Foundation; either version 2 of the License, or     #
 #   (at your option) any later version.                                   #
 #                                                                         #
 #   This program is distributed in the hope that it will be useful,       #
 #   but WITHOUT ANY WARRANTY; without even the implied warranty of        #
 #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         #
 #   GNU General Public License for more details.                          #
 #                                                                         #
 #   You should have received a copy of the GNU General Public License     #
 #   along with this program; if not, write to the                         #
 #   Free Software Foundation, Inc.,                                       #
 #   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             #
############################################################################
 
import os,sys,shutil,tempfile
 
tempdir = tempfile.mkdtemp()
 
print "Extracting source archive..."
args=['tar', '-zxf', sys.argv[1], '-C', tempdir]
os.spawnvp(os.P_WAIT, args[0], args)
print "Source archive extracted"
 
origpwd = os.getcwd()
 
dirlist = os.listdir(tempdir)
os.chdir(tempdir + "/" + dirlist[0])
 
args=['aclocal'];
print "Running", " ".join(args)
os.spawnvp(os.P_WAIT, args[0], args)
 
args=['autoheader'];
print "Running", " ".join(args)
os.spawnvp(os.P_WAIT, args[0], args)
 
args=['libtoolize', '--copy', '--force', '--automake']
print "Running", " ".join(args);
os.spawnvp(os.P_WAIT, args[0], args)
 
args=['automake', '-a', '-c']
print "Running", " ".join(args);
os.spawnvp(os.P_WAIT, args[0], args)
 
args=['autoconf'];
print "Running", " ".join(args)
os.spawnvp(os.P_WAIT, args[0], args)
 
print "Removing automake cache files"
shutil.rmtree('autom4te.cache/')
 
os.chdir('..')
 
print "Building source package"
 
args=['tar', '-zcf', os.path.split(sys.argv[1])[1], dirlist[0]]
os.spawnvp(os.P_WAIT, args[0], args)
 
shutil.copy(os.path.split(sys.argv[1])[1], origpwd)
 
os.chdir(origpwd)
 
print "Clearing up..."
shutil.rmtree(tempdir)
print "Done"

To use the script just call it and pass the source archive filename to the script as an argument. The script takes the source archive and overwrites it as a source package which will be easy for users to install.

Update (16/9/2007)

Removed an unneeded module dependency.