We are not sure how our users would react if we remove the X screen savers and replace them by a new solution. We would like you to contribute and share your opinion. Tell us why you need screen savers and how you would think about if the currently used screen saver could no longer be used.

Fortunately, the Nepomuk developers have come up with a high level API to query already stored metadata, and today’s post will deal with querying tags in Nepomuk. As per the past tutorials, the full source code is available in the kdeexamples module.

Let’s start off with the basic imports:

import sys

import PyQt4.QtCore as QtCore

import PyKDE4.kdecore as kdecore
import PyKDE4.kdeui as kdeui
from PyKDE4.kio import KIO
from PyKDE4.nepomuk import Nepomuk
from PyKDE4.soprano import Soprano

Then let’s create a simple class that wil be used for the rest of this exercise:

class NepomukTagQueryExample(QtCore.QObject):

    def __init__(self, parent=None):

        super(NepomukTagQueryExample, self).__init__(parent)

__init__ is just used to construct the instance, nothing more. The bulk of the work is in the query_tag() function, which we’ll take a look at in parts.

    def query_tag(self, tag):

        """Query for a specific tag."""

        tag = Nepomuk.Tag(tag)

First of all we convert the tag we want to query into a proper Nepomuk.Tag() instance. Of course we should use an already existing tag: even if Nepomuk.Tag() automatically creates new tags, it makes little sense to query for a newly created tag, doesn’t it?

For our job, we need to use properties which define the terms of our query. As we’re looking for tags, we’ll use Soprano.Vocabulary.NAO.hasTag():

        soprano_term_uri = Soprano.Vocabulary.NAO.hasTag()
        nepomuk_property = Nepomuk.Types.Property(soprano_term_uri)

The first call generates an URI pointing to a specific RDF resource for this specific term, which is then wrapped as a Nepomuk.Types.Property in the second call. While the C++ API docs don’t show this, I found it to be necessary, or the Python interpreter would raise a TypeError. Notice that this is not the only term we can use: aside for tags, there are a lot of other URIs we can use for querying, listed in the Soprano API docs.

Once we have our property set up, it’s time to define which kind of query we’re going to use. In this case, since we want to check for the presence of tags, we use a Nepomuk.Query.ComparisonTerm, which is a query term used to match values of specific properties (in our case, tags):

        comparison_term = Nepomuk.Query.ComparisonTerm(nepomuk_property,
                Nepomuk.Query.ResourceTerm(tag))

Our tag is wrapped in a ResourceTerm, which is used exactly for the purpose. Now we make the proper query: in this specific case, we want to look up files tagged, so we use a FileQuery. We could also get other items, such as mails (in Akonadi): in that case we could use a a Nepomuk.Query.Query():

        query = Nepomuk.Query.FileQuery(comparison_term)

Lastly, we want to get some results out of this query. There are different methods, but for this tutorial we’ll use the tried-and-tested KIO technology:

        search_url = query.toSearchUrl()
        search_job = KIO.listDir(kdecore.KUrl(search_url))
        search_job.entries.connect(self.search_slot)
        search_job.result.connect(search_job.entries.disconnect)

First we convert the query to a nepomuksearch:// url, which then we pass to KIO.listDir, to list the entries. Unlike my previous post on KIO, this job emits entries() every time one is found, so we connect the signal to our search_slot method. We also connect the job’s result() signal in a way that it will disconnect the job once it’s over.

Finally, let’s take a look at the search_slot function:

    def search_slot(self, job, data):

        # We may get invalid entries, so skip those
        if not data:
            return

        for item in data:
            print item.stringValue(KIO.UDSEntry.UDS_DISPLAY_NAME)

Entries are emitted as UDSEntries: to get something at least understandable, we turn them into the file name, which is obtained by the stringValue() call using KIO.UDSEntry.UDS_DISPLAY_NAME.

That’s it. As you can see, it was pretty easy. Of course there’s more than that. For further reading, take a look at Nepomuk’s Query API docs, and Query Examples. Bear in mind however that to the best of my knowledge, the “fancy operators” mentioned there will not work with Python.

Happy Nepomuk querying!

Defining the problem

