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()

So, I’ve decided to create one!

pynmea is a Python library for parsing NMEA sentences into more useful objects. In its current form, it uses mapping to ‘fill in’ an otherwise generic object with the information contained within the sentence. It’s a very basic solution right now but when all of the mappings are entered (right now there are a limited number but it’s pretty strait forward to add the one you want in if it’s missing) it provides a single object for each sentence.

In the future, I would very much like the library to be able to take a data stream as an input and just churn out sentences as objects, doing all the splitting and parsing for the developer.

The project is currently on google code: http://code.google.com/p/pynmea/.


$ losetup /dev/loop2 /path/to/image.img
$ mount /dev/loop2 /mnt/path


That’s it!

After much Googling I found someone stating that removing /var/tmp/kdecache-username resolved their problem. Sure enough renaming my kdecache-username directory reset a whole bunch of stuff but really messed up some of the system settings that I really wanted to keep. After some trial and error I found that just removing /var/tmp/kdecache-username/ksycoca* got rid of the lingering German language problems and allowed me to keep the rest of my desktop settings as they were.

I have no idea if this is a bug in KDE or if there’s an option to reset the caching that is responsible for this problem.

Out of the box, this is what was working (or not):

• The trackpad and both mouse buttons behave as normal
• Wireless: Not Working
• Ethernet: Working
• External monitor: Yes but only to the extent that an image was trying to show. My monitor was shredding the image and flickering. I should note that my monitor is a 24″ widesceen monitor so it’s quite possible that this was an issue. Will update this if I test on a more sensible screen / projector.
• Graphics are using VGA, will test more later as the Intel Pineview graphics chip looks like it’s supported in the xf86-video-intel 2.10.0 driver
• Bluetooth: Working
• Sound: Working
• Microphone: Not working (tested using Skype)

• Webcam: Working (tested using Skype)

With this all in mind (no wireless) I decided not to wipe off Windows quite yet. I used the Windows partitioning tool to shrink down the C:\ drive partition so that I could make a dual boot system. I then installed Kubuntu and rebooted into the nice new system. After this I connected the Netbook to my wired network and got online.

Getting Wireless working

I tried out two methods for getting wireless to work. I should note here that even though I got the wireless card working with ndiswrapper, I would recommend skipping ahead to installing the Realtek RTL 8192E driver as it performs much better.

NDiswrapper

I installed ndiswrapper and retrieved the RealTek wireless drivers from the Samsung website. After doing this the installation of the drivers was very straight forward. I found that I could find the local networks in the area but had lots of trouble connecting to my router, which is one of the better wireless routers on the market.

Realtek RTL 8192E Wireless driver

As there were issues with ndiswrapper, I carried on searching and came across this page. The part of the page that is of interest is:


#wireless
#Realtek RTL 8192E Wireless LAN 802.11n PCI-E NIC
wget http://www.dirk-hoeschen.de/temp/rtl819Xe.tar.gz
tar xzf rtl819Xe.tar.gz
./install.sh
#modprobe r8192_pci
iwconfig


These commands (with the exception of the lines starting with a # character) should typed at the command line.

I did not have to run the final two lines as KDE kindly informed me that my wireless card had been found just after I ran ./install.sh. I’m not actually sure why as I didn’t run the command as root so YMMV. With this driver the signal from all networks was noticeably higher than it was when using ndiswrapper and connection to my home router was quick and without issue. All in all a very happy result!

Wireless update

I’ve seen that some people who are installing Lucid are reporting that the Lucid kernel now has support for RTL8192E wireless devices. If you are planning on installing Linux on the Samsung N220 then I would highly recommend using a live distribution and finding out if wireless is enabled out of the box. This will save you the trouble of installing the above driver.

I can also report that after allowing Kubuntu to upgrade to either Lucid or Meerkat (I cannot remember right now and don’t have my netbook on me to verify which I upgraded to) wireless continues to work. I have no installed from scratch but at least upgrading did not break it!

Backlight Issues

Since getting the netbook I was not able to change the backlight setting. This meant that I was working with a dimmed screen. I finally got around to fixing this issue and I now have functioning brightness keys.

The solution that has worked for me was to install the samsung-backlight driver. I did this by adding the PPA to my sources list and installing the driver by executing the following commands:


sudo apt-add-repository ppa:voria/ppa
sudo aptitude update
sudo aptitude install samsung-backlight

The driver was successfully installed and after a reboot to check and see if the driver would automatically get loaded on boot I wasn’t disappointed to see that I was able to use the brightness keys as normal.

Exciting stuff, even for us non-physics bods!

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.

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.

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.