Brian Beck's Text Adventure

Cleveland Code Co-op meeting on Sunday

The fifth meeting of the Cleveland Code Co-op will commence this Sunday, February 22, from 13:00 till 19:00. We’re expecting more participants than usual, and likely projects so far include:

• redit, a text editor in Ruby
• 80sheep, an ADC (peer-to-peer) client in Python
• a Python tutorial for beginners
• your wildest software fantasies

This month’s meeting will take place in the EECS student lounge at Case Western Reserve University, which is located in the Glennan Building. Directions are located on the wiki. You can also join us on IRC in #C3 on irc.freenode.net.

Food and drinks will be provided! Hope to see you there.

Python instance descriptors: when class descriptors aren't dynamic enough

Python descriptors are great for customizing access to attributes on a class or instance. They are a big win for tasks like mapping Python objects to data from non-Python sources (such as SQL), since mapped attributes will need to be encoded/decoded and connected to other attributes in some way.

Below is a very simple descriptor; as you can see, accessing it from both the class and the instance invoke the descriptor protocol:

class Test(object):
    pass

class Descriptor(object):
    def __get__(self, instance, owner):
        return "Hello, world."

>>> Test.x = Descriptor()
>>> Test.x
'Hello, world.'
>>> test = Test()
>>> test.x
'Hello, world.'

However, in order to add descriptors to an object, they must be added to the object’s class. Descriptors added to an instance do not invoke the descriptor protocol:

>>> test.y = Descriptor()
>>> test.y
<__main__.Descriptor object at 0x16fe810>

This means that creating an instance with dynamic (determined at runtime) descriptors requires either the heavy-handed approach of generating a class just for that object (since adding descriptors to its class will add them to all other instances of the class), or the ad-hoc approach of redefining getattr/setattr behavior (essentially re-implementing your own descriptor protocol).

It turns out the latter approach is not as messy as it first sounds. Below is a class that enables “instance descriptors”:

class InstanceDescriptorMixin(object):
    def __getattribute__(self, name):
        value = object.__getattribute__(self, name)
        if hasattr(value, '__get__'):
            value = value.__get__(self, self.__class__)
        return value

    def __setattr__(self, name, value):
        try:
            obj = object.__getattribute__(self, name)
        except AttributeError:
            pass
        else:
            if hasattr(obj, '__set__'):
                return obj.__set__(self, value)
        return object.__setattr__(self, name, value)

class Test(InstanceDescriptorMixin):
    pass

>>> test = Test()
>>> test.z = Descriptor()
>>> test.z
'Hello, world.'

geopy sprint at December C³ meeting

Christmas tree adventure

I’ve never taken the time to get a Christmas tree while living on my own before because, honestly, Christmas doesn’t mean much to me. But having moved into a spacious single-family carriage house with Steve, it sounded a lot more fun to drag a big needly tree into my living room this year. Today Mandy and I drove all the way out to Tower-N-Pines Farm to cut down our own tree. We followed this up with dinner at Mary Yoder’s Amish Kitchen, where Mandy told me everything she knows about the Amish (Middlefield has the world’s fourth largest Amish population).

I was hoping for an axe, but they only provided hacksaws. I then realized that, despite being cooler and more fun, an axe would have required blindly swinging your arms into the branches:

We did a lot of walking and probably looked at every single tree. This took a long time:

We settled on this one:

Finally, the moment I had been waiting for:

Mandy even got her chance to make this face:

It worked:

Note all the inferior trees in the background:

Then there was dragging:

We tied it to the roof of Mandy’s car using the rope from my grappling hook (farm’s ropes? $11). It arrived safely:

Steve made up for his non-participation by helping “unfell” the tree:

Real mature, Steve:

Steve guesstimates that the tree is “almost 10 feet” tall.

geopy sprint at November C³ meeting

After suffering from over a year of poor maintenance, geopy is finally getting some love this month. A few other developers and I will be focusing on geopy at this month’s Cleveland Code Co-op meeting. We’ve come up with an ambitious todo list, including:

• Merging pending patches (bug fixes, Python 2.3 support, accuracy support)
• Adding unit tests
• Reverse geocoding support (finding locations near a point)
• Higher level Points and Locations (instead of tuples and strings)
• Keeping up with third-party geocoder APIs (and hacks)
• A “compound” geocoder for querying multiple geocoders (as fallbacks or for averaging results)
• A parser module with support for geotagged documents (including the Geo microformat), ISO 6709, GPX files, etc.
• Geohash encoding/decoding
• A formatter module for pretty-printing coordinates, distances, and ordinal directions (think “south by southwest”)
• setuptools entry points to support geocoder plugins and discovery

I think these features are in line with the “geocoding toolbox” goal of the project. While there are a lot of features there, I think geopy will still feel like a nice compact library.

Why does geopy deserve some developer attention? Because it’s being used in numerous interesting ways, including: directing robots at Carnegie Mellon University, calculating stream lengths for the U.S. Geological Survey, and updating address data for the Barack Obama presidential campaign.

We’ll be sprinting on Sunday, November 16th. If anyone would like to join us in person or on IRC, please get in touch!