Since Eisen’s original paper on clustering, this form of analysis has been widely used by a lot of researchers. However, as it is known, such systems may be susceptible to an ordering bias: in other words, the order of the samples and/or genes might influence the final result. That’s why popular software such as TMeV offers alternative approaches, based on bootstrapping. 

In this specific form of bootstrapping, the samples and/or genes are randomly shuffled a number of times (1000 or more iterations are a good starting point) and the resulting dendrograms checked for consistency and robustness of partitioning. In other words, a p-value is calculated, our null hypothesis being that the arrangement of samples/genes is merely due by chance. Depending on the software, this value might be expressed either in form of p-value or percentage (TMeV calls it support). 

In the past years, I found an interesting method developed by Hidetoshi Shimodaira: the technique, called multiscale bootstrap resampling, aims at determining more accurate p-values out of the bootstrapping. Shimodaira calls the resulting p-value an AU value, where AU stands for “approximately unbiased”, a more precise p-value than the one obtained through bootstrapping alone.

In addition to this nice algorithm, a R package was also provided, named pvclust (it’s available on your favorite CRAN mirror). And that’s exactly what we’ll use for this exercise.

Prerequisites

Some of the readers of this blog might remember my disdain of R: while I need to use it for Bioconductor, I’m often annoyed by its weird syntax, and difficult to understand error messages. Luckily, thanks to the hard work of Laurent Gautier and contributors, there’s rpy2, a nice R-to-Python bridge. All the examples here require this package, version 2.1 or newer (I’d recommend the release candidate of 2.2, it’s really nice). Unfortunately, this means that Windows users are out of luck as there’s no version of rpy2 2.1 or 2.2 available for that platform..

Also, don’t forget to have the pvclust package installed in R.

Loading and preparing the data

import rpy2.robjects as robjects
from rpy2.robjects.packages import importr

base = importr("base")
pvclust = importr("pvclust")

dataframe = robjects.DataFrame.from_csvfile("GSE4984.txt", sep="\t ", row_names=1)

rows = robjects.IntVector(range(1,501))
subset = dataframe.rx(rows, True)

subset <- dataframe[rows, ]

result = pvclust.pvclust(subset, nboot=100, method_dist="correlation", method_hclust="average")

matrix = base.as_matrix(subset)
subset_transposed = matrix.transpose()
result_rows = pvclust(subset_tranposed, nboot=100, method_dist="correlation", method_hclust="average")

graphics = importr("graphics")
graphics.plot(result)

graphics = importr("graphics")
grdevices = importr("grDevices")
grdevices.pdf("myresult.pdf", paper="a4")
graphics.plot(result)
grdevices.dev_off()

gplots = importr("gplots")
row_dendrogram = result_rows.rx2("hclust")
column_dendrogram = result.rx2("hclust")
gplots.heatmap_2(subset, Rowv=row_dendrogram, Colv=column_dendrogram, col=gplots.greenred(255), density_info="none")

Recently I had the opportunity of viewing a DVD that I had bought in 2006 but never had the chance of seeing: it was the third season of Galaxy Angel, of which I had already viewed the first two years before. After viewing it, I realized I could have viewed it sooner, as I liked it quite a bit. Not only that, but I brought myself up to speed by getting what was left in the series, that is the second half of the third season (marketed by Bandai Visual as Galaxy Angel AA) and the fourth and final season (known in the English speaking market as Galaxy Angel X).

Well, I found the whole franchise quite good: and after having explored also other bits of it, including the manga and the games related to it, I thought it’d be nice to have a retrospective with my own views. Which is the point of this post.

Galaxy Angel? What was it about?

I was initially aware of the whole matter when Project G.A. was announced by BROCCOLI (for those who don’t know, it is, or at least used to be, a large merchandising company which also owned the GAMERS anime chain until very recently) at the Tokyo Game Show in 2000.  

At the time the designs were very preliminary and they showed mostly about the game (more on that later) than on the TV series that was going to be made by Madhouse.  As you may already know, BROCCOLI thought of this whole matter as a rather spread initiative, encompassing different medias: games, a TV series (13 episodes in total) a manga (made by the Kanan, the same person who did the original designs) plus a lot of merchandise and associated bits.

