scaryclam.co.uk - Blog

Recently I found that some Internet services were broken on my friends home connection. After some digging around I found that his connection was being hijacked by Virgin Media whenever a target server did not exist. Rather than following basic Internet protocols Virgin Media hijack the connection so that they can advertise themselves and sponsored websites rather than allowing the connection to fail like it should. So I tried to use their ‘opt out’ link in order to restore some sanity. I found a 404 error page instead. After much Googling it seems that the link that they provide has been out of order for much of the life of the ‘service’. The link they provide is: https://my.virginmedia.com/advancederrorsearch/settings. However, there is hope for anyone finding a 404 error at the provided link to still manage to opt out. Try going to http://my.virginmedia.com/advancederrorsearch/settings instead as this link worked just fine for me and my friend (notice the http rather than https). No more broken Internet!

After playing around with the super keyworld in Python, I finally stumbled across this question which helped explain some multiple inheritence, with arguments. This also helped me to understand the use of super in Python and how to whole thing links together. I edited the original answer to the question as I found Python complaining about the arguments being passed into the last __init__.

class Mother(object):
    def __init__(self, p_mother, **more):
        print "Mother", p_mother, more
        self.p_mother = p_mother
        super(Mother, self).__init__(p_mother=p_mother, **more)

    def hello(self):
        print "Hello %s" % self.p_mother

class Father(object):
    def __init__(self, p_father, **more):
        print "Father", p_father, more
        self.p_father = p_father
        super(Father, self).__init__()

    def world(self):
        print "World %s" % self.p_father

    def hello(self):
        print "Hello %s" % self.p_father

class Child(Mother, Father):
    def __init__(self, p_mother, p_father, **more):
        print "Child", p_father, p_mother, more
        super(Child, self).__init__(p_mother=p_mother, p_father=p_father,
                                    **more)

if __name__ == '__main__':
    c = Child("Mother", "Father")
    c.hello()
    c.world()

Congratulations to the LHC for making history today. Fingers crossed they’ll find what they’re looking for (and lots of things that they weren’t)!

Exciting stuff, even for us non-physics bods!

I recently upgraded to Kubuntu Karmic and since it’s so shiny (I’m a sucker for a bit of eye candy…so long as it doesn’t get in my way) I decided to try my hand at making a widget. Now, I’ve tinkered with this before and made a widget that gets a fortune but that was simple. I want something a bit more complicated. Since I’ve also recently found the python-twitter API it seemed quite a nice little project (yes I’m aware it’s been done before).

KDE TechBase provides some good starting documentation but I had a lot of trouble with just getting a simple data engine set up, installed and a plasmoid that could connect to it. The documentation does a nice job of telling you how to make a data engine, how to make a widget but then gave an over complicated example of how to use to use the two together. So here is the result of some of my trial and error in this simple task…

Let’s start with the data engine.

from PyQt4.QtCore import *
from PyKDE4.kdecore import *
from PyQt4.QtGui import *
from PyKDE4.plasma import Plasma
from PyKDE4 import plasmascript
import twitter

class PyTwitterData(plasmascript.DataEngine):
    def __init__(self,parent,args=None):
        plasmascript.DataEngine.__init__(self,parent)

    # Set up the initial stuff. self.source_dict is just something I was trying out. Read the note
    # in updateSourceEvent
    def init(self):
        self.source_dict = {'username':'password'}
        # Minimum polling interval is in milliseconds
        self.setMinimumPollingInterval(30000)

    # Return the available sources
    def sources(self):
        sources = ['username']
        return sources

    # This gets called when the data engine has new data or when polled
    def sourceRequestEvent(self, name):
        return self.updateSourceEvent(name)

    def updateSourceEvent(self, source):
        # username and password of the required user. Note that the original idea was to allow
        # the use of a dictionary to store the username and password but for some reason it
        # wasn't storing it properly so you may have to just replace this to use your normal
        # username and password here.
        twitter_username = source
        twitter_password = self.source_dict.get(str(source), 'default_password')

        # Twitter API things. This just makes a twitter API object that gets you own status
        api_base = twitter.Api(username=twitter_username,
                               password=twitter_password)
        my_status = api_base.GetUser('username').GetStatus().GetText()

        # Set the in the 'Status' key of source (username) to the status string
        self.setData(source, 'Status', my_status)
        # As far as I know this always returns true so return True!
        return True

