Skip to main content

C#-like Events in Python

I've been experimenting with Python recently for a few different reasons:

  1. It's fun to learn new things
  2. I'm planning to build a site for a friend on top of Django and Wagtail
  3. I have some ideas for Kodi Addons

I had the need to implement an observer pattern for decoupled publish/subscribe messaging between independent Python modules. C# has this built in to the language with events. I found this Stack Overflow post where user Jason Orendorff's answer provided the following excellent decorator:

This is difficult at first to understand as a Python noob, but once you get it you appreciate the simplicity and the power the language has. Starting at the bottom, the boundevent class stores the event handlers and iterates over them when the function is invoked (i.e., the event is 'raised'). The event decorator exposes the boundevent (that is stored on the object instance) for a given event (which is really just a method) when it is accessed via the '.' notation.

This may seem unimpressive. After all, C# has this event syntax baked in. You can even override the the event accessors if need be. But the thing is, the language actually has to implement those features, just like with automatic properties (remember when they didn't exist?). In this case, we're creating this 'language feature' for events without actually extending the language. All we need is the syntactic sugar provided by '@' combined with the late-binding characteristics of Python to create these events. @property does the same thing; it just happens to be built-in.

Here is my example of its usage:

This is plain awesome, and it just works. A couple of subtle things I like about this are

  1. You can actually use any arguments you want on the event definition, which can be useful for documentation. There is nothing to enforce method signature. It does need one argument to correspond with self, but it can be named anything, as is the case with this example.
  2. Completely separate from anything event-related, the doc comment actually does translate to code, which eliminates need for the pass keyword (I think).

Comments

Post a Comment

Popular posts from this blog

Enabling Globalization Invariant Mode for .NET Core App on Raspberry Pi Running LibreElec

I had an app I wanted to run on my Raspberry Pi 3 running LibreElec . In LibreElec you can install the dotnet core 2.2 runtime as an addon, and in Visual Studio you can compile for ARM processors with ‘Target Runtime’ set to ‘linux-arm’ in the publish profile. So, I published to a folder from VS using that profile, and I copied the output over to my RPi which had the dotnet runtime installed. I did a simple dotnet Whatever.dll to run the app (actually in this case, it was /storage/.kodi/addons/tools.dotnet-runtime/bin/dotnet Whatever.dll because of the way the addon is installed) and was met with this error: FailFast: Couldn't find a valid ICU package installed on the system. Set the configuration flag System.Globalization.Invariant to true if you want to run with no globalization support. at System.Environment.FailFast(System.String) at System.Globalization.GlobalizationMode.GetGlobalizationInvariantMode() at System.Globalization.GlobalizationMode..cctor() at Syste
Post a Comment
Read more

Migrating Hg Repos with hg-fast-export and Windows Subsystem for Linux

Introduction I prefer Mercurial (hg) to git . I don’t really have any reason for this preference - they both do the same thing, and the user experience for 90% of the use cases is the same. It probably comes from the conditions of the DVCS landscape when I started using these systems. Some of this may have been perception only, but it looked like this: GitHub didn’t have free private repos BitBucket did have free private repos BitBucket was very hg-friendly Joel Spolsky had an amazing tutorial that served as both a how-to for hg as well as a general intro to DVCS hg was much more Windows-friendly than git Since hg was written in python, I felt like extending it would be easier than doing so for git if I ever needed to (admittedly, this is a pretty ridiculous reason) hg felt like a more unified, “coherent” system than the very linux-y feeling git and its extensions (also pretty ridiculous) Where they differed, I liked the verbs hg used better than git’s counterparts
Post a Comment
Read more

Stubbing Static Methods with PostSharp

TypeMock uses the Profiler API to allow mocking, stubbing, etc. of classes used by code under test. It has the ability to handle sealed classes, static classes, non-virtual methods, and other troublesome-yet-oft-encountered scenarios in the world of unit testing. Other frameworks rely on proxies to intercept method calls, limiting them to be able to only fake virtual, abstract, and interface members. They also rely on dependecy injection to place the proxies as the concrete implementation of calls to the abstracted interface members. Anyone working with a legacy codebase is bound to run into static method calls (especially in the data access layer), dependencies on concrete types with non-virtual methods, and sealed class dependencies (HttpContext anyone?). The only way to unit test this without refactoring is with TypeMock. I've never used TypeMock, and I'm sure it's a great product, but it's not free. I decided to spike some code to see if I could solve the prob
6 comments
Read more