I updated my SoundSwitch Application.
You can install it by going here.

The purpose of SoundSwitch is to be able to easily switch between  2 or more Audio output devices.
For example, I have a wireless headset and my regular speakers.
Both are detected as a separate audio card in the sound panel.
The only way to switch between them is to open the playback devices panel and select one of them and choose to put it as default device.

That’s such a hassle!
With SoundSwitch you just press Ctrl+Alt+F11 and it toggles between the cards you selected.

Todos:

1. Let the application start up when the user logs in. (currently you have to start it yourself)
2. Allow users to set their own shortcut (instead of  Ctrl+Alt+F11)
3. Make the configuration easier. (Won’t be possible I’m afraid though)

UPDATE:
Changed the hosting to CodePlex, apparently you can host ClickOnce applications there!

$.fn.scrollTo = function(duration){
    if(duration == null){
        duration = 1000;
    }
 
    var offset = $(this).offset().top - $(window).height()/2 + $(this).height();
    $('html,body').animate({
       scrollTop: offset
    }, duration);
}

This small plugin will scroll to a selected element when calling .scrollTo() on it.
It has an optional parameter which specifies the duration of the scroll.

For example, if i would have a div with the id “#mydiv” I would let the screen scroll to it using this code:

$('#mydiv').scrollTo();
 
//Or, if you want the animation to be slower
$('#mydiv').scrollTo(2000);

The top of the selected element will be displayed at 50% of the screen unless the scrollbar is too short, then the element will be lower on the screen.

I also have to keep track of what’s in my fridge and what’s expiring when.
I suck at that.
However, I’m good with computers. And computers are good at keeping track of stuff.
So I created a small tool to do just that, Fridgemon.

I know it’s butt-ugly but it does it’s job.

Textbooks

Full fledged learning tools containing a textbook explaining grammar and spelling rules, audio tapes for pronunciation and often also workbooks to apply the acquired knowledge.

Pimsleur Norwegian

30 audio lessons of 30 minutes each. I started learning with this. After each lesson of Pimsleur’s completed I could clearly notice that I had learned something. The rate at which I learned stuff using Pimsleur is very high. Unfortunately Pimsleur Norwegian has only 1 level of lessons, compared to 2 or 3 levels for larger languages like French or Chinese. If I had to suggest a starting point to learning Norwegian, this would be it. Pimsleur Norwegian website

Ny I Norge & Bo I Norge

Ny I Norge contains a textbook, audio readings of the conversations in the textbook, a workbook and listening comprehension exercises. Bo I Norge is a textbook for more advanced learners (after Ny I Norge). This will be the second resource I’ll be using, after Pimsleur.

Colloquial Norwegian

Similar to Ny I Norge, consists of a textbook with exercises and audio readings. I do have the impression that the learning curve of the book is higher.

På vei, Stein På Stein, Her på berget

All three books consist of a textbook, a workbook and audio files. They consist of three levels of which På vei is the 1st, Stein På Stein the second and finally Her på berget the third. Each of the books have free exercises online. (På vei, Stein På Stein, Her på berget)

Praktisk Norsk I & II

From the same series as På vei etc. Also has free exercises online here and here.

Teach Yourself Norwegian

A book with conversations both in English and in Norwegian. Seems to rely heavily of cross referencing the dialogues in both languages. Also contains audio recordings for the conversations.

Sett i gang I & II

A textbook, workbook and audio files. The audio files are freely downloadable here and here.

My Little Norway

A blog about 2 people in Norway, one native speaker and one who’s learning Norwegian. They also have a bunch of lessons on the blog for learning Norwegian.

Assimil (for German or French speakers)

Norwegisch ohne Mühe (For German speakers) | Assimil site Le Norvegien sans Peine(For French speakers)

Television

NRK

NRK is the Norwegian national broadcaster. A lot of the programs are visible freely (Click A-Å on the top and choose a starting letter of a program). For example, the newsis something that is updated daily.

NRK Torrents

NRK also offers some HD torrents of their programs. These don’t get updated very often I’ve noticed.

TV3

TV3 broadcasts more foreign (to Norway) programs which are more limited by drm. But those are most likely not the programs you want to watch anyways cause they are in different languages :) Watch out, they also have some Swedish programs.

TVNorge (NOT FREE)