# Create and return the data engine object
def CreateDataEngine(parent):
    return PyTwitterData(parent)

If you’ve read the KDE TechBase documentation you’ll know that this code is meant to go in a file named main.py. The directory structure for the data engine is as follows:
.
| — contents
|     `– code
|          |– main.py
| — metadata.desktop
` — twitterdataengine.zip

As stated, the code above goes in the main.py file. The metadata.desktop file is important and contains all of the information required to install this data engine. Mine looks like the following:

[Desktop Entry]
Encoding=UTF-8
Name=twitterdataengine
Type=Service
ServiceTypes=Plasma/DataEngine
X-Plasma-API=python
X-Plasma-MainScript=code/main.py
X-KDE-PluginInfo-Author=ScaryClam
X-KDE-PluginInfo-Email=twitterdataengine@scaryclam.co.uk
X-KDE-PluginInfo-Name=twitterdataengine
X-KDE-PluginInfo-Version=1.0
X-KDE-PluginInfo-Website=http://plasma.kde.org/
X-KDE-PluginInfo-Category=Examples
X-KDE-PluginInfo-Depends=
X-KDE-PluginInfo-License=GPL
X-KDE-PluginInfo-EnabledByDefault=true

When the main.py and metadata.desktop file are complete, the contents need zipping. From the base directory for this dataengine run:
$ zip -r twitterdataengine.zip *
Which should zip the entire directory structure into a file named twitterdataengine.zip.

Installing the data engine required the command:
$ plasmapkg -t dataengine -i twitterdataengine.zip

As a side note, removing the data engine also requires the -t dataengine option, obvious when you know but a pain when you’re not thinking and leave it out.

OK, if everything went smoothly the data engine is now installed and ready to be used. A nice little utility for examining data engine is plasmaengine which allows you to have a look at the different engines available and their current sources/values.

Now for the plasmoid to make use of the data engine!

from PyQt4.QtCore import *
from PyQt4.QtGui import *
from PyKDE4.plasma import Plasma
from PyKDE4 import plasmascript

class TwitterClient(plasmascript.Applet):
    def __init__(self,parent,args=None):
        plasmascript.Applet.__init__(self,parent)

    def init(self):
        # Make a widget, 300x300, no configuration (to keep this simple) and
        # connect to the data engine
        self.setHasConfigurationInterface(False)
        self.resize(300, 300)
        self.setAspectRatioMode(Plasma.Square)
        self.status_text = 'No Status set!'
        self.connectToEngine()

    def paintInterface(self, painter, option, rect):
        # This will just print the status text into an otherwise blank widget
        painter.save()
        painter.setPen(Qt.white)
        painter.drawText(rect, Qt.AlignVCenter | Qt.AlignHCenter,
                         self.status_text)
        painter.restore()

    def connectToEngine(self):
        # Connect to the source "username" in the twitterdataengine data engine,
        # every 30000 milliseconds (30 seconds)
        self.twitterEngine = self.dataEngine("twitterdataengine")
        self.twitterEngine.connectSource('username', self, 30000)

    # This will get called when polled
    @pyqtSignature("dataUpdated(const QString &, const Plasma::DataEngine::Data &)")
    def dataUpdated(self, sourceName, data):
        # data contains all of the data from the source requested. In this case
        # it just has one key: "Status"
        status = data[QString("Status")]
        self.status_text = status
        self.update()

def CreateApplet(parent):
    # Create applet
    return TwitterClient(parent)

Again, this should go into the main.py file and the directory structure is:
.
| — contents
|     `– code
|          |– main.py
| — metadata.desktop
` — twitterclient.zip

The metadata.desktop file is:
[Desktop Entry]
Encoding=UTF-8
Name=TwitterClient
Type=Service
ServiceTypes=Plasma/Applet
Icon=games-hint
X-Plasma-API=python
X-Plasma-MainScript=code/main.py
X-KDE-PluginInfo-Author=ScaryClam
X-KDE-PluginInfo-Email=twitterclient@scaryclam.co.uk
X-KDE-PluginInfo-Name=twitter_client
X-KDE-PluginInfo-Version=1.0
X-KDE-PluginInfo-Website=http://plasma.kde.org/
X-KDE-PluginInfo-Category=Examples
X-KDE-PluginInfo-Depends=
X-KDE-PluginInfo-License=GPL
X-KDE-PluginInfo-EnabledByDefault=true

