Technomancy

Conduit is a syncronization programme for Gnome. It’s still a work in progress

I’ve added one-way Gmail contacts support. You can now use gmail contacts as an data source, i.e. you can download all your gmail contacts into a folder. I have also improved the Contact -> vCard file convertor, the file name is now more human understandable.

I’ve made some patches. They should work against svn revision 838, which is the current head of the svn trunk.

Download the patches here:

• conduit-add-gmail-contacts-as-data-source.patch
• conduit-improve-contact-to-file-conversion.patch

As I said before, you can permantly hide join and parts globally in XChat. Sometimes you want to show join/parts on some channels but not for others. This plugin allows you to specify some channels that you want to always show join/parts on, and some to never show join/parts. This will override the global settings.

Change the options at the start of the file and save as ~/.xchat2/customjoinparts.py

This version will always show join/parts on #python, and never on #xchat.

__module_name__ = "CustomJoinPart"
__module_version__ = "1.0"
__module_description__ = "Automatically show join parts on a per channel basis"

show_join_parts = [
    [ 'FreeNode', '#python' ],
]

hide_join_parts = [
   [ 'FreeNode', '#xchat'],
]

import xchat

def channel_joined(word, word_eol, userdata):
    global show_join_parts, hide_join_parts

    curr_channel = xchat.get_info("channel")
    curr_network = xchat.get_info("network")
    for network, channel in show_join_parts:
        if curr_network == network and curr_channel == channel:
            # this is the a channel we are to show join parts
            xchat.command("CHANOPT CONFMODE OFF")
            print "Showing Join/Parts in this channel"
    for network, channel in hide_join_parts:
        if curr_channel == network and curr_channel == channel:
            xchat.command("CHANOPT CONFMODE ON")
            print "Hiding all Join/Parts in this channel"

    # Don't eat this event, let other plugins and xchat see it too
    return xchat.EAT_NONE 

xchat.hook_print( "You Join", channel_joined )

print __module_name__ + " version " + __module_version__ + " loaded"

Sometimes you want to monitor a low activity channel while doing something else. This plugin uses GNOME’s notifications to show you a notification of each message in the channel.

Save this as watch.py and put it in ~/.xchat2/

# Copyright 2007 Rory McCann
# Released under the GNU GPL v3 or later

# Configuration options go here

notification_title = "Message in %(channel)s"
notification_text = "<%(nick)s> %(message)s"

# End of configuration options.

__module_name__ = "WatchChannel"
__module_version__ = "1.0"
__module_description__ = "Watches a channel for new messages"

import xchat, pynotify

# This is empty at the start obviously, but it will contain network name and
# then channel name tuples.
channels_to_watch = set()

def watch_channel(word, word_eol, userdata):
	global channels_to_watch
	channels_to_watch.add((xchat.get_info("network"), xchat.get_info("channel")))
	xchat.prnt("You are now watching %s. You are now watching a total of %d channels" % (xchat.get_info("channel"), len(channels_to_watch)) )
	return xchat.EAT_ALL

def unwatch_channel(word, word_eol, userdata):
	global channels_to_watch
	tuple = (xchat.get_info("network"), xchat.get_info("channel"))
	if tuple in channels_to_watch:
		channels_to_watch.remove(tuple)
		xchat.prnt("You are no longer watching %s" % (xchat.get_info("channel")))
	return xchat.EAT_ALL

def message_recieved(word, word_eol, userdata):
	global channels_to_watch, notification_title, notification_text
	#print "channels to watch:", str(channels_to_watch)
	network, channel = xchat.get_info("network"), xchat.get_info("channel")
	nick, message = word[0], word[1]
	if nick[0:2] == 'x032':
		# Occasionally there are 3 characters at the front, this will remove them. I don't know why they are there.
		nick = nick[3:]
	details = {'channel':channel, 'message':message, 'nick':nick}
	if (network,channel) in channels_to_watch:
		n = pynotify.Notification(notification_title % details, notification_text % details, "file:///usr/share/pixmaps/xchat.png")
		n.show()

	return xchat.EAT_NONE

pynotify.init("Channel watcher")

xchat.hook_command("watch", watch_channel)
xchat.hook_command("unwatch", unwatch_channel)

xchat.hook_print("Your Message", message_recieved)
xchat.hook_print("Channel Message", message_recieved)

print __module_name__ + " version " + __module_version__ + " loaded"

Trackpads on laptops are annoying if you’re using a mouse. While typing, you can accidentally tap it, causing the cursor to move.

Change your /etc/X11/xorg.conf file so the Synaptics Touchpad input device section looks like this:

Section "InputDevice"
	Identifier	"Synaptics Touchpad"
	Driver		"synaptics"
	Option		"SendCoreEvents"	"true"
	Option		"Device"		"/dev/psaux"
	Option		"Protocol"		"auto-dev"
	Option		"HorizScrollDelta"	"0"
    Option          "SHMConfig"
EndSection

The important line is the

    Option          "SHMConfig"

line.

After restarting X, you can disable the touchpad with this command:

synclient TouchpadOff=1

It can be enabled with

synclient TouchpadOff=0

Mac OSX disabled the touch pad when you plug a mouse in. GNOME should do this. There is an open bug about it.