TV2 (SEMI-FREE)

Only short clips of programs are free, full programs require a subscription.

Radio

• Radio Norge
• NRK P1 – Click the small red round button with the play icon to the right
• NRK P2 – Click the small red round button with the play icon to the right
• NRK Petre (P3)
• NRK Alltid nyheter (always news) – Click “Nettradio” in the left bar.
• NRK Klassisk
• P4 Radio Hele Norge – Click “lytt nå”
• All NRK Radio channels
• A huge list of other norwegian radio channels

Extra resources

Anki flashcards

Anki is a program to exercise flashcards using spaced repetition. I use this to exercise vocabulary. The great thing about Anki is that you can also add audio files to your flashcards, so you can train pronunciation and spelling in one go. I don’t like having to record every word manually, so I made this site to automatically generate sound files for words you type in. Here is a list of the 1000 most used Norwegian words to get you started. Be sure to use Bokmål (see below).

News in “Simple Norwegian”

Klar Taleis a news website written in simple Norwegian. If you use their website together with a browser plugin which can translate (unknown) words you select then this is another good way of learning.

Lessons on Youtube

Crienexzyon Youtube has a bunch of videos on Norwegian pronunciation. She’s also a fine example of Scandinavian beauty.

Films

A great way to passively (but slowly) learn is by watching movies and series. Some Norwegian films I liked were:

• Vegas
• Trolljegeren
• Død snø
• Fritt Vilt I, II, III

A big list of Norwegian films can be found on IMDB.

Livemocha

Livemocha uses the same teaching style as Rosetta Stone. I’m not particularly fond of this way of learning, I learned a bunch more by just a few lessons of Pimsleur. However, it’s a great way to find native speaking partners.

Interpals

A site aimed at bringing penpals together. Has quite a large user base.

Linguistic tools & sound files of Norwegian dialects

This site contains a tool to break down sentence structure and some sound files of texts in various Norwegian dialects. I think it should be accessible  through this site as well, but that one seems to have some database problems atm. Books about norwegian dialects can be found here.

Free music

Gatas Parlament is a Norwegian rap group and they offer their music for free on their website.

More info

This sitehas a bunch of links to Norwegian related things.

Bokmål & Nynorsk

Norwegian has 2 written forms, Bokmål and Nynorsk. Unlike what Nynorsk’s (new-Norwegian) name seems to suggest it is actually older than Bokmål. The grand majority of (newly) written material is in Bokmål, so you’ll have the most use of learning Bokmål. As far as I know, all textbooks listed above use Bokmål.

Get started

I found a torrent which contains a lot of the resources mentioned above. Credit where credit is due: a lot of the resources mentioned here came from this post on reddit. Update Found a site with good explanations on grammar rules. And a site which will show you ALL conjugations of a given verb! Super useful.

Bulktts allows you to choose a language, paste your list of words in and download a zip file with the mp3′s.

There are still some bugs though, at the moment words with special characters won’t product the correct sound.
Update: Sound bug fixed. Only the filenames for special character words in zip files are still not correct.

After a bit of googling around I came to this StackOverflow answer.
That worked like a charm, and here is my more reusable version:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

from zipfile import ZipFile
from StringIO import StringIO
 
class InMemoryZipFile(object):
	def __init__(self):
		self.inMemoryOutputFile = StringIO()
 
	def write(self, inzipfilename, data):
		zip = ZipFile(self.inMemoryOutputFile, 'a')
		zip.writestr(inzipfilename, data)
		zip.close()
 
	def read(self):
		self.inMemoryOutputFile.seek(0)
		return self.inMemoryOutputFile.getvalue()
 
	def writetofile(self, filename):
		open('out.zip', 'wb').write(self.read())

Save as “inmemoryzip.py” and import it as “inmemoryzip”.
This is quite limited compared to the standard ZipFile class, but this gets the job done for what I needed it.

You start with a population of begin states and each state has a ‘fitness’ which indicates how close it is to a solution.
Based on that fitness you will crossjoin or mate 2 states. Higher fitness = higher chance of mating.

I implemented the example given in my AI course’s slides in python.
The example is trying to find a solution to solve an n-queens problem, in this case 8 queens on an 8×8 chessboard.
Briefly explained: you need to place 8 queens on a chessboard so that none of the queens can attack eachother.
(A queen can move like a Bishop and a Tower, horizontally and diagonally)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

