multum im parvo

[ dosomething(v) for v in items ]

for v in items:
    dosomething(v)

def sleep(secs):
    d = Deferred()
    reactor.callLater(secs, d.callback, None)
    return d

@inlineCallbacks
def doSomeStuff(stuff, throttle):
   for thing in stuff:
      yield someThing.send(thing)
      yield sleep(throttle)

def doSomeStuff(stuff, throttle):
    if not stuff:
        return defer.succeed(None)
    d = Deferred()
    work = list(stuff)
    def sendNext()
        if not work:
            loop.stop()
            d.callback(None)
        next = work.pop(0)
        return someThing.send(next)
    loop = LoopingCall(sendNext)
    loop.start(throttle)
    return d

  $ rabbitmqctl stop_app
  $ rabbitmqctl cluster rabbit@hostB rabbit@hostC
  $ rabbitmqctl reset
  $ rabbitmqctl start_app

  $ /etc/init.d/rabbitmq-server stop

  $ rm -rf /var/lib/rabbitmq/mnesia/rabbit/*

  $ rpm -U --force rabbitmq-server-.rpm

  $ rabbitmqctl stop_app
  $ rabbitmqctl force_reset
  $ rabbitmqctl cluster rabbit@hostA rabbit@hostB rabbit@hostC
  $ rabbitmqctl start_app

def f():
    try:
        return 1
    finally:
        return 2
print f()

class Publishable(object):
    published = False
    def __init__(self, start_date, end_date):
        self.start_date = start_date
        self.end_date = end_date
    def publish(self):
        self.published = True

I've always been under the impression having class & instance
variables with the same name is just confusing and not a good way to
write Python. Why did you do this?

class Foo:
   _created = 0
   @classmethod
   def create(cls):
       foo = Foo()
       cls._created += 1
       return foo

class Task:
    completed = False
    def __init__(self):
        self.start_time = time.time()

class Confusing:
  completed = 0
  def __init__(self):
      self.completed = False
  @classmethod
  def complete(cls, confusingInstance):
       cls.completed += 1
       confusingInstance.completed = True

def f():
    funcs = []
    for i in range(5):
        def g():
            print i
        funcs.append(g)
    return funcs

funcs = f()
for func in funcs:
    func()

class TaskQueue:

    def __init__(self, concurrentMax=cpuCount()):
        self.concurrentMax = concurrentMax
        self._running = 0
        self._queued = []

    def push(self, f, *args, **kwargs):
        if self._running < self.concurrentMax:
            self._running += 1
            return f(*args, **kwargs).addBoth(self._try_queued)
        d = defer.Deferred()
        self._queued.append((f, args, kwargs, d))
        return d

    def _try_queued(self, r):
        self._running -= 1
        if self._running < self.concurrentMax and self._queued:
            f, args, kwargs, d = self._queued.pop(0)
            self._running += 1
            actuald = f(*args, **kwargs).addBoth(self._try_queued)
            actuald.chainDeferred(d)
        if isinstance(r, failure.Failure):
            r.trap()
        return r

def doSomeStuff(a, b=None):
    print 'doSomeStuff(%s, %s) called: %f' % (a, b, time.time())
    def finishUp():
        print 'doSomeStuff(%s, %s) finished: %f' % (a, b, time.time())
        d.callback('done %d %d' % (a, b))
    d = defer.Deferred()
    reactor.callLater(2.0, finishUp)
    return d

taskq = TaskQueue(3)
taskq.push(doSomeStuff, 1, b=2)
taskq.push(doSomeStuff, 2, b=3)
taskq.push(doSomeStuff, 3, b=4)
taskq.push(doSomeStuff, 4, b=5)
taskq.push(doSomeStuff, 5, b=6)

doSomeStuff(1, 2) called: 1223472790.943929
doSomeStuff(2, 3) called: 1223472790.944112
doSomeStuff(1, 2) finished: 1223472792.947769
doSomeStuff(3, 4) called: 1223472792.947887
doSomeStuff(2, 3) finished: 1223472792.948004
doSomeStuff(4, 5) called: 1223472792.948162
doSomeStuff(3, 4) finished: 1223472794.951818
doSomeStuff(5, 6) called: 1223472794.951937
doSomeStuff(4, 5) finished: 1223472794.952080
doSomeStuff(5, 6) finished: 1223472796.955836

# this
taskq.push(doSomeStuff, 1, b=2).addCallback(cb).addErrback(eb)

# is the same as
doSomeStuff(1, b=2).addCallback(cb).addErrback(eb)

# ... just with queuing behavior under the hood

    >>> namespace = vars(o)

    >>> names = o.__dict__

    class Thing(object):
        def __init__(self, a, b, secret=None)
            self.a = a
            self.b = b
            self.secret = secret
            self._fd = open('file.txt')

    def dictifyThing(thing):
        blacklisted = ['secret', '_fd']
        data = dict(vars(thing))
        for bl in blacklisted:
            del data[bl]
        return data

    >>> thing = Thing( 1, 2, "don't tell anyone" )
    >>> dictifyThing(thing)
    {'a': 1, 'b': 2}

    AnotherThing(Thing):

       def __init__(self, b, secret=None):
          self.b = b
          self._fd = open('data.txt')

       @property
       def a(self):
           return self.b - 1

    >>> thing = AnotherThing(2, "open sesame")
    >>> dictifyThing(thing)
    { 'b': 2 }

    def dictifyThing(thing):
        blacklisted = ['secret']
        data = {}
        for name in ( n for n in dir(thing) if n[0] != '_' and
                      n not in blacklisted ):
           data[name] = getattr(thing, name)
        return name

    def _encode(include=(), exclude=()):
        def f(o):
            data = {}
            if include:
                for name in include:
                    data[name] = getattr(o, name)
                return data
            for name in ( n for n in dir(thing) if n[0] != '_' and
                          n not in exclude ):
                data[name] = getattr(thing, name)
            return data
        return f

    encodeThing = _encode(exclude=('secret'))
    encodeFoo = _encode(include=('a','b','c'))

Ran 4113 tests in 172.023s

PASSED (skips=62, expectedFailures=19, successes=4032)

        scene_radius = 95.0
        light_to_scene_distance = math.sqrt(
                light_pos[0]**2 + light_pos[1]**2 + light_pos[2]**2)
        near_plane = light_to_scene_distance - scene_radius
        field_of_view = miru.math3d.radians_to_degrees(2.0 *
                math.atan(scene_radius / float(light_to_scene_distance)))

        tmp = ( GLfloat * 16)()

        glMatrixMode( GL_PROJECTION )
        glLoadIdentity()
        gluPerspective( field_of_view, 1.0, near_plane,
                near_plane + (2.0 * scene_radius) )
        glGetFloatv( GL_PROJECTION_MATRIX, tmp )
        light_projection = euclid.Matrix4()
        light_projection[:] = tmp[:]

        # Move to light's perspective
        glMatrixMode( GL_MODELVIEW )
        glLoadIdentity()
        gluLookAt( light.pos.x, light.pos.y, light.pos.z,
                  0.0, 0.0, 0.0, 0.0, 1.0, 0.0 )
        glGetFloatv( GL_MODELVIEW_MATRIX, tmp )
        light_mview = euclid.Matrix4()
        light_mview[:] = tmp[:]

        # Clear the depth buffer only
        glClear( GL_DEPTH_BUFFER_BIT )

        # Remember the current shade model and setup driver state
        ...

        # do a render pass
        render()

        # Copy depth values into depth texture
        glCopyTexImage2D( GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT,
                         0, 0, shadow_width, shadow_height, 0 )

        # Restore prior driver state
        ...

        # Setup up the texture matrix which will be use in eye-linear
        # texture mapping
        tex_matrix = euclid.Matrix4()
        tex_matrix.translate(0.5, 0.5, 0.5).scale(0.5, 0.5, 0.5)
        tex_matrix = (tex_matrix * light_projection) * light_mview
        tex_matrix.transpose()
        # Give us immediate access to ctypes arrays
        tex_matrix = (
            (GLfloat * 4)(*self.tex_matrix[0:4]),
            (GLfloat * 4)(*self.tex_matrix[4:8]),
            (GLfloat * 4)(*self.tex_matrix[8:12]),
            (GLfloat * 4)(*self.tex_matrix[12:16])
        )

        glCopyTexImage2D( GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT,
                         0, 0, shadow_width, shadow_height, 0 )

        tex_matrix = euclid.Matrix4()
        tex_matrix.translate(0.5, 0.5, 0.5).scale(0.5, 0.5, 0.5)
        tex_matrix = (tex_matrix * light_projection) * light_mview
        tex_matrix.transpose()
        ... translate into ctypes array

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
    glTexParameteri(GL_TEXTURE_2D, GL_DEPTH_TEXTURE_MODE, GL_INTENSITY)
    glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)
    glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)
    glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)
    glTexGeni(GL_Q, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR)

    if not ambient_shadow_ext:
       # do an ambient pass
       ...

    glLightfv(GL_LIGHT0, GL_AMBIENT, ambient_light)
    glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse_light)

    glPushAttrib(GL_ENABLE_BIT)

    glEnable(GL_TEXTURE_2D)
    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE)
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE,
                    GL_COMPARE_R_TO_TEXTURE)

    glEnable(GL_TEXTURE_GEN_S)
    glEnable(GL_TEXTURE_GEN_T)
    glEnable(GL_TEXTURE_GEN_R)
    glEnable(GL_TEXTURE_GEN_Q)
    glTexGenfv(GL_S, GL_EYE_PLANE, tex_matrix[0]))
    glTexGenfv(GL_T, GL_EYE_PLANE, tex_matrix[1]))
    glTexGenfv(GL_R, GL_EYE_PLANE, tex_matrix[2]))
    glTexGenfv(GL_Q, GL_EYE_PLANE, tex_matrix[3]))

    ... render objects in scene

    glPopAttrib()

  Iterator iter = properties.getKeys();
  for (String key : iter) {
    // do something with the key
  }

$ mvn -Dmaven.test.skip=true -Denv=local war:war-exploded

$ build
$ runtests
$ generate-docs

$ mvn -Dmaven.test.skip=true ...

multum im parvo

The Code Hosting Site Holy War (I didn't know about)

Github (aka Shithub)

Bitbucket (aka Shitbucket)

Launchpad (aka Launchcrap)

After the war ...

Python List Comprehensions are not For-loops

2012: Personal review

IPython and libreadline Don't Work On Mac OSX ... Unless

Ding Dong, The (IE6) Witch is (almost) dead

The Cell

Competitor Research in Global Markets

2010 Is the Year Bullshit Takes Off

Google's AdWords Policies - Great Ideas, If they Only Implemented Them

The Plains

Nonjatta: Malt Maniac Awards: "The quality of the average Japanese whisky has now surpassed the quality of the average Scotch whisky."

Flickr Color Search for "Aaku" Images

Waaaarggggghhh

Perception of Twitter by the Masses - The Stats to Prove my Point. Ha! There!

Noveller

And the Preferred Character Encoding for stumbleupon is .... not UTF-8?

More on Those Things I Just Said about Microblogging

February 1, 2010 is Officialy "Stop Microblogging Forever Day"

Twisted Sleep

Notes on Upgrading a RabbitMQ Cluster

finally

Class Variables

Lexical Scope

Deferred Task Queue

Python's vars()

I Smell Fear

Devil in the Shadows

Iterators are of course not Iterable!

New Blog

Arrogant Maven, You Fill my Soul with Hatred