The following python programme will detect when a mouse is plugged in (using HAL/Dbus) and disable the touchpad using the above command when a mouse is plugged in. If you plug in more than one mouse, crazy things might happen. You’ll need the python dbus package. Dump this somewhere, make it executable and add it to your start up programmes.

#! /usr/bin/python

import os

import dbus, gobject
from dbus.mainloop.glib import DBusGMainLoop

DBusGMainLoop(set_as_default=True)

system_bus = dbus.SystemBus()

def device_removed(device_name):
    global hal, initial_mice
    mice = hal.FindDeviceByCapability("input.mouse")
    # mice won't include the device that was removed, so we need to check
    # initial_mice
    if device_name in mice or device_name in initial_mice:
        enable_trackpad()

def device_added(device_name):
    global hal, initial_mice
    mice = hal.FindDeviceByCapability("input.mouse")
    if device_name in mice or device_name in initial_mice:
        disable_trackpad()

def enable_trackpad():
    os.system("synclient TouchpadOff=0")

def disable_trackpad():
    os.system("synclient TouchpadOff=1")

system_bus.add_signal_receiver(
    handler_function=device_removed,
    signal_name="DeviceRemoved",
    path="/org/freedesktop/Hal/Manager",
    dbus_interface="org.freedesktop.Hal.Manager" )

system_bus.add_signal_receiver(
    handler_function=device_added,
    signal_name="DeviceAdded",
    path="/org/freedesktop/Hal/Manager",
    dbus_interface="org.freedesktop.Hal.Manager" )

hal = system_bus.get_object('org.freedesktop.Hal', '/org/freedesktop/Hal/Manager')

initial_mice = hal.FindDeviceByCapability("input.mouse")

# see how many mice we have when we start up.
if len(initial_mice) == 1:
    # only one possible mouse so it's the trackpad.
    enable_trackpad()
else:
    disable_trackpad()

loop = gobject.MainLoop()
loop.run()

When one is programming, the humble print statement is used frequently for debugging purposes. I’ve written a python module debug_print_statements that provides some simple functions to print helpful information. It uses some pretty cool introspective python stuff.

Download the latest version here (v0.1)

print_line_number()

Calling this function will print the file and line number of where that function is in the file. It will figure out by itself what the line number is. Printing the line number is helpful to see if a piece of code gets executed, but as you add or remove lines from a file, this number can change, which makes it hard to go back to that place in the file.

print_local_variables()

When you call this, all the local variables will be printed (along with their names)

renick is a Python plugin script for the XChat IRC client for automating

Many IRC networks (such as FreeNode) have a NickServ to allow people to register nicks. However if you get disconnected you will leave behind a ‘ghost’, and you’ll need to reidentify. This script makes that easy. If it happens, just run “/renick” and the ghost will be killed,your nick changed and you’ll be reidentified. See the top of the file for documentation on how to specify the nicks.

Just put this file in the ~/.xchat2/ directory and it’ll be automatically loaded when XChat starts. If you are disconnected, just enter “/renick”

nf is a simple command line script that reads in text from stdin, looks for any decimal numbers and replaces them with the thousands separated version of that number and prints it back to stdout

Many commands will print numbers & text (eg wc -l) which can be sorted using sort, but it’s hard to see how big 345768782 is. 345,768,782 is much easier to read. Some commands (eg du -hs) will print human readable units (eg MB, GB), but they cannot then be sorted.

Some examples:

cd ~/music/
du -h | sort -n | nf

I was playing around with an ipod plugin for Quod Libet and accidently copied many track many times to my iPod, so I wound up with about 3 copies of every Lordi song, for example.

Based on the I wrote a quick script using libgpod and it’s python bindings to remove all the duplicate tracks from my ipod. Just mount the iPod, change the “mount_point” line to specify where the ipod is mounted, and run the programme. It’ll print out a line for every dupe it finds.

I was suprised at how easy it was to use libgpod. This programme only took 40 lines. gpod is nice.

Sometimes when you’re running a python programme (especially a GUI programme) it’d be nice to be able to drop into an interactive console and have a poke around the state of the programme at that point. This code will do it:

import code
code.interact(local=locals())

Just put that into the point (or points) of your programme where you’d like to drop to an interactive console, and run your programme. When you get to that point, it’ll switch to an interactive console with all the local variables in the current scope.

It’s stuff like this that makes python development so nice.

I recently imported some music into Rhythmbox and found out that Rhythbox doesn’t/can’t move all your music into your central music library (which I’ve set to “~/music”), I don’t want to delete all the songs I’ve added, move them all to the correct folder hierarchy and then reimport all the songs. Secondly doing all that would lose all metadata (like play count) about the various songs.

So instead I wrote a python script, rbcentralize.py, that will scan your rhythmbox library (ie ~/.gnome2/rhythmbox/rhythmdb.xml) and look for any mp3s or m4as outside out ~/music. It creates the correct Artist/Album folder and make a hard link in there to the original music file. It then changes the location field in the Rhythmbox library file.

Some of the configuration (ie location of ~/music) can be changed by editing the script. Don’t run this script when rhythmbox is running, as rhythmbox modifies the library file while running, actually this script checks if rhythmbox is running and won’t run. I recommend backing up ~/.gnome2/rhythmbox/rhythmdb.xml before running this script, just in case.