A few days ago, the urge to create an internetted thingy was upon me. Recently, I had been reading documentation regarding machine to machine communication using MQTT as well as BLE, and then I took a quick look at my tinker pile. The amount of neat things that I purchased for use in a project was far too high.... and then it hit me: LESS HOARDING, MORE MAKING!

What I was craving to make, was a network accessible pixel LED, inside an orb light fixture, that could be controlled using MQTT.

For this build, I used:

• an orb light fixture from the ReStore
• an Unwired One single board computer running OpenWRT
• a single ws2801 pixel LED that was left over from the Glimmer build.

The Build

The Fixture

The orb light fixture appears to be a run of the mill wall or ceiling CFL fixture. If I remember correctly, the orb cost around $5. The cost of computer cases these days is getting out of hand. :)

Take it Apart!

For some reason, the fixture manufacturer decided to put a bunch of unnecessary crap in my new computer case. Fortunately, it only took a few minutes to get the orb in a usable state.

Test the Circuit

ws2801 pixel LEDs are controlled using SPI. On the Unwired One device, there are no GPIO pins that are dedicated to SPI. Instead, the SPI bus is created by loading a kernel module with arguments to determine which GPIO pins will be used for SPI.

Solder Leads to the LED

Once the circuit was working, leads were soldered to the LED so that it could be connected directly to the GPIO headers.

After the soldering was complete, the leads were wrapped in electrical tape.

Make a Notch for the Power Cable

Since the orb is intended to rest on a table, it was necessary to make a notch in the base for the power cord to fit through. Thus ensuring that the orb will be flush on a flat surface. After a bunch of waffling around trying to find my files and metal snips, a grab and twist with some needle nosed pliers did the trick.

Put it Together

After more waffling while trying to determine the best way to make some fancy standoffs for the computer board, I opted to simply hot glue the board to a piece of cardboard, and then hot glue the cardboard to the underside of the orb base.

Fast
Simple
Effective
... and I'm lazy

The LED was also hot glued to the base, pointing upward into the glass orb. /

Now me has ORB!

Have Some Coffee

Technically, this picture is for the morning after the Orb Device had been created, but it does a damn fine job of showing what the orb thingy looks like.

The Code

Enable SPI

As previously stated, the SPI on the board needs to be configured by added a kernel module. In order for the kernel module to be loaded each time the device is restarted, the /etc/rc.local file was edited to launch the following script:

#!/bin/sh

#see http://www.unwireddevices.com/wiki/index.php/Working_with_SPI_(C/C%2B%2B)
#BUS : SPI bus number, can be bus0, bus1, bus2, bus3
#ID : SPI device ID (integer number)
#SCK, MOSI, MISO : GPIO numbers for the corresponding SPI signals
#MODE : SPI mode (0, 1, 2 or 3)
#FREQ : max SPI frequency (Hz)
#CS : GPIO number for the CS signal (optional)
# insmod spi-gpio-custom BUS=ID,SCK,MOSI,MISO,MODE,FREQ,CS

bus="bus1"
id=1
sck=20
mosi=23
miso=18
freq=25000000

cmd="insmod spi-gpio-custom $bus=$id,$sck,$mosi,$miso,0,$freq"
echo $cmd
`$cmd`

Honestly, the entire script can be replaced with one line of code: the final command. However, the script was written while reading the documentation of the process and if I ever need to edit the script, there are hella useful comments in there.

Control the Orb

The code for controlling the orb is written in Python and requires the Paho MQTT library.

code is available at https://gitlab.com/jezra/orb

oh... It would be really nice if I could copy the payload parsing documentation from the README.md in the code repository. Sadly, the lazy dev hasn't yet created that file. Well then, I know what I'm doing later!

Now quit reading, and go make an orb thingy.

The Magic starts at 3:30AM... because at 3:30AM every day, a cron task runs on the chicken coop computer to determine when the coop door should open and close later that day. For most of my weather needs I had been using the http://wunderground.com API, but for some reason, they don't offer access to twilight data through the API and I didn't want to write a webpage scraper to harvest the data from their website.

Fortunately for me, hamweather.com has a wonderful API accessible weather service with great documentation, all at a very reasonable price (free, if making less than 750 API calls per day).

For this piece of the project, I decided to use civil twilight as the opening and closing times. Then it was just a matter of reading the hamweather API documentation for sun and moon data and then hacking together some code. Since the majority of the code is written in Python, I opted to use python for this script.

Enter the Python

During the event loop of my door controller, a file is checked to see if the door should open or close, and the door behaves accordingly. This twilight fetching script will determine when to open and close the door, and submits a command to at, which then handles the timing for running the open or close script.

The chickens will be going into their new home next weekend, and the close time will probably need to be adjusted, but that just means I need to hang out in the hammock at sunset/twilight and see if all the chickens go in the coop before the door closes.

Now quit reading, and go make something that can only be tested by relaxing in a hammock at sunset. :)

Not too long about I built a tubular music thingy, and while it is nice and fun to play, I really wanted to automate the playing of some tunes as well as giving myself the ability to play certain tunes at certain times.

To be fair, this was the plan all along and I'm calling this thing "Spiel", which I guess is short for glockenspiel.

Before the tubular music thingy was built, I came up with a fairly plain-text music notation format that I call SMN: the Spiel Music Notation format. In a nutshell, SMN files start with "tNUMBER" where NUMBER is the number of beats per second, and then there will be a series of notes: G a b c d e f g, and rests: r. Both notes are rests will be considered whole notes unless followed by a number.

