Free acme test weather 0.2 software for linux

Better Weather contains a couple of scripts using normal KDE and Linux tools to provide better display of weather info than KDEs weather applet. It downloads the information from the US national weather service and maps from weather.com. Two launchers on the main menubar bring up the window separately. Full details and instructions are in the readme.

This is a solution that worked for me, not being a coder. You have to make it work for you. Its an idea and a set of tools. Its also US-centric, but someone may take the idea and make it work just as well anywhere. I hope someone finds it as useful as I do.

WHAT IT DOES

The tools I wrote are two *very* simple bash scripts. The script, localwx.sh, invokes the python weather utility, and downloads the current weather conditions and forecast in text format from the weather service. It stores the information temporarily in a text file (I chose the desktop as the directory in which to save it.) It then "reads" the text file into a kdialog box. When the "ok" button is clicked, the temporary file is deleted.

The other script, wxmap.sh, downloads a current local weather map image using wget, saves it temporarily to the desktop, and calls Kview to display it. When Kview closes, the temporary image file is deleted.

HOW I DID IT

The man pages for "weather," "kdialog," and "wget" were useful for determining which options to use. The script for weather forecasts has to be edited to receive the data for the users current location. My nearest airport is PDK, so my ID was "KPDK." The rest is straightforward enough. To make the weather map script work, you can go to weather.com or your local tv station website and copy the image location for the weather map they use. It can be pasted into the script.

Once the scripts were edited to suit, I made them executable (chmod +x filename), copied them to /usr/local/bin, and created a launcher for each in my main menubar. Describing the process is a lot more difficult than actually doing the work!

WeatherBug is a Firefox extension that can get live, local weather conditions in Firefox web browser. Featuring forecasts, radar, and severe weather alerts from WeatherBugs community of neighborhood weather stations.

Acme::Laugh is a Perl module that can add joy to your scripts.

SYNOPSIS

use Acme::Laugh qw( laugh );

print laugh(5); # print a short laugh
print laugh(50); # print a long laugh

Laughing is something that lets humans distinguish themselves from other forms of life. Now computers are nearer to us.

Have you ever needed to generate a laugh? I had: in IRC, to laugh at other people (for fun!). So, here we are!

INTERFACE

This module lets you export the laugh function:

my $l = laugh( $length );
my $l = laugh(); # Random length

This function accepts an optional $length parameter, which lets you trim the length of the generated laugh. This length has little to do with the actual string length (which you can trim later, if you want), but higher values generate longer laughs in average. Ok, peruse the code to see it!

Acme::Hyperindex is a Perl module to look deep into structures using a list of indexes.

SYNOPSIS

use strict;
use Acme::Hyperindex;

my @struct = (
{ j_psi => [qw( eta_prime phi kaon )] },
{ j_psi => [qw( selectron down tau_sneutrino )] },
{ j_psi => [qw( upsilon gluino photino )] }
);

print @struct[[ 2, j_psi, 1 ]], "n"; ### Prints gluino
my $row = @struct[[ 1, j_psi ]]; ### Row contains [qw( selectron down tau_sneutrino )]

When you use dynamic datastructures, the perl index syntax may not be felxible enough. A little examle:

my @struct = (
{
pion => [
[qw(strange j_psi positron)],
[qw(down_squark electron gluino)],
],
w_plus_wino => [
[qw(neutralino tau kaon)],
[qw(charm_squark photino strange_squark)]
],
},
);

Now to get to the kaon particle, normally we use:

my $particle = $struct[0]->{w_plus_wino}->[2];
-- or better --
my $particle = $struct[0]{w_plus_wino}[2];

But what if you dont know how deep your datastructure is at compile time? Course this is doable:

my $particle = @struct;
$particle = $particle->[$_] for qw(0 pion 2);

Two problems here: Perl will tell you Not an ARRAY reference once we try to index in the hash on pion with this array indexing syntax. Its damn ugly and looks complicated.

So Acme::Hyperindex lets you index arbitrary deep into data structures:

my $particle = @struct[[ 0, pion, 2 ]];
-- or even --
my $particle = @struct[[ @indexes ]];
-- or --
my $particle = @struct[[ get_index() ]];
-- or --
my $particle = @struct[[ $particleindexes[[ 3, 42 ]] ]];

Acme::Hyperindex now also lets you index on scalars, arrays and hashes:

$struct[[ ... ]];
@struct[[ ... ]];
%struct[[ ... ]];

And lists ary auto-derefed in list context:

my $struct = [ [qw(a b c)], [qw(d e f)] ];

my $foo = $struct[[ 0 ]]; # $foo contains a ref to qw(a b c)
my @foo = $struct[[ 0 ]]; # @foo contains qw(a b c)

Acme::Playmate is a Perl module to consult the playboy playmate directory for playmate information.

SYNOPSIS

use Acme::Playmate;

my $playmate = new Acme::Playmate("2003", "04");

print "Details for playmate " . $playmate->{ "Name" } . "n";
print "Birthdate" . $playmate->{ "BirthDate" } . "n";
print "Birthplace" . $playmate->{ "BirthPlace" } . "n";
print "Bust" . $playmate->{ "Bust" } . "n";
print "Waist" . $playmate->{ "Waist" } . "n";
print "Hips" . $playmate->{ "Hips" } . "n";
print "Height" . $playmate->{ "Height" } . "n";
print "Weight" . $playmate->{ "Weight" } . "n";

Test::Data is a Perl module to test functions for particular variable types.

SYNOPSIS

use Test::Data qw(Scalar Array Hash Function);

Test::Data provides utility functions to check properties and values of data and variables.

Functions

Plug-in modules define functions for each data type. See the appropriate module.

How it works

The Test::Data module simply emports functions from Test::Data::* modules. Each module defines a self-contained function, and puts that function name into @EXPORT. Test::Data defines its own import function, but that does not matter to the plug-in modules.

If you want to write a plug-in module, follow the example of one that already exists. Name the module Test::Data::Foo, where you replace Foo with the right name. Test::Data should automatically find it.