<div>
  <dl id="xxx">
    <dt>xxx</dt>
    <dd>yyy</dd>
  </dl>
</div>

<div>
  <dl entry:id="xxx">
    <dt>xxx</dt>
    <dd>yyy</dd>
  </dl>
</div>

      bind("entry", xhtml,
           AttrBindParam("id", Text(article.id.is.toString), "id")
      )

#!/usr/bin/expect -f
 
set timeout 30
spawn ssh wall
match_max 100000
expect -re ".*password:.*"
send -- "xxxxxx\r"
send -- "\r\r\r\r"
expect timeout
 
for {} 1 {} {
    send "ls\r"
    expect timeout
}
 
exit 0

/**
   * Create an anchor tag around a body which will do an AJAX call and invoke the function
   *
   * @param jsFunc -- the user function that will be executed. This function will receive as last parameter
   *                  the function that will actually do the ajax call. Hence the user function can decide when
   * 				  to make the ajax request.
   * @param func - the function to invoke when the link is clicked
   * @param body - the NodeSeq to wrap in the anchor tag
   * @param attrs - the anchor node attributes
   */
  def a(jsFunc: Call, func: () =>; JsCmd, body: NodeSeq, attrs: (String, String)*): Elem = {
    attrs.foldLeft(fmapFunc(contextFuncBuilder(func))(name =>;
            <a onclick="{deferCall(Str(name" href="javascript://">{body}</a>))(_ % _)
  }

function delete(toDelete) {
  if (confirm("Delete?"))
    toDelete()
}

#!/usr/bin/python
 
from Queue import Queue
from threading import Thread
 
import usb.core
import usb.util
 
class Singleton(type):
    def __init__(cls, name, bases, dict):
        super(Singleton, cls).__init__(name, bases, dict)
        cls.instance = None
 
    def __call__(cls, *args, **kw):
        if cls.instance is None:
            cls.instance = super(Singleton, cls).__call__(*args, **kw)
 
        return cls.instance
 
class Lamp(object):
    GREEN = 0x01
    RED = 0x02
    BLUE = 0x03
    PURPLE = 0x04
    X = 0x05
    Y = 0x06
    WHITE = 0x07
    __QUIT = -1
 
    __metaclass__ = Singleton
 
    def __init__(self):
        self.t = None
        self.q = None
 
        self.dev = usb.core.find(idVendor = 0x1294, idProduct = 0x1320)
 
        import os
 
        if os.uname()[0] == 'Linux':
            self.dev.detach_kernel_driver(0)
 
        self.dev.set_configuration()
 
    def __worker(self):
        item = self.q.get()
        while item != Lamp.__QUIT:
            if item >= Lamp.GREEN and item <= Lamp.WHITE:
                print item
                data = (item, 0x04, 0x04, 0x04, 0x04)
                self.dev.write(2, data, 0)
 
            self.q.task_done()
            item = self.q.get()
 
    def plug(self):
        if self.q is None:
            self.q = Queue()
            self.t = Thread(target=self.__worker)
            self.t.start()
 
    def unplug(self):
        if self.q is not None:
            self.q.put(Lamp.__QUIT)
            self.t.join()
            self.q = None
            self.t = None
 
    def on(self, color):
        self.q.put(color)
 
    def off(self):
        self.q.put(0x00)
 
if __name__ == '__main__':
    lamp1 = Lamp()
    lamp2 = Lamp()
    lamp3 = Lamp()
 
    lamp1.plug()
    lamp2.plug()
    lamp3.plug()
 
    lamp1.on(Lamp.GREEN)
    lamp1.on(Lamp.RED)
    lamp1.on(Lamp.WHITE)
    lamp1.on(100)
 
    lamp1.unplug()
    lamp2.unplug()
    lamp3.unplug()