from __future__ import division
from random import Random, random
 
class State(object):
	MUTATION_RATE = 0.03
	def __init__(self, parents=None):
		r = Random()
		self._fitness = None
		self._probability = None
		if parents==None:
			self.state = [r.randint(1,8) for y in range(8)]
		else:
			parent1 = parents[0]
			parent2 = parents[1]
			self.state = self.crossover(parent1, parent2)
			self.mutate()
 
	def fitness(self):
		if not self._fitness:
			state = self.state
			horizontal_collisions = sum([state.count(col)-1 for col in state])/2
 
			diagonal_collisions = 0
			for i, col in enumerate(state):
				for j, diagonal in enumerate(state):
					mod = abs(i-j)
					if mod > 0: #we don't want to count the current queen in a collision with herself
						if diagonal + mod == col or diagonal - mod == col:
							diagonal_collisions += 1
			diagonal_collisions /= 2 #we were counting the diagonal collisions double
			self._fitness = int(28 - (horizontal_collisions + diagonal_collisions))
		return self._fitness
 
	def probability(self, population):
		if not self._probability:
			self._probability = self.fitness() / sum([x.fitness() for x in population])
		return self._probability
 
	def crossover(self, parent1, parent2):
		r = Random()
		crossover_index = r.randint(0,8)
		left = parent1.state[0:crossover_index]
		right = parent2.state[crossover_index:8]
		left.extend(right)
		return left
 
	def mutate(self):
		r = Random()
		for i in range(len(self.state)):
			if random() < State.MUTATION_RATE:
				self.state[i] = r.randint(1,8)
 
	def __str__(self):
		r = ''
		r += '   '
		for i in range(8):
			r += '%d ' % (i+1)
		r += '\n  ' + '--'*8 + '\n'
 
		for i in range(8,0,-1):
			r += '%d|' % i
			for j, queen in enumerate(self.state):
				if queen == i:
					r += ' O'
				else:
					r += '  '
			r += '|\n'
		r += '  ' + '--'*8 + '\n'
		print self.fitness()
		return r
 
def pickRandomByProbability(populationByProbability):
	i = 0
	selectedState = None
	while selectedState == None:
		current = populationByProbability[i]
		if current[0] <= random():
 			return current[1]
 		if i+1 >= len(populationByProbability):
			i = 0
		else:
			i += 1
 
def generateNextPopulation(population, n):
	newPopulation = []
	while len(newPopulation) < n:
 		populationByProbability = [(x.probability(population), x) for x in population]
 		parent1 = pickRandomByProbability(populationByProbability)
 		populationByProbability = [x for x in populationByProbability if x[1] != parent1]
 		parent2 = pickRandomByProbability(populationByProbability)
 		newPopulation.append(State((parent1, parent2)))
 	return newPopulation
 
if __name__ == '__main__':
 	populationSize = 100
 	generation = 1
 	population = [State() for x in range(populationSize)]
 	while not 28 in [x.fitness() for x in population]:
 		print "generation %d\tMax fitness: %d" % (generation, max([x.fitness() for x in population]))
 		population = generateNextPopulation(population, populationSize)
 		generation += 1
 	for x in population:
 		if x.fitness() >= 28:
			print x

State

The State class keeps track of a state. In this case that is a list of 8 integers ranging from 1 to 8.
Each integer represents the position of a queen in a column (which row).
Since queens can attack vertically each queen has to be in a different column by default.

Fitness

A collision is two queens who are able to attack each other. This means they are in the same diagonal, the same row or the same column.
The maximum amount of collisions that can occur is 28. The fitness function is a higher-is-better function, so we calculate it by substracting the amount of collisions that occur in the current state from 28.
A solution would have 0 collisions and thus a fitness of 28.

Probability of mating

When we generate the next population of states we will need to have something on which we can base which 2 states can ‘mate’.
We want only the best states (the one closest to a solution) to mate, so the best heuristic to define the chance of a state being allowed to mate is it’s fitness.

Crossover (mating), mutation