For example, Sudo Modprobe in SMN would be:

t30   
a4 G8 a4 G8 a8   
b8 c2 e4 d2 r8  
e4 d8 c8 d8 c8  
d8 c8 b8 a4 G8  
a4 G8 a8 b8  
c2-8 b8 G1-2  

On To the Build

For the automation, I used the following:

• BeagleBone Black - for running the code, network access, etc
• 8 12V 1A solenoids with a 10mm stroke - for striking the tubular bells
• 12V 6A power adapter - for powering the solonoids
• 8 channel 5V Relay - for sending power to individual solonoids
• Cheapo USB wireless adapter

Stand Offs

What are these things called? I don't know.

What I do know, is that once the spiky bits are bent down, these things make amazing stand offs for just about any computer build.

Mount the computer and relay board

After the stand offs were put on the Beaglebone Black and the 8 channel relay, the stand offs were hot glued to the frame of the Tubular Music Thingy.

Place the solenoids

More hot glue was used to place the solenoid bell hammers.

When the solenoids are energized, they produce heat, and if they stay energized long enough, they get hot enough to melt the glue.

This led me to write a script called 'heat' that will heat up a solenoid so that I can realign the hammer for a better sound.

Wire it up!

The Beaglebone was wired to the relay (I later changed the beaglebone to relay wiring).

The relay is wired to the solenoids, and the 12V power adapter was spliced into the relay and common ground of the solenoids.

Plug it in and run some code

Here is the finished product, ready to be played, or automated over the network.

What about some code?

The code for controlling Spiel is available at https://gitorious.org/spiel/spiel The documentation is non-existent, but there are a few .smn files in the SMN directory. If you have any questions about the code, send me an email and I'll help as I can.

My last Linux Outlaws related script

The final episode of the Linux Outlaws is nearly upon us, and I needed a script that will check if the last episode has been released, and if so, trigger the Spiel device to play the Sudo Modprobe melody.

Basically, this is a Final Episode Alarm

So now, within 5 minutes of the final episode being released, my Spiel device will play:

After setting up my BeagleBone with a phone so that I can run scripts when certain numbers are dialed, it became apparent that I should have other ways of running scripts on the BeagleBone, and most importantly, it should be possible to run scripts at a given time. Time for a new project!

A bit of Background

For a while, I had been using SSH to connect to the BeagleBone and using the at command to schedule the running of a script at a specific time. For example to run my "maiden_fade" script at 8:10 AM, I would use the following:

While that is fine and dandy, I really really did not want to open a terminal, ssh to the BeagleBone, and then type a command in order to do what I want. To make everything nice and easy, I started the Ruby Web Alarm Project. Originally, I had wanted to hack this thing together during a "code sprint" at the NBLUG, but there wasn't enough time. Oh well.

What is Ruby Web Alarm?

Ruby Web Alarm is a small Ruby based webserver with an HTML and JavaScript based UI that allows one to schedule scripts to be run within 24 hours. (This should really be changed to allow a user to set a script to run farther in the future)

Screen Shots!

Some Blather About the Code

As stated previously, the server for Ruby Web Alarm is written in Ruby (hey, fancy that!), and does not use any 3rd party gems. All of the included libraries are part of the Ruby Standard Library.

For the UI, jQuery handles async calls to the server and I'm using a slightly modified stylesheet from the MuttonChop Mobile UI.

What it Needs

While the project mosty does what I need it to do, it still needs some feature improvements such as:

