Superloading Devel::REPL

Today I bumped into Class::Autouse, pointed by App::Cmd's docs. Essentially, it lets you defer the importing of a module until the code actually tries to use it. So, for instance, if you have:

	use Dep::1;
	use Dep::2;
	...
	use Dep::10;
	my $thing = Dep::2->new;

view raw gistfile1.pl hosted with ❤ by GitHub

The program will load Deps 1..10 before executing Dep:2's constructor. However, with

	my @deps; push "Dep::$_" for (1..10);
	use Class::Autouse @deps;
	my $thing = Dep::2->new;

view raw gistfile1.pl hosted with ❤ by GitHub

Only Dep::2 will be use-d before the instantiation of $thing.

This can be very useful in cases where an application's flow can take several different routes, and might not use all of its functionality in a single invocation. Padre, the Perl IDE, for example, makes extensive use of this module exactly for this reason.

But another cool feature of this library is its ':superloader' option. It allows you to import dependencies on the fly without explicitly saying so. For example:

	use Class::Autouse qw(:superloader);
	my $thing = Dep::2->new;

view raw gistfile1.pl hosted with ❤ by GitHub

Here, we don't predeclare any class in particular, we just use it. Notice that I said "class" and not "module"; this only works for object oriented libraries, ie., classes.

What's most useful about this is that it can be very convenient in cases where you don't know beforehand what classes you will be needing. In particular, I think this is a perfect addition to my Devel::REPL configuration file:

	# in ~/.repl/repl.rc:
	use Class::Autouse qw(:superloader);

view raw gistfile1.pl hosted with ❤ by GitHub

and then:

	brunov@dora:~$ re.pl
	$_ my $thing = Foo->new;
	$Foo1 = Foo=HASH(0xa77cb98)
	$_ my $other = Bar->new;
	$Bar1 = Bar=HASH(0xabc4eb8)

view raw gistfile1.txt hosted with ❤ by GitHub

Since I'm mostly doing exploration and debugging when using the REPL, correctness is not an issue, and not having to load things beforehand increases the whipuptitude and overall improves the coding experience.

A sequence translator folder using POE::Component::DirWatch::Object

So, I admit it. I hate coding GUIs. Probably because I don't have much experience doing it, but I hate it nevertheless. So when I bumped into POE::Component::DirWatch::Object and grasped some of the potential it had for kind of replacing a GUI in some simple scripts, I just had to try it.

What POE::Component::DirWatch::Object basically does is keep an eye on a folder, and act upon an event regarding it. For instance, using ::NewFile, it will trigger a user-defined function whenever a file is created in that directory. This might seem old news for the compsci people, but for me it was quite a new concept and I really liked it.

So to test-drive it, I decided that I'd code for a simple script (not too different than the module's synopsis, in retrospect) that would translate any DNA sequence that was created in it. This way, the user would just have to copy or move her desired sequence files to the "translate" (as I very imaginatively called it) folder, and they would automagically translate themselves.

The core of the script is:

	my $watcher = POE::Component::DirWatch::Object::NewFile->new(
	directory => '/home/brunov/translate',
	callback => \&translate,
	);
	sub translate { ... }
	$poe_kernel->run();

view raw translate-1.pl hosted with ❤ by GitHub

Simple, right? Here, $watcher will execute the translate subroutine whenever a new file is created in the /home/brunov/translate folder. The last line is needed to make POE do its magic. The script runs a daemon that never exits, and could be configured to start when you log in to your session.

The translate routine is pretty straightforward. It uses Bio::Seq for the translation part, and Bio::SeqIO for the file reading and writing. What it does is read the input file, translate all the translatable sequences that are in it, and write the results in a temporary file,
which is later used to replace the original one.

	sub translate {
	# Translate the input file from dna to protein, replacing the
	# original file. Sequences that are already protein remain
	# untouched.
	my ( $filename, $fullpath ) = @_;
	# Input sequence stream.
	my $seqI = Bio::SeqIO->new( -file => $fullpath );
	# Output sequence stream.
	my $tempfile = File::Temp->new( SUFFIX => '.fasta' )->filename;
	my $seqO = Bio::SeqIO->new(
	-file => ">$tempfile",
	-format => 'fasta'
	);
	# Translate dna sequences and write to temp file.
	while ( my $seq = $seqI->next_seq ) {
	if ( $seq->alphabet eq 'dna' ) {
	$seq = $seq->translate;
	}
	$seqO->write_seq($seq);
	}
	$_->close for ( $seqI, $seqO );
	# Replace the original file with the temporary one with the
	# translated sequences.
	move( $tempfile, $fullpath );
	}

view raw translate-2.pl hosted with ❤ by GitHub

That's all that is needed (minus a little error checking that I chose to leave out for the sake of bloggability).

Adding neat notifications

The script runs fine as it is, but it's kind of dull. Since there are no newly created files nor visible output, you are tempted to reopen the translated file to actually check that your DNA has been translated into protein. This is why I thought that adding system notifications would be appropiate.

Actually, bullshit. I just can't get enough of Ubuntu's sexy notification system, so I figured it'd be nice if a bubble popped up saying the outcome of the translation.

So doing some more CPAN digging, I found Gtk2::Notify. With a few extra lines of code, I got a chatty, ribosomy (get it?) folder. Here's the modified translate sub (minus old comments) and the new notify one:

	sub translate {
	my ( $filename, $fullpath ) = @_;
	my $seqI = Bio::SeqIO->new( -file => $fullpath );
	my $tempfile = File::Temp->new( SUFFIX => '.fasta' )->filename;
	my $seqO = Bio::SeqIO->new(
	-file => ">$tempfile",
	-format => 'fasta'
	);
	my $outcome = 0;
	while ( my $seq = $seqI->next_seq ) {
	if ( $seq->alphabet eq 'dna' ) {
	$seq = $seq->translate;
	$outcome = 1;
	}
	$seqO->write_seq($seq);
	}
	$_->close for ( $seqI, $seqO );
	# $outcome will be true only if seq is dna and move succeded.
	$outcome *= move( $tempfile, $fullpath );
	notify( $outcome, $filename ); # Preach it!
	}
	sub notify {
	my ( $success, $file ) = @_;
	my $message;
	if ( $success ) { $message = "Translated $file" }
	else { $message = "$file not translated" }
	Gtk2::Notify->new( 'Attention', $message )->show;
	}

view raw translate-3.pl hosted with ❤ by GitHub

And that's it! Now whenever you drop a file in the "translate" folder, all DNA sequences that are in it get translated (and those who are not are left untouched). This could allow for cute chained actions; one could have a whole hierarchy of live folders with things such as "reverse translate", "blast it", "predict solubility", "digest it" and so on. It is certainly not as flexible as good old CLI scripts, but it reaches a nice compromise between the user friendliness of a GUI and the batch processing capabilities of command-line fu.

Here's how it looks:



You can see the real-life script here.

P.S: And just to spite TIOBE people: Perl Programming rocks! And also Euphoria Programming and SuperCollider Programming, of course.