Zip up the directory contents (in the same way as the data engine) and then install using:

$ plasmapkg -i twitter_client.zip

If successful, the installed plasmoid can be seen by using the plasmoidviewer utility:

$ plasmoidviewer twitter_client

Hopefully there is now a widget showing the status text of the twitter user entered.

Lately I’ve been using DeviceKit via DBus in Python as part of my work. The DeviceKit documentation is actually pretty good but I have found that it lacks examples. I’ve had trouble finding much via Google either so I thought it might be nice to post up some short blog articles as I find things out.

I have a need to be able to partition USB compact flash cards and here’s an example that works for me, broken up so I can give some explanation as I go:

import dbus

bus = dbus.SystemBus()
proxy = bus.get_object('org.freedesktop.DeviceKit.Disks', '/org/freedesktop/DeviceKit/Disks')
iface = dbus.Interface(proxy, "org.freedesktop.DeviceKit.Disks")

cur_dev = bus.get_object('org.freedesktop.DeviceKit.Disks', '/org/freedesktop/DeviceKit/Disks/devices/sdb')
device_int = dbus.Interface(cur_dev, 'org.freedesktop.DeviceKit.Disks.Device')

Lines 3, 4 and 5 are getting and interface to DeviceKit from DBus. Lines 4 and 5 may not be necessary but are useful to have if you don’t know the device name yet and wan tot enumerate through the devices and see what’s there.

Lines 7 and 8 are getting an interface to a specific device, which in this case is a USB card reader on /dev/sdb. I have a 1Gig SanDisk compact flash card, without any partitions, plugged into the card reader.

Now that there is a device interface, I can start using it to partition that card:

device_int.PartitionTableCreate('none', [])
device_int.PartitionTableCreate('mbr', [])
device_int.PartitionCreate(0, 1019215872, '06', '', [], [], 'vfat', [])

device_int.PartitionTableCreate() can take 2 arguments: scheme and options. For more information on the schemes and options allowed see this page as it does a better job than I will at explaining. Here I’ve opted, mainly to just help with the example, to call it twice; once with ‘none’ as the scheme and once with ‘mbr’. The ‘none’ scheme will clear anything that happened to be there before and ‘mbr’ sets up the master boot record at the start of the disk.
Line 3 shows an actual partition being created. The arguments are as follows: offset, size, type, label, flags, options, fstype, fsoptions). The above makes a FAT32 partition, just shy of 1Gig in size.

Normally this would be the end as the partition has been created. However, if you wan to removed partitions the following may be helpful:

cur_dev = bus.get_object('org.freedesktop.DeviceKit.Disks', '/org/freedesktop/DeviceKit/Disks/devices/sdb1')
sdb1_dev = dbus.Interface(cur_dev, 'org.freedesktop.DeviceKit.Disks.Device')
sdb1_dev.PartitionDelete('')

Line 1 gets an interface to the device /dev/sdb1, which is the partition that I have just created and wish to delete. As before, an interface is required to work on the device. Line 2 retrieves one.

Finally the delete is preformed using PartitionDelete(). The disk should now have no partitions.

I’ve only just started using DeviceKit so apologies for missing things or getting things wrong. I’d more than welcome any corrections and tips!

There’s lots of information on DeviceKit Devices which can be found here and I would recommend it as reading for anyone who needs to work with it.

I’ve installed WordPress and decided to move the site onto it. While I love messing around with web technologies I never get around to finishing things and this way I get to have a shiny web site while still having room to play!

Last night I tried out WordPress, Drupal and Joomla. Joomla suggested I install a bunch of example data, which I did. While I appreciate that this could be useful for beginners, I spent more time cleaning up the mess than it would haven taken to read through a tutorial on how to get started.

Drupal looks like it’ll be a great resource but it also lives up to its reputation of having a bit of a learning curve. Perhaps in the future I’ll come back to this one but for now I just want something quick and easy.