But back then, it was all yet to come. I admit I didn’t pay attention much to the announcement and moved on.

It was only years later that I bought the animated series, in 2004, that is when BROCCOLI USA opened and a partnership with Bandai Visual was formed to bring the anime and the manga to the English-speaking market.

The animated series

Season 1 – Galaxy Angel

   

   

Season 2 – Galaxy Angel Z

   

   

The second season (known as Galaxy Angel Z outside Japan) introduces a format that will become common: assemble two episodes (which are half as long as a common anime episode) separated by the eye-catch. In this case we’re looking at 18 episodes, or rather 9 in total. Compared to its predecessor, elements of parody and marked non-sense begin appearing, which make the show even more enjoyable. Also the cast has better interactions than in the first series, leading to truly hilarious moments.

One episode in my opinion stands out, because much more of this type will be featured in later series, is the second, ウェディングケーキ合体スペシャル (Wedding Cake Gattai Special, aka Wedding Cake combined Special). In this specific episode, we see the Angels having to pilot a robot which is basically a reference to a number of 1970s and early 1980s mecha shows, in particular Combattler V  and Voltes V. I would rather say rather try to pilot, as the thing explodes every time combination is attempted… But this is not the only element of parody there: a scene where Milfeulle rides a scooter to reach her vehicle is a mock of Daisuke Umon / Duke Fleed’s rocket “motorbike” in the launch sequence of Grendizer. The final icing on the cake is the song played in the background, たたかえ！ぼくらのX X X (Fight! Our X X X), sung by a real singer of mecha shows and tokusatsu sentai. The X X X in there because the mecha blows up exactly when the song would say its supposed name.

Like the original Galaxy Angel this series ends with a non-ending, showing something great about to happen “but now it’s the last episode” and thus ending in an anti-climactic way. Still, the game was about to come out and a third series was in the works.

Season 3 – Galaxy Angel A & Galaxy Angel AA

This section is the longest when dealing to the anime, because it is the longest of the four, featuring 52 half-length episodes, and a few specials on the way. This is in my opinion the best of the bunch, where the mixture of the interactions among the cast and decidedly weird plots form a very nice mixture.

I mentioned the plots. Well, starting from this series the parody / non-sensical element is much more noticeable, and often every episode would lose every bit of sanity within seconds. The situations where the Angels fall in also are even stranger than in the previous series (although they magically get fixed in time for the next episode). 

Regarding parody this series stars a number of successful experiments. In primis, one episode, サインはブイヨン (Sign wa Bouillon), which is a complete parody of famous sports anime like Attacker no. 1 (the song sung in the end, あたしたちがNo.1, or We are no.1, is a direct reference), featuring improbable and out-of-the-line volleyball techniques, but also references to Ultraman and Cyborg 009 (such as Forte’s acceleration, complete with spark on the teeth). In the end there’s even a “next episode” that puts together all the possible cliches.

However if I were to pick, parody-wise, two episodes from this series, I’d definitely choose ピュルリクマジカルステーキ (Pyururiku Magical Steak) and 新鮮 鯛づくし (Shinsen Taizukushi) because they bring that element to a new level.

The first of the two is an all out reference to the “magical girl” series, where the Angels (and Volcott, too!) try to use a magic stick that would grant a wish to a truly believer in magic. This somehow ends up in a sort of clip where lots of historical shows are referenced, as shown in the images below. 

The series reference relatively recent productions such as Doremi, but also real antiquities (for the Japanese, at least) such as Megu-chan (the Italian readers of this blog may know it as Bia e la sfida della magia), touching also video games. How many references did you find in the image shown above? This video shows all of them. As you can see are quite a lot. The song is also performed by a veteran of such series.

The second parody episode I mentioned instead is a reference to super sentai series, where the Angels have to fight as a group known as the “Angel Five”. Also this episode compresses a full-length sentai 52 episode series in little less than fifteen minutes.

Almost all the cliches are touched, including also a reference to the first Kamen Raider series and the always present narrator that tells  how things go on. Oh, and I should not forget about the obligatory mecha scenes (with the combination of the girls’ 紋章機 – monshoki or rather emblem frames - referencing the usual lack of budgets of these series). Just like the previous episode, there’s even a specific song for the various scenes.

The last mention for this series is the last episode, final dish REBECCA, which is actually full-length. In contrast with most of the series, there’s not a single trace of humor. It’s like one of the few serious episodes scattered through the series but in a more coherent and longer form.

Despite the difference, the essential psychology of the characters is not changed at all (in fact some bits reminded me of the game) and the whole story fits perfectly as ending of the series (open ended, also with Masami Okui and JAM Project’s In the Chaos as ending song). If Galaxy Angel had to end there, final dish REBECCA would have been ideal. By the way it was done, I also feel that this season was to be the last one, but the decision changed only later on.

Season 4 – Galaxy Angel X

   

   

The last of the seasons is also the one of the most absurd, because the parody and nonsense elements increase dramatically. Usually it’s impossible to predict where an episode would end up to being, because aside the initial settings they almost go completely random (but they’re rather funny). The craziness affects even episode titles, which become tongue-twisters that also play on assonance: an example 非凡平凡チョコボンボン (Hibon Heibon Choko bonbon, translatable as Extraordinary, ordinary chocolate bonbon).

On the parody side, an episode like 哀しみ憎しみ凍み豆腐 (Kanashimi nikushimi shimi tofu, or Sadness and Hatred Tofu in the English translation) replicates (very faithfully, I might add) the aura of Japanese dramas, complete with rather improbable plot twists and character relations (who is the daughter of who?). Another episode, ラブ米, feels like a session of Tokimeki Memorial, with the Angels infiltrated in a school-like environment (complete with stereotypes) and with an insert song performed by a singer that actually did some of the game’s songs. 

Along with the already present characters, this season also includes  Chitose Karasuma, but she’s completely different than the game counterpart, with a personality bordering on psychopathic. She doesn’t appear very often in the season as well, but she leaves her mark, definitely. 

The last episode (オールオッケーロケ弁当, All OK bento) is somehow meta as due to plot reasons it almost feels that the main voice actors are speaking about their characters, in a way. However, near the end the nonsense returns, showing a “battlefront” against aliens that is more reminiscent of the tennis anime エースをねらえ！(Ace o nerae! or Aim for the Ace!) as the “battle” is played at table tennis. Other notable mentions which also include the appearance of a character from the 1970s Great Mazinger series, namely 闇黒大将軍 (Ankoku Daishogun, or Great Dark General). but with the face of Di Gi Charat‘s Digiko…

Unfortunately the last episode is a bit of a let down because it’s half-length, unlike final dish REBECCA,  and thus the final part is a bit rushed. It’s not a bad ending per se, anyway, and doesn’t affect the overall quality of the series. Series which despite its length never really bored me and provided many hours of enjoyment. Especially the latter seasons show a great coordination among the cast that increases the comical effect. 

To be very brief, watching this series, even now taht many years ahave passed, is definitely recommended.

The video games

How do I get it?

git clone http://git.gitorious.org/kde-vlc-snapper/kde-vlc-snapper.git

sudo python setup.py install

kdevlcsnapper

With the adoption of Review Board to facilitate code reviews, there were also requests for a REVIEW keyword that could close the review requests without asking the submitters to do so manually (which is slow and not always effective). Since the hooks for Git were written in Python, I thought I could give a hand there.

I looked into the Review Board API, which is a simple REST API: tasks are performed with HTTP GET, POST, or PUT. As I didn’t want to dive too much into the technicalities, I decided to use a wrapper that would make things easier: python-rest-client. Once that was in place, it was just a matter of adding some sugar to handle replies, errors and logging. All in 78 lines of code.

Now that the “field tests” passed with flying colors, I’m happy to announce that such a hook exists and is operational for KDE’s Git infrastructure. By using the REVIEW keyword at the start of a line, followed by a number, the hook will notify the Review Board instance and close the request. It will also publish a comment stating the commit’s SHA1 and the person who did it.

You can take a look at the finished results in this review request.

Credits for this also go to Ben “bcooksley” Cooksley for helping with testing and fixes, and Eike “Sho” Hein for helpful suggestions.