• Better time input (I'd like to use the HTML5 Range element, but none of the modern webkit based mobile browsers have a working Range element)
• Daily, weekly, monthly repeating

Maiden Fade?

In case you were wondering what the "maiden_fade" script looks like...

It sets the volume to zero, starts playing a random Iron Maiden track, and then, each second of the next 35 seconds it increases the volume by 1. Is there a better way to wake up than to fade into some Maiden?

And if you were wondering about the Random Iron Maiden script...

UP THE IRONS!

Earlier this month, I received a 3V Voltmeter that I purchased on Amazon. The reason for the purchase was so that I could write some code to control the voltmeter from my beaglebone. Well hey! Guess what I finally got around to doing?

Before I get to the code, let me explain how this works, and I'd like to give a big shout out to gigamegablog for being such a great resource.

Controlling the voltmeter with the beaglebone requires a bit of understanding of Pulse-Width Modulation (PWM). The pins on the beaglebone are capable of outputting 3.3V of power. By using PWM we can send the 3.3V of power in pulses, and when these pulses are spaced apart properly, we give the illusion of a lower voltage.

The Pin Layout

According to the beaglebone documentation, pins 14 and 16 of pin header P9 on the beaglebone are PWM pins. It should be possible to use other pins as PWM pins by "muxing" the pins, but for my needs, pin 14 will do just fine.

The positive probe of the voltmeter was connected to pin 14 on P9 and the ground was connected to pin 2 on P9.

The First Test

Since I am runnin Arch Linux on my beaglebone, PWM is not only supported in the kernel, it is also enabled. Rad, that is one less step to take. Thank you Arch Linux!

The test went like this :

1. su to become root
2. mux pin 14, just to be sure:
   echo 6 > /sys/kernel/debug/omap_mux/gpmc_a2
3. set the duty_percent to 0 (this is the percent of the 3.3V that we want to emit):
   echo 0 > /sys/class/pwm/ehrpwm.1:0/duty_percent
4. set the period frequency to 100 (this is the 'pulse' ins Hz):
   echo 100 > /sys/class/pwm/ehrpwm.1:0/period_freq
5. start the PWM pin running:
   echo 1 > /sys/class/pwm/ehrpwm.1:0/run
6. start increasing the duty_percent until the voltmeter is at 3V. For me, this was when the duty_percent was 92

Sweet!

Getting Data To Process

Since I didn't want to do any web server configuration in order to get data, I decided to write a very small WSGI app in python and serve it up using the wsgiref.simple_server class.

Enter the Python

For ease of copy, the code is also available at http://hoof.jezra.net/snip/o3

The code starts serving on port 8080 and sets the percent of the PWM based on the URL used to access the server. For example, to set the voltmeter to 25%, one would need to point a browser at http://NAME_BEAGLEBONE:8080/25. My beaglebone is mounted on the wall and is named "wallbone", yea original. Anyway, if I want to set the voltmeter to 77%, I would access http://wallbone:8080/77

Face to Face

It's a shame that the voltmeter as a big "V" on it, as well as 0, 1, 2, 3, and some useless text.

One would think that I could just take apart the voltmeter, make a compass from a pin and a twist-tie, draw a new face, and re-assemble the meter. Oh, don't mind if I do!

How about some video?

Well... it was far too dark and the pin isn't really visible. What a shame.
http://www.youtube.com/watch?v=ldcwMYj5AIc
http://www.youtube.com/watch?v=SdbBgiZn1UM

Now What?

There are plenty of uses for this meter.

• analog progress or volume meter for muttonchop
• add a few more meters and create a neat clock

With the pulse-width modulation, I could connect and control a fan from the beaglebone.

The possibilities are only limited by my imagination.

Now quit reading, and go send me some ideas.

In the movies, when it is time to detonate the explosives, the person setting off the KABOOM has a sweet remote control with either a two part switch or with two separate switches. Damn, I love a good movie explosion.

The two part switch allows the user to:

1. activate the explosive
2. blow shit up

Because the switch has two components, activate and detonate, it is uncommon for there to be accidental explosions. This is a damn fine safety measure and when adding the ability to block an identi.ca user with heybuddy, I wanted a similar safety precaution; blocking someone by accident should not be possible. So that is what I did.

To accomplish this, it was necessary to do the following

• create a disabled button that brings the hammer down!
• create a checkbox that will activate the button

In GTK parlance, to disable a button, one needs to set the button sensitivity to false. Since I am using Python, this is accomplished thusly

To show this idea as a small working bit of code, I wrote a quick Python-GTK app that almost does the bare minimum.

Enter the Python

It may not be the best solution, but it is a solution and it works.

Well that's it for now. Quit reading, and go write some code.

My N810 died

When I went to the MeeGo conference I discovered that my N810 would no longer boot. The device would simply blink the Nokia logo when I tried to turn it on, and all of my attempts to flash a new image to the device failed. So long buddy. [sadface]

How Am I Supposed to Test Software?

Since I need an Maemo device for testing Heybuddy I wrote a postcard to Nokia and requested a new device. Quite surprisingly, I have not yet received a response.

Really? Didn't they see the awesome picture of a coffee cup that drew on the postcard? Maybe they were just waiting until they announced the N9 before they send one my way. Yeaaaaa, that's the ticket!

Fortunately for me (and for !Heybuddy ), there are some kick ass users and testers out there that help me with Maemo problems. However......

Terrible Timing

On June 16th, there was a bug report for heybuddy regarding a security vulnerability due to the use of Python's urllib2 module for HTTPS communication. A nice fix for the problem was found at stackoverflow, and it utilizes the SSL module. However.....

There is No Python SSL Module on Maemo!

One more time, in case you missed it: There is no Python SSL Module on Maemo! Maemo uses Python 2.5 and the 2.5 release did not include an SSL module. Fortunately, there is an SSL module available for Python 2.5 that can be downloaded from http://pypi.python.org/pypi/ssl. Unfortunately, I can't properly test this SSL module with Heybuddy on a Maemo device because my device is broken. Oh, now we've come full circle.....

If you are using Heybuddy, I highly suggest that you update to the latest version, and if you are on an Maemo device, update to the latest Heybuddy release and install the SSL module.

Now quit reading, update your software, and send someone a postcard.

The Need

I really wanted a web accessible interface to control streaming music on my media playing computer that is connected to my home stereo. With a mix of Last.fm, shell-fm, pyjamas, web.py, and a few hundred lines of python code, I succeeded adequately and thought I'd share my experience.

The Why

When I wanted to stream music on my media machine, I would to get on the command line, ssh to the machine with X11 forwarding, and run the last.fm linux client on the machine. This would display a sluggish last.fm client on whichever computer I was using to connect to the media machine.

But what if I'm switching computers or I want to use my Nokia N810 or Neo Freerunner to control the music? A web interface solves these issues.

NOTE: this "how to" assumes that you are familiar with compiling software from source on a Linux system.

Step 1

Sign up for a Last.fm account. It is a fairly straight forward process.

Step 2

Install shell-fm (follow the directions on the shell-fm webpage). Shell-fm may be in your repos, but the version may not be new enough for this to work.

edit your ~/.shell-fm/shell-fm.rc file to look like the following:

What the configuration does:

• username and password should be self explanatory
• default-radio is used to set what starts streaming when shell-fm is started
• unix creates a unix file socket that allows for communication with shell-fm. My file is /home/jezra/.shell-fm/unix_file. we need to use this later
• daemon runs shell-fm as a daemon in the background

OK, that takes care of the player. Now onto the web server

Step 3

In order to get a web interface, I need some sort of webserver. There are many many different ways to create a webserver and for this example I chose to use web.py which is a damn simple web app framework for Python. If web.py isn't in your repos, you should switch distributions (or download the source).

My Layout of Files and directories
/testing_directory
--index.py #the webserver
--interface.py # the pyjamas interface for the web app
--templates/ #a directory containing one template that the webserver will use
--static/ #a directory of static content served by the web app
----styles/ #a directory of css styles used by the web app
----pyjamas/ #a directory containing the compiled output of the interface.py file

Lets move on to the files

index.py

Go to line 28 and change sock.connect('/home/YOUR_NAME/.shell-fm/unix_file') to point to your unix file that you set up in the shell-fm.rc file.

Almost there, now we just need to create an AJAXy interface.....

Step 4

Creating a web app with pyjamas is quite a bit like creating a Python application with any graphical toolkit, except the code needs to be compiled by Pyjamas and the finished product is HTML and JavaScript.

So go get the pyjamas source. You don't really need to install pyjamas, but you will need to "bootstrap" it. cd into the pyjamas directory and run "python bootstrap.py" which will create the pyjamas compilers in the bin directory of the pyjamas source directory.

interface.py

Compile this code using "/PATH/TO/PYJAMAS/SOURCE/bin/pyjsbuild interface.py". Compiling will create a directory named "output". Copy the contents of "output" into "static/pyjamas"

Now create a style sheet for the progress bar in our interface
static/style/style.css

finally, create the index template
templates/index.html

Now if everything went according to plan.....
run "shell-fm" to start the shell-fm player
run "python index.py" to start the server
Point your web browser to http://localhost:8080 and enjoy the ugly web interface that is nowhere near "feature complete", but it is a start.

Now quit reading, and go listen to Basil Poledouris

All of these files can be downloaded from http://www.jezra.net/downloads/blogcode/pywebshellfm.tgz

EDIT: What does it look like?

How about a screenshot of the UI, and a picture of the UI in the N810 and the Freerunner.

Recently, I've been playing around with web.py, a simple yet very powerful web framework for writing web applications using python, and I thought I would share my first test of web.py that goes beyond "hello world". I discussed this briefly on Episode 13 of Frostcast

what it do

In a nutshell, the code will produce a browseable list of directories and audio files.

When run, the code will start a web server on port 8080 that dynamically displays the list of directories and files. Clicking on a link to an audio file will cause the audio file to be played on the server machine using sap. One could easily use any command line audio player of their choice in place of sap; such as mplayer.

Enter the Python

Give it a go

1. save the code http://www.jezra.net/downloads/blogcode/audio_browser.tgz
2. edit line 19 to point to a directory of audio files
3. run the code with python
4. point your browser to http://localhost:8080
5. email me to let me know what went wrong
6. ?
7. Did you remember to install web.py?

Moving Forward

Welcome to "Shot of Code", this is only the start of the code. So where can this go? AKA, what would I like this to do. Well I can think of a few things.

• a web interface for playing videos on my media machine. This will require some some way to send commands to Mplayer for play, pause, fast-forward, etc.
• a web front end to a command line audcatcher (sorry, I couldn't resist).
• recreate shnerkel with a web interface.

The reason that all of my code ideas are audio or video related is because I want to be able to control my media machine with a web interface and not have to SSH into the machine to control media playback.

Now quit reading, and go sweeten that sauce!
jezra

Starting with version 2.18, the GTK library allowed for adding links to Labels, and this is exactly how I handled adding clickable URLs and names in heybuddy. Unfortunately, the version of GTK on Maemo devices is too old to use links in Labels.

Another unfortunate problem with links in Labels is that no GTK theme seems to have set a custom link color and all themes are stuck with the default bright blue link color. Egads! It sure would be nice if the user could set the color of links in heybuddy.

After searching and searching, I couldn't find an example of how to set a custom color for links in a GTK Label so I first needed to write some code to experiment with. The end result was a very simple example of exactly what I needed: a custom link color in a GTK Label.

Enter the Python

shazaam! Custom color, baby!

Now quit reading, and go make things colorful.

Recently, while writing code for heybuddy, I needed to:

• display a tray icon
• hide the window when "close window" is selected
• show the window when the tray icon is clicked

Although getting this done was easy enough to do, finding out how to do it was a bit of a pain, so I thought it would be best if I shared my Python/GTK test code and save future developers from some pain.

Enter the Python

#!/usr/bin/env python
import gtk
class Win (gtk.Window):
    def __init__(self):
        gtk.Window.__init__(self)
        self.set_title("Close to tray")
        self.connect("delete-event", self.delete_event)
        #create a virtical box to hold some widgets
        vbox = gtk.VBox(False)
        #make a quit button
        quitbutton = gtk.Button("Quit")
        quitbutton.connect("clicked",self.quit)
        #add the quitbutton to the vbox
        vbox.pack_start(quitbutton)
        #create a label to say *something* and add to the vbox
        label=gtk.Label("This is a test of 'close to tray' functionality")
        vbox.pack_start(label)
        #add the vbox to the Window
        self.add(vbox)
        #show all of the stuff
        self.show_all()
        #make a status icon
        self.statusicon = gtk.status_icon_new_from_stock(gtk.STOCK_GOTO_TOP)
        self.statusicon.connect('activate', self.status_clicked )
        self.statusicon.set_tooltip("the window is visible")
        #start the gtk main loop
        gtk.main()
    
    def quit(self,button):
        #quit the gtk main loop
        gtk.main_quit()
    
    def delete_event(self,window,event):
        #don't delete; hide instead
        self.hide_on_delete()
        self.statusicon.set_tooltip("the window is hidden")
        return True
        
    def status_clicked(self,status):
        #unhide the window
        self.show_all()
        self.statusicon.set_tooltip("the window is visible")
        
if __name__=="__main__":
    win = Win()

The basics of what needs to be done:

1. connect the Window's "delete-event" signal to a function
2. in the function, have the window "hide_on_delete()"
3. return True ( if True is not returned, the Window's children will be destroyed and everything will go to crap )

So there you have it, an easy way to "close to tray" or whatever you want to call it.

Now quit reading, and go ease a developer's pain.

The Need

Having recently implemented parsing of Markdown code in my blog, and deciding to write most, if not all, of my future documentation in Markdown, what I really needed, was a way to do the following:

1. write markdown code in a spellchecking text editor
2. convert the markdown code to HTML
3. preview the HTML as it would appear in a browser

Simple enough, but unfortunately, all of the solutions that I found were online forms. I wanted something that I could run on my own machine.

The Solution

As is often the case, the solution was to write a quick little application. For this application, I chose to use Python due to the readily available Python Markdown module as well as my "quick/dirty" need and recent Python usage on various projects.

The application uses GTK for the graphical interface, and webkit for HTML rendering.

Without further ado ...
Enter the Python

#!/usr/bin/env python 
''' 
Hey, this is GPLv3 and copyright 2010 Jezra 
''' 
import gtk 
import webkit 
import markdown #http://www.freewisdom.org/projects/python-markdown/ 
global default_file 
default_file = "markdown.txt" 
try: 
    import gtkspell 
    has_gtkspell=True 
except: 
    has_gtkspell=False 
     
class application: 
    def `__init__`(self): 
        #build the UI 
        winder = gtk.Window(gtk.WINDOW_TOPLEVEL) 
        winder.connect("destroy",self.quit) 
        winder.maximize() 
        #add some accellerators 
        #create an accellerator group for this window 
        accel = gtk.AccelGroup() 
        #add the ctrl+q to quit 
        accel.connect_group(gtk.keysyms.q, gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE, self.quit_accel ) 
        #add ctrl+s to save 
        accel.connect_group(gtk.keysyms.s, gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE, self.save_accel ) 
        #lock the group 
        accel.lock() 
        #add the group to the window 
        winder.add_accel_group(accel) 
        #we need a paned 
        pane = gtk.HPaned() 
        #and a vbox 
        box = gtk.VBox(False) 
        #add the pane to the box 
        box.pack_start(pane) 
        #add the box to the window 
        winder.add(box) 
        #do the text crap for the first pane 
        self.tb = gtk.TextBuffer() 
        tv = gtk.TextView(self.tb) 
        tv.set_wrap_mode(gtk.WRAP_WORD) 
        #try and add spell checking to the textview 
        if has_gtkspell: 
            #what if there is no aspell library? 
            try: 
                self.spell = gtkspell.Spell(tv) 
                self.has_spell_library=True 
            except Exception: 
                #bummer 
                self.has_spell_library=False 
                print Exception.message 
        #add the text view to a scrollable window 
        input_scroll = gtk.ScrolledWindow() 
        input_scroll.add_with_viewport(tv) 
        input_scroll.set_policy(gtk.POLICY_AUTOMATIC,gtk.POLICY_AUTOMATIC) 
        #add to the pane 
        pane.pack1(input_scroll,True) 
        #make the HTML viewable area 
        self.wv = webkit.WebView() 
        #disable the plugins for the webview 
        ws = self.wv.get_settings() 
        ws.set_property('enable-plugins',False) 
        self.wv.set_settings(ws) 
        out_scroll = gtk.ScrolledWindow() 
        out_scroll.add(self.wv) 
        out_scroll.set_policy(gtk.POLICY_AUTOMATIC,gtk.POLICY_AUTOMATIC) 
        pane.add2(out_scroll) 
        #we will add buttons at the bottom 
        bbox = gtk.HButtonBox() 
        bbox.set_layout(gtk.BUTTONBOX_START) 
        #we need buttons! 
        savebutton = gtk.Button("Save") 
        savebutton.connect("clicked", self.save) 
        markdownbutton = gtk.Button("_Markdown",use_underline=True) 
        markdownbutton.connect("clicked", self.markdown) 
        #add the buttons to the bbox 
        bbox.pack_start(savebutton,False,False,0) 
        bbox.pack_start(markdownbutton,False,False,0) 
        #add the bbox to the box 
        box.pack_start(bbox,False,False,0) 
        winder.show_all() 
        self.read_default_file() 
    def run(self): 
        gtk.main() 
    def quit(self,widget=None): 
        self.save() 
        gtk.main_quit() 
    def markdown(self,widget): 
        text = self.get_buffer_text() 
        mdtext = markdown.markdown(text) 
        self.wv.load_html_string(mdtext,"file:///") 
    def read_default_file(self): 
        try: 
            f = open(default_file,"r") 
            text = f.read() 
            self.tb.set_text(text) 
            f.close() 
        except: 
            pass 
    def quit_accel(self,accel_group, acceleratable, keyval, modifier): 
        self.quit() 
    def save_accel(self,accel_group, acceleratable, keyval, modifier): 
        self.save() 
    def save(self,widget=None): 
        #get the text 
        text = self.get_buffer_text() 
        f = open(default_file,"w") 
        f.write(text) 
        f.close() 
    def get_buffer_text(self): 
        start_iter = self.tb.get_start_iter() 
        end_iter = self.tb.get_end_iter() 
        text=self.tb.get_text(start_iter,end_iter) 
        return text 
if `__name__`=="`__main__`": 
    a = application() 
    a.run() 

Usage

• Ctrl+q quits the application
• Ctrl+s saves the current document
• Alt+m marks down the text and displays the HTML in the right pane

Note: the 'save' location is hard coded to be "markdown.txt" in the directory where the code is run from.

EDIT:the code for markdowner is now available on launchpad

Now quit reading, and go markdown some text.

• I probably should have used Vala
• using threads in python isn't hard
• using threads in a python GTK app isn't hard
• Documentation for pygtk is not the greatest

label=gtk.Label()
markup="Visit <a href='http://www.jezra.net'>Jezra's Website</a>"
label.set_markup(markup)

For the past few months, I've been using indenti.ca to micro-blog and while there are plenty of applications available to access the identi.ca data from my laptop or desktop, I couldn't find anything that would run well on my Nokia N810 pocket computer.

Originally, I had planned to write a client in Vala, but since there is already a wonderful Vala denting client named Pino and since I hadn't written anything in Python for a while, I decided to use Python and develop a client in such a way that it might be easy to port to other languages: specifically Vala and possibly Java.

A couple of hours here and there with Geany and I had a pretty decent denting client in need of a name. Luckily I have a buddy who, aside from needing to blog about his photos, needs a denting client named after him.

Hey Buddy! I wrote an identi.ca client and named it after you. Well, sort of.... it's called heybuddy

Jake Hume (http://blog.fragdev.com/) took this picture of heybuddy running on his N810. Sweet!

Although I don't have any plans for making packages of heybuddy for various Linux distributions, fellow Linux Outlaw and heybuddy user timttmy has created a heybuddy AUR package for Arch Linux

• simple little projects are rarely simple or little
• I still can't get threading to work in a python app
• there is a correct way to authenticate an identi.ca user via the urllib2 python module, the short cut I tried to take showed me the error of my ways
• the documentation for gtk.keysyms seems to be non-existent
• The majority of heybuddy user's live in apple growing country
• I ♥ scrumpy

#!/usr/bin/env python
import sys,urllib,re,os
from optparse import OptionParser
from HTMLParser import HTMLParser

class Parser(HTMLParser):
  def __init__(self,verbose=False):
    HTMLParser.__init__(self)
    self.clear()
    self.verbose = verbose
  def handle_starttag(self, tag, attrs):
    # we only care about 'a' tags
    if tag=="a":
      href = self.get_value_from_tuple_list("href",attrs)
      if href!=None:
        if self.verbose:
          print "found href: "+href
        if not href in self.hrefs:
          self.hrefs.append( href )
        
    elif tag=="base":
      href = self.get_value_from_tuple_list("href",attrs)
      if self.verbose:
          print "found base href: "+href

      if href!=None:
        self.base_href=href
        
  def get_hrefs(self):
    return self.hrefs
    
  def get_base_href(self):
    return self.base_href

  def get_value_from_tuple_list(self,target_key,list):
    for (key,value) in list:
      if key==target_key:
        return value
    return None
  
  def clear(self):
      self.hrefs=[]
      self.base_href=""

class JayWalker():
  browsable_files =[]
  valid_links = {}
  errors = {}
  processed_urls =[]
  depth = 0
  file_links = {}
  current_file_identifier=""

  webpage_extensions = ["htm","html","php","asp","jsp","py",""]
  def __init__(self,options):
    self.options=options
    
  def get_extension(self,str):
    #remove the start_url from the string
    s_string = str.replace(self.options.start_url,"")
    splits = s_string.split(".")
    if len(splits)>1:
      return splits[-1]
    else:
      return ""
      
  def walk(self):
    #process the start_url
    self.process_url(self.options.start_url)
    
    '''we are done, what sort of output should there be?'''
    #does the user want sitmap data?
    if self.options.sitemap:
      sm_text="<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
      sm_text+="<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">\n"
      if len(self.browsable_files)>0:
        for f in self.browsable_files:
          sm_text+="\t<url>\n"
          sm_text+="\t\t<loc>%s</loc>\n" % (f) 
          sm_text+="\t</url>\n"
        sm_text+="</urlset>\n"
    if self.options.outdir !=None:
      dir = self.options.outdir
      if not os.path.exists(dir):
        os.makedirs(dir)
      #make the errors
      errors_path = os.path.join(dir,"errors.txt")
      file = open(errors_path,"w")
      if len(self.errors)>0:
        for key in self.errors.keys():
          file.write( key +"\n")
          for page in self.errors[key]:
            file.write( "\t%s\n" % ( page ) )
      else:
        file.write("no errors")
      file.close()
      #make the errors
      links_path = os.path.join(dir,"links.txt")
      file = open(links_path,"w")
      if len(self.valid_links)>0:
        for key in self.valid_links.keys():
          file.write( key +"\n")
          for page in self.valid_links[key]:
            file.write( "\t%s\n" % ( page ) )
      else:
        file.write("no links")
      file.close()
      #make the browsable files
      browsables_path = os.path.join(dir,"browsables.txt")
      file = open(browsables_path,"w")
      if len(self.browsable_files)>0:
        for f in self.browsable_files:
          file.write("\t%s\n" % (f) )
      else:
        file.write("no browsables")
      file.close()
      #are we making a sitemap?
      if self.options.sitemap:
        sitemap_path = os.path.join(dir,"sitemap.xml")
        file = open(sitemap_path,"w")
        file.write(sm_text)
        file.close()
    else:
      print "--ERRORS--"
      if len(self.errors)>0:
        for key in self.errors.keys():
          print key
          for page in self.errors[key]:
            print "    %s" % ( page )
      else:
        print "no errors"
      
      print "--VALID LINKS--"
      if len(self.valid_links)>0:
        for key in self.valid_links.keys():
          print key
          for page in self.valid_links[key]:
            print "    %s" % ( page )
      else:
        print "no valid links"
      
      print "--BROWSABLE FILES--" 
      for f in self.browsable_files:
        print "    "+f
      
      if self.options.sitemap:
        print "--SITEMAP--"
        print sm_text
    
  def process_url(self,url,parent="root",depth=0):
    
    #add the url to our processed list
    self.processed_urls.append(url)
    
    self.file_links[url]=[]
    if self.options.be_verbose:
      print "processing "+url
    
    #is this a mailto?
    if url.startswith("mailto:") or url.startswith("MAILTO:"):
      if self.options.be_verbose:
        print "found mailto "+url
      #todo: record the mailto
      return
    
    #is this a link to an anchor?
    if url.startswith("#"):
      if self.options.be_verbose:
        print "found anchor link "+url
      #todo: record the mailto
      return
    
    #get a handle for the opened url file
    try:
      fh = urllib.urlopen(url)
      #what code did we get?
      code = int( fh.getcode() )
      if code>400:
        #record this error
        if not self.errors.has_key( parent ):
          self.errors[parent] = []
        self.errors[parent].append(url)
        
        if self.options.be_verbose:
          print "error %d" % ( code )
        return
      else:
        #record this good link
        if not self.valid_links.has_key( parent ):
          self.valid_links[parent] = []
        self.valid_links[parent].append(url)
        if self.options.be_verbose:
          print code
      
      #check the file extension
      ext = self.get_extension(url)
      if not ext in self.webpage_extensions and ext!="":
        if self.options.be_verbose:
          print "based on extension, we won't parse this file"
        return
      
      #check the content type, we only want html
      file_info = fh.info()
      content_type = file_info.getheader("Content-type")
      if content_type.endswith("html"):
        #this is good
        pass
      else:
        if self.options.be_verbose:
          print "bad content type: "+content_type
        return
      #this is a browsable file
      self.browsable_files.append(url)  
      #read the text from the file
      file_text = ""
      readfile = True
      while(readfile):
        temptext = fh.read(1028)
        file_text+=temptext
        if temptext==None or temptext =="":
          readfile = False
      fh.close()
      if self.options.be_verbose:
        print "reading "+url
      
      p = Parser(self.options.be_verbose)
      p.feed(file_text)
      
      self.file_links[url] = p.get_hrefs()
      base_href=p.get_base_href()
      
    except Exception as inst:
      print type(inst)     # the exception instance
      print inst.args      # arguments stored in .args
      print inst           # __str__ allows args to printed directly

      if self.options.be_verbose:
        print url+" is not a valid file"
      if not self.errors.has_key(parent):
        self.errors[parent] = []
      self.errors[parent].append(url)
      return
    
    if self.options.be_verbose:
      if len(self.file_links[url])>0:
        print "--unique links--"
        for link in self.file_links[url]:
          print "  "+link
      print "processed "+url
    
    #loop through the links
    for link in self.file_links[url]:
      parse_link=None;
      # if the url isn't absolute
      #TODO: find a better way to process anchored links
      if re.match( "^[A-Za-z]+:",link)==None and not link.startswith("#"):
        # is there a base href?
        if base_href!=None and base_href!="":
          parse_link = self.get_absolute_url(link,base_href,True)
        else:
          parse_link = self.get_absolute_url(link,url)
        
      else:
        #todo: check if this is an Absolute path on the site
        pass
        
      if parse_link!=None:
        if not parse_link in self.processed_urls:
          print parse_link
          self.process_url(parse_link,url)
    
  def get_absolute_url(self,url,parent,parent_is_base_href=False):
    #determine the parent's directory
    bits = parent.split("/")
    if not parent_is_base_href and parent.count("/")>2:
      del(bits[-1])
    #how may ../ are in the url?
    up_count = url.count("../")
    #remove that many dirs from the parent bits
    for x in range(up_count):
      print x
      sys.exit()
      del(bits[-1])
    #remove the ../ from the url
    url.replace("../","")
    parent_root = "/".join(bits)
    
    if url.startswith("/") :
      return_url = parent_root+url
    else:
      return_url = parent_root+"/"+url
    return return_url
    
    
class Application:
  def __init__(self):
    #we need an option parser
    self.opt_parser = OptionParser()
    #what do we need from the user?
    self.opt_parser.add_option("-u", "--url", dest="start_url",
      help="The URL to start processing", metavar="URL")
    self.opt_parser.add_option("-o", "--out", dest="outdir",
      help="save output to a specific directory", metavar="dir")
    self.opt_parser.add_option("-s", "--sitemap",
                  action="store_true", dest="sitemap", default=False,
                  help="include generic sitemap data in the output")
    self.opt_parser.add_option("-v", "--verbose",
                  action="store_true", dest="be_verbose", default=False,
                  help="display what is going on")
    
  def run(self):
    #parse the options
    (options, args) = self.opt_parser.parse_args()
    #if there is no url,we quit
    if options.start_url==None:
      print "ERROR: You did not specify a URL to process"
      print ""
      sys.exit()
    #we need a JayWalker
    jw = JayWalker(options)
    jw.walk()

if __name__=="__main__":
  app = Application()
  app.run()

./walk.py -u http://www.jezra.net -s -o output

#!/usr/bin/env python
# copyright 2009 jezra lickter
#this software is licensed under the GPLv3  http://www.gnu.org/licenses/gpl.txt
import clutter
import random

class Game:
    def __init__(self,cell_size):
        self.cells = []
        #create a clutter stage
        self.stage = clutter.Stage()
        #set the stage size in x,y pixels
        self.stage.set_size(500,500)
        self.stage.set_title("The Game of Life")
        self.stage_width, self.stage_height = self.stage.get_size()
        #define some clutter colors in rgbo (red,green,blue,opacity)
        self.color_black =clutter.Color(0,0,0,255) 
        self.color_green =clutter.Color(0,255,0,255)
        self.color_blue =clutter.Color(0,0,255,255)
        #set the clutter stages bg color to our black
        self.stage.set_color(self.color_black)
        #we will need to check on the key presses from the user
        self.stage.connect('key-press-event', self.parseKeyPress)
        self.stage.connect("destroy", self.quit)
        '''fill the screen with rectangles'''
        num_cols = int(self.stage_width/cell_size)
        num_rows = int(self.stage_height/cell_size)
        cells_to_create = num_cols*num_rows
        y = 0
        for row in range(num_rows):
            x = 0
            self.cells.append( [] )
            print "%i cells to create" % (cells_to_create)
            for column in range(num_cols):
                #set the column index to a rect that is cell_size by cell_size
                self.cells[row].append( clutter.Rectangle() )
                self.cells[row][column].set_size(cell_size,cell_size)
                self.cells[row][column].set_position(x,y)
                #add this cell to the stage
                self.stage.add(self.cells[row][column])
                self.cells[row][column].set_color(self.color_green)
                self.cells[row][column].set_opacity(0)
                x+=cell_size
            cells_to_create-=num_cols
            
            y+=cell_size
        print "cells created"
        #get some data about the rows
        self.row_count  = len(self.cells)
        self.col_count = len(self.cells[0])     
        self.cell_count = self.row_count*self.col_count
        #make a timer to do stuff for us
        self.timeline = clutter.Timeline(duration=500)
        #when the timer finishes running, we want to determine the life
        self.timeline.connect("completed",self.compute_life)
        #increase linearly
        alpha = clutter.Alpha(self.timeline, clutter.LINEAR)
        #make some opacity behaviours that we will apply to the cells
        self.dieBehaviour = clutter.BehaviourOpacity(255,0,alpha)
        self.aliveBehaviour = clutter.BehaviourOpacity(0,255,alpha)
        
    def parseKeyPress(self,actor,event):
        if event.keyval == clutter.keysyms.q:
            self.quit()
        elif event.keyval == clutter.keysyms.c:
            self.compute_life()
        elif event.keyval == clutter.keysyms.r:
            self.reseed()
    
    def quit(self,widget=None):
        clutter.main_quit()
    
    def run(self):
        self.stage.show_all()
        self.seed_life()
        self.compute_life()
        clutter.main()
        
    def reseed(self):
        for r in range(self.row_count):
            for c in range(self.col_count):
                if self.cells[r][c].get_opacity()>0:
                    self.cells[r][c].set_opacity(0)
        self.seed_life()
        
    def seed_life(self):
        print "adding random life"
        #loop through the rows
        for r in range(self.row_count):
        #loop through the columns
            for c in range(self.col_count):
                #generate a number
                i = random.randint(0,4)
                if i==0:
                    # x,y is alive
                    self.cells[r][c].set_opacity(255)
        
    def compute_life(self,asset=None):
        #detach all objects from the behaviors
        self.dieBehaviour.remove_all()
        self.aliveBehaviour.remove_all()
        for r in range(self.row_count):
            for c in range(self.col_count):
                if self.cells[r][c].get_opacity()>0:
                    alive=True
                else:
                    alive=False
                ln = self.living_neighbors(r,c)
                if alive and ( ln<2 or ln>3 ):
                    #this cell will die; boohoo
                    self.dieBehaviour.apply(self.cells[r][c] )
                elif not alive and ln==3:
                    #this cell is now alive; damn zombies
                    self.aliveBehaviour.apply(self.cells[r][c] )
                            
        #start the timeline again
        self.timeline.start()
                
    def living_neighbors(self,r,c):
        alive = 0
        r_min = r-1
        r_max = r+1
        c_min = c-1
        c_max = c+1
        if r==0 :
            r_min=r
        elif r == self.row_count-1:
            r_max=r
        if c==0 :
            c_min=c
        elif c == self.col_count-1:
            c_max=c
            
        tr = r_min
        tc = c_min
        cells_computed=0
        while not tr > r_max:
            tc = c_min
            while not tc > c_max:
                if ( tr!=r or tc!=c ):
                    cells_computed+=1
                    if self.cells[tr][tc].get_opacity()>0:
                        alive+=1
                tc+=1
            tr+=1
        return alive
        
if __name__=="__main__":
    game = Game(5)
    game.run()