When we crossover 2 states we choose a point in the states where we will ‘chop’ them in 2 parts.
We will for example take the left 3 columns of the 1st parent and the 5 last of the second parent.
The child state is then the combination of these columns.
We don’t want to stay stuck in the same state pool because what if the initially randomly generated population has no queen in row 3?
We would never be able to get a solution because a solution requires a queen in each row.
No matter how many times we crossover 2 states, we will never get a state in row 3.
Therefore we need to include a random mutation when crossing over 2 parents.
Each column in the child state has a specific percentage chance of changing it’s value to a random number from 1 to 8.

Conclusion

I’ve noticed that this doesn’t find a solution as fast as I initially expected. It can quickly take over a few (ten)thousand generations before a solution is found.
I haven’t noticed any noticeable speed increase in finding a solution when taking a population of 100, 1000 or 10000. (Didn’t do any benchmarks, just a few runs per population size)
Maybe a solution would be found more quickly if the percentage chance of mating weren’t on a linear scale but an exponential one.
I’m not sure if i’m expressing this correctly but what I mean is that the chance of mating for bad fitnesses and good ones is currently too close. Good ones should be picked way easier than bad ones. Now the chance differs only by a few percent or even a few tenths of a percent depending on the size of the population.

Setting some settings

First of all, set your application id to whatever you called your application in the GAE dashboard.
Open up app.yaml in the root folder and change what’s behind “application: “.
This isn’t a requirement to be able to develop for GAE, but if you want to deploy your app this will need to be set.

Open up settings.py. If you want to use sessions in your application you’ll need to uncomment “django.contrib.sessions.middleware.SessionMiddleware” in MIDDLEWARE_CLASSES near the end of the file.

If you’re planning on using GAE’s memcache you’ll need to add the following lines to MIDDLEWARE_CLASSES:

'django.middleware.cache.UpdateCacheMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.cache.FetchFromCacheMiddleware',

And you’ll need to set these variables as well:

CACHE_BACKEND = 'memcached://?timeout=0'
CACHE_MIDDLEWARE_SECONDS = 0

CACHE_MIDDLEWARE_SECONDS sets the default caching time in seconds for each page. Since I don’t want every page to be cached by default I’ve set this value to 0.
Note that the setting of the cache info is different in Django 1.3. (I’m using 1.2.4 here)

Then at the bottom in INSTALLED_APPS add a line with the name of the app we’ll be creating.
In the tutorial they’re using the name “polls”, so that’s what i’ll call it as well.

This is how my settings file looks now.
And that’s all the settings that we need to set. The database (Google’s BigTable) settings have already been taken care of by the helper.

Creating the application and creating models

Open a command prompt and cd to where manage.py is situated. (in the root folder of the project)
Type “python manage.py startapp polls”. or replace polls by whatever name you set in INSTALLED_APPS.

The models we’ll be creating won’t extend from the standard Django base model but instead will use the base class provided by the helper. This is an edited version of the Django base model class that is compatible with the GAE datastore.

models.py:

1
2
3
4
5
6
7
8
9
10
11

from appengine_django.models import BaseModel
from google.appengine.ext import db
 
class Poll(BaseModel):
    question = db.StringProperty()
    pubDate = db.DateTimeProperty()
 
class Choice(BaseModel):
    pollId = db.IntegerProperty()
    choice = db.StringProperty()
    votes = db.IntegerProperty()

Notice that there are no foreign keys, this is because GAE is a non-relational data store. Foreign keys don’t exist.

Views and templates

We’ll need 3 pages:

1. Create  a poll
2. List existing polls
3. View a specific poll and be able to vote on one of it’s choices

My urls.py file is as follows:

1
2
3
4
5
6
7

from django.conf.urls.defaults import *
 
urlpatterns = patterns('',
	(r'^$', r'polls.views.list'),
	(r'^create$', r'polls.views.create'),
	(r'^view/(\d+)$', r'polls.views.view'),
)

The views:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

from django.shortcuts import render_to_response
from django.http import HttpResponse, HttpResponseRedirect
from polls.models import Poll, Choice
from datetime import datetime
 
def create(request):
	if request.POST:
		question = request.POST["question"]
		c1 = request.POST["choice1"]
		c2 = request.POST["choice2"]
		c3 = request.POST["choice3"]
 
		poll = Poll(question=question, pubDate=datetime.now())
		poll.save()
		choice1 = Choice(pollId=poll.key().id(), choice=c1, votes=0)
		choice2 = Choice(pollId=poll.key().id(), choice=c2, votes=0)
		choice3 = Choice(pollId=poll.key().id(), choice=c3, votes=0)
		choice1.save()
		choice2.save()
		choice3.save()
		return HttpResponseRedirect('/')
	else:
		return render_to_response('create.html')
 
