PostRank is a scoring system developed by AideRSS to rank any kind of online content, such as RSS feed items, blog posts, articles, or news stories. PostRank is based on social engagement, which refers to how interesting or relevant people have found an item or category to be.

Public-facing RESTful API’s are becoming more popular as a way to allow access to services by third-parties. AideRSS recently decoupled their PostRank service and offered it as a stand-alone service allowing any developer to use PostRank within their application. I am in the process of updating this website/blog and I am planning to make use of the PostRank service not only as a tool to measure my engagement with the public, but increase the usefulness of my posts.

What is PostRank Python API and what does it do?

This is an api accessor for python that allows a developer to quickly access all of the services offered by PostRank. It is loosely modeled after Mike Verdone’s Python Twitter Tools in that it is simple to use, and it uses the same arguments as those documented on the PostRank API page.

What are the requirements?

• Python 2.5 (haven’t tested with <2.4)
• simplejson python library (if using json output)

How do I use it?

Using the PostRank Python API is very easy. The first step should be to look at the API documentation provided by the PostRank website.

We can see what options the api needs in order to satisfy the request. We just need to specify the resource that we want to use, then we can add all the arguments we want passed along to PostRank.

If you have selected JSON as your format, the api will return to you a simplejson object which can be accessed just like a multi-dimensional array. When using JSON, it is extremely simple to get at the information provided by PostRank.

There is a bit of a trick when using the ‘postrank‘ resource but it certainly isn’t difficult to use. It works the exact same way – the PostRank API says it wants an array of urls (url[]) so we will pass in an array of urls as an argument (same thing for the feed_id[]).

Following the same pattern as before, we just pass in the resource we want to use and the API arguments.

There really isn’t much more to it. For now, you can find the python library here: http://newthink.net/~ash/software/postrankapi/ When my new website is done, I plan to find a more permanent place for this (and future software). Next step, creating an egg and integrating with ez_install.

I am quite familiar with PHP, so I set out to try to do the same things in rails as I would in PHP. Everything seemed to transfer over without effort… except file upload inputs. These kept me busy for quite some time, and had me wanting to pull out my hair.

I tried to make use of the community; exploring the wiki, reading through the rails cookbook, seeking out blogs that addressed the issue, visiting #rubyonrails on irc.freenode.net on a regular basis. Infact, the IRC community was referring me to the wiki article (HowtoUploadFiles). No matter how I tried, the upload just wouldnt work. I had narrowed the problem down to the multipart => “true” definition, but that was about as far as I could get without help. Luckily, I know a few rails nunjas (gurus) who helped me figure out what to do.

As it turns out, the rails wiki was incorrect. Since the project is opensource, it was easy enough for me to fix the documentation (perhaps the documentation was for a previous version of rails, and hadn’t been updated), but it was still a frustrating week (I was actually only working on it maybe and hour a night, but still) especially since it was such a simple task I was trying to complete.

Hopefully there are no more hiccups like this as I go forward. I am already thinking about a cool new idea which I am excited to work on once I complete this test application.

The book covers Rails development from the beginners level to the fairly advanced. It offers an easy tutorial which one can follow along, and gives a decent amount of information about most of the features they have available.

One of the biggest features that the Rails framework offers is migration. Although it is a fairly small part of Rails, it is a technology which I know is useful to many companies. At Pason, we created our own technology that basically does the same task as migration. It would have been nice to just use the Rails’ migration instead of developing our own.

The biggest issue I am having now, is getting back into the Python-style of coding. Ruby and Python are fairly similar… and very much different from Java and C++ which I am more familiar with. There are also a few speedbumps I am noticing when working on my first Rails project, but I hope to overcome them soon.

Basically, the problem comes from having the POST information still resident after an HTTP POST. If the user were to refresh their browser, that POST information will be resent, resulting in a double post. There are many ways to solve this problem, but the one I will outline (in PHP) seemed like the best for my situation.

Let us assume we have a text input and a button and that our form.php file will process our form as well as present it to the user (yes, I know this isn’t a good idea, but it is just an example).

<form method=”post” action=”form.php”>
    <input name=”mytext” />
    <input name=”submitBtn” type=”submit” />
</form>

When we load the page, we are going to check whether the $_POST variable is set. If it is, then we are going to do something with it.

session_start();

if(isset($_POST['mytext']))
{
    saveToDatabase($_POST['mytext']);
}

Now that we are doing something with this $_POST['mytext'] variable, we can see the double-post problem materialize. Since the HTTP POST is still populated, when the user presses refresh on their browser, the $_POST['mytext'] will be saved to the database twice.

What we need to do is get rid of the $_POST variable after we are done using it.

At the beginning of the form.php file I am going to create a server-side session to store any post information we get. Then I have a check to see whether the $_POST array has been populated.

If the $_POST has been populated, we are going to store the post information in the server-side session we have started and we send a blank header back out (which removes the HTTP POST).

if (isset($_POST['myText']))
{
    $_SESSION['myText'] = $_POST['myText'];
    header(“Location: form.php”);
}

Now, we have gotten rid of the POST which removes the double-post problem, and have stored the information from the $_POST for use. We can then access the POST information stored in the session. Once we have copied the POST information from the session, we will unset the session so that the information doesn’t stay resident.

if (isset($_SESSION['myText']))
{
    $myEnteredText = $_SESSION['myText'];
    unset($_SESSION['myText']);
}

Now you can use the POST information without running the risk of a double post.

If you would like to see this tutorial in action, create a form.php file on your webserver, and paste the following:

<?
    session_start();

    if (isset($_SESSION['myText']))
    {
        $myEnteredText = $_SESSION['myText'];
        unset($_SESSION['myText']);
    }

    if (isset($_POST['myText']))
    {
        $_SESSION['myText'] = $_POST['myText'];
        header(“Location: form.php”);
    }
?>

<html>
<head>

</head>
<body>

<form action=”form.php” method=”POST”>

<?
    if (isset($myEnteredText))
    {
        echo “<p>The message you entered was \”".$myEnteredText.”\”</p>”;
    }
?>

<input name=”myText” type=”text” />
<input name=”submitBtn” type=”submit” value=”ok” />

</form>
</body>

</html>

Now, I know not everyone has a Linux machine just lying around, but I do, and maybe in the future it might be enough to convince you to build your own file-server for your home (for media perhaps?).

Before starting, you need to make sure you have the ffmpeg binary installed on your Linux box. As of this posting, I have ffmpeg-0.4.9-0.3.20051207.2.el4.rf installed on my CentOS4 machine. I will leave it as an exercise to you to figure out how to install it if you don’t have it.

ash@galactica:[/tmp]> ffmpeg -vcodec xvid -b 500 -qmin 1 -qmax 7 -bufsize 4096 -g 300 -acodec aac -ab 96 -i doctor.who.102.the.end.of.the.world.avi -s 320×240 -aspect 16:9 doctor.who.102.the.end.of.the.world.mp4

Here is a run down of what the switches mean and how they affect your converted video:

-vcodec — this is the video codec you want the converted video to use. For iPod use, I suggest xvid. It is basically the same codec as mpeg4 (except open source) and you don’t run into buffer-underflow problems as often.

-b — this is the video bitrate in kbit/s (higher bitrate means higher quality).

-qmin & -qmax — this controls the quality when dealing with VBR (variable bit rate). Basically a range to keep the quality between.

-acodec — the audio codec to use. When converting to iPod video, this must be aac since that is the only format the iPod supports.

-ab — this is the audio bitrate in kbit/s. 96 kbit/s offers decent audio quality for iPod use.

-i — input file (obviously?).

-s — size of the output video. The iPod supports 320×240, 480×480 and with the newest firmware, now supports 640×480. If you want to retain the source aspect ratio, make sure you calculate the new size to follow the sources aspect ratio.

-aspect — aspect ratio for the converted video. This is especially important if your input video is 16:9 and you want to keep the ratio and replace the extra space with black bars. The aspect ratio is usually 4:3 or 16:9.

Now,after you have run this command, your video should begin to be converted. The time it takes to convert depends greatly on the hardware being used. I often offload this task to a P-III 800 machine, and it seems to be able to encode a video in the same time it would take to watch it. Again, the nice thing about offloading this task is that you can now use your main system for other fun tasks.

Might I suggest maybe using your main machine to whip up a quick script to encode a list of videos, perhaps at night when spare cpu cycles are pleniful? The nice thing about batching up video conversions like this, is that it is also compatible with mac’s running OSX. Sure, you could use the mac-GUI program to do it, but that is going to require a whole lot more human interaction to convert 10 shows.

For mor information of supported codecs, see the FFMPEG Documentation