def list(request):
	polls = Poll.objects.all()
	return render_to_response('list.html', {'polls':polls})
 
def view(request, id):
	if request.POST:
		choiceId = int(request.POST["voteChoice"])
		choice = Choice.get_by_id(choiceId)
		choice.votes += 1
		choice.save()
	id = int(id)
	poll = Poll.get_by_id(id)
	choices = Choice.objects.all().filter('pollId =', id)
	return render_to_response('view.html', {'poll':poll, 'choices':choices})

The templates:

list.html

1
2
3
4
5
6
7
8

<ul>
 {% for poll in polls %}
 <li>
 <a href="/view/{{poll.key.id}}">{{poll.question}}</a> - {{poll.pubDate}}
 </li>
 {% endfor %}
</ul>
<a href="/create">Create new poll</a>

view.html

1
2
3
4
5
6
7
8
9
10
11
12
13

<h1>{{poll.question}}</h1>
 
<form action="/view/{{poll.key.id}}" method="post">
 <ul>
 {% for choice in choices %}
 <li>
 <input name="voteChoice" type="radio" value="{{choice.key.id}}">
 {{choice.choice}} ({{choice.votes}} votes)
 </li>
 {% endfor %}
 </ul>
 <input type="submit" value="Vote" />
</form>

create.html

1
2
3
4
5
6
7
8
9
10
11

<h1>Create poll</h1>
 
<form action="/create" method="post">
 Question: <input type="text" name="question" /><br>
 
 Choice 1: <input type="text" name="choice1" /><br>
 Choice 2: <input type="text" name="choice2" /><br>
 Choice 3: <input type="text" name="choice3" /><br>
 
 <input type="submit" value="Create" />
</form>

I think everything is quite clear when you look it over.
There are a few differences with regular Django code, for example the filter line.

A zip file with the files of the project can be found here.

Update:  You might also be interested in checking out Django-nonrel which is a different way of running Django on GAE. It seems to be more flexible at first glance than the helper but I can’t say for sure since I haven’t used it yet.

As I was studying I naturally got bored of it, so I looked for more interesting things to do – Learn something else :D
I already looked for information about setting Django up on GAE (Google App Engine) but only found information scattered on different websites/blogs/.. but I finally managed to figure it out.

This post should serve as a single list of instructions to follow how to get Django running on GAE.

Requirements

You’ll need to download a few files which we’ll need.

1. The App Engine SDK for Python. (1.4.1 atm)
2. Your Django version of choice. I’m using 1.2.4 here but it should work with everything >= 1.0.
3. The App Engine Helper for Django. (r109 atm)

Extract the App Engine Helper for Django somewhere.
The folder is called “appengine_helper_for_django” here and contains the following important files:

• appengine_django/
• app.yaml
• main.py
• manage.py
• settings.py
• urls.py
• other information files.

Most of these files have been altered so that Django can easily be run on Google App Engine.
But because Google App Engine is a quite restricted platform, not all features of Django will work out of the box, or at all.
One example is the Django admin module, this one is not supported.

Getting it to work

Now extract the Django sources somewhere else.
Go to where the setup.py file is within the folder you just extracted.
On the same level there should be a folder called “django”, copy this folder and paste it in the App Engine Helper folder we were in earlier.
You should now have 2 folders in the helper’s folder, “appengine_django” and “django”.

The django folder we just copied will define which version you’ll be running on GAE.
In my case, I downloaded Django 1.2.4, so I’ll be using that version on GAE.

Now we can try running this setup.
Start up the GAE Launcher and choose file > add existing application.
Select the helper’s folder (where app.yaml is situated) and choose Add.
Click run and click Browse after it’s done booting.
You should now be able to see the Django welcome screen.

If you have your application if set correctly in the  app.yaml file you could just press deploy and this is what you’d be seeing on http://[your-appname].appspot.com

The next post will handle the actual creating of a small app in Django.
There are a few small and larger differences you need to take in to account.

Idiomatic Python?

I quickly (re)discovered a page dedicated to giving aspiring Pythonistas guidelines to writing correct python code.
Especially The Zen of Python describes more generally how to write correct Python code (not at statement level, but application/class level – more general).
The first time I discovered ‘Code like a Pythonista’ I guess the only thing I did was skim the statement level tips.

What Davy’s asking is more of the general kind I think though.

My attempt

class Event(object):
	def __init__(self):
		self.__handlers = []

	def subscribe(self, handler):
		self.__handlers.append(handler)

	def unsubscribe(self, handler):
		self.__handlers.remove(handler)

	def __call__(self, *args):
		for handler in self.__handlers:
			handler(*args)

class Publisher(object):
	def __init__(self):
		self.notify = Event()

	def trigger_notify(self):
		self.notify("A", "B")

class Subscriber(object):
	def start_listening_to(self, publisher):
		self.__publisher = publisher
		self.__publisher.notify.subscribe(self.event_handler)

	def stop_listening(self):
		self.__publisher.notify.unsubscribe(self.event_handler)
		self.__publisher = None

	def event_handler(self, param1, param2):
		print "RECEIVED: param1: %s, param2: %s" % (param1, param2)

publisher = Publisher()
subscriber1 = Subscriber()
subscriber2 = Subscriber()
subscriber1.start_listening_to(publisher)
subscriber2.start_listening_to(publisher)
publisher.trigger_notify()
subscriber1.stop_listening()
publisher.trigger_notify()

I removed the alteration of the object base class. It didn’t seem like the right thing to do, modifying an existing class.
Now the setting of an event attribute is a lot simpler, just say that attribute x is an event.

I liked the way of adding and removing events by using the += and -= operators, but it didn’t seem very intuitive to me and I’ve never seen them be used like that in Python so I changed it to regular methods.

The way arguments are passed to the handlers also changed, I used to pass an array of arguments when calling the event.
Now I just pass arguments like you would with any other function. Way more intuitive.

When subscribing I also don’t check whether the handler is callable anymore.
When triggering the event you’ll get an appropriate error message if the handler is in fact not callable.
The same happens when you pass a handler which has the incorrect amount of parameters.

Checking with more experienced people

After I modified the code I posted a thread on #python and on /r/python asking for some tips on further improving this code.

First of all, this (events) apparently already exists in twisted, so when using it in a real project it might be better checking that out first.

I was told not to use __ to indicate attributes as private. It’s a misnomer and shows you’re still green behind the ears. A regular underscore is enough to indicate that an attribute should not be touched. I looked around and found this Stackoverflow answer which explains it quite nicely.

It was also suggested to use  *args, **kwargs instead of just *args so I can trigger the event with keyword arguments.
I assumed *args would handle both named and unnamed. But that’s why I asked for tips, learn something new every day :)

Another thing that was suggested is to use a set or a dictionary for storing the handlers. It is apparently faster to remove handlers then and also makes sense since this way you can’t subscribe the same subscriber’s handler twice to the event.

Implementing the tips

#/usr/bin/python

class Event(object):
	def __init__(self):
		self._handlers = set()

	def subscribe(self, handler):
		self._handlers.add(handler)

	def unsubscribe(self, handler):
		self._handlers.remove(handler)

	def __call__(self, *args, **kwargs):
		for handler in self._handlers:
			handler(*args, **kwargs)

class Publisher(object):
	def __init__(self):
		self.notify = Event()

	def trigger_notify(self):
		self.notify("A", param2="B", param4="C")

class Subscriber(object):
	def start_listening_to(self, publisher):
		self._publisher = publisher
		self._publisher.notify.subscribe(self.event_handler)

	def stop_listening(self):
		self._publisher.notify.unsubscribe(self.event_handler)
		self._publisher = None

	def event_handler(self, param1, param2=None, param3=None, param4=None):
		print "RECEIVED: param1: %s, param2: %s, param3: %s, param4: %s" % (param1, param2, param3, param4)

publisher = Publisher()
subscriber1 = Subscriber()
subscriber2 = Subscriber()
subscriber1.start_listening_to(publisher)
subscriber2.start_listening_to(publisher)
publisher.trigger_notify()
subscriber1.stop_listening()
publisher.trigger_notify()

[run the code]

The code looks a lot cleaner and easier to use than what I started out with imo.