Free identified by software for linux

DupeFinder is a simple application for locating, renaming, moving and deleting duplicate files in a directory structure.
Its perfect both for users who havent kept their hard drives very well organized and need to do some cleaning to free space, and for users who like to keep lots of backup copies of important data "just in case" something bad should happen.
Main features:
Although DupeFinder is a quite small application, it should have all of the features you will need to remove and reorganize large directories full of duplicate files:
- Well designed graphical interface with full tooltip and "Whats This?" question button support, useful in an application which you probably wont need to use frequently
- Quick processing by eliminating analysis of unwanted data through file extension filtering
- View files in external applications by double-clicking
- Rename files in place or move to new locations
- Default settings disallow deletion of all copies of duplicate files to prevent accidental data loss
- Generate simple reports identifying groups of duplicate files for later processing
While everything works pretty well in most cases, there are a few issues with DupeFinder to be aware of. I hope to fix most of the following bugs sometime soon:
- May crash if files containing "~" or ":" characters are encountered
- May crash if self referencing symlinks are encountered
- Zero byte files cannot be deleted
- May not be able to delete files with Unicode characters in filename
- Display does not update if identified duplicates are moved, renamed or modified external to DupeFinder

Gentle.NET is an RDBMS independent object persistence framework. Gentle.NET features automatic SQL generation and object construction, an SQL factory for creating custom queries, DataView construction helpers, excellent performance and reasonably complete docs.
The framework defines a few attributes with which you have to decorate the objects you wish to persist. Decorate classes with the TableName attribute, and members (properties and fields as you see fit) with the TableColumn attribute.
There are additional attributes available which need only be used when no Analyzer class exists for the database you are using (see Database Provider - Implementation Status). The Analyzer classes are used to obtain metadata on the current schema directly from the database, thus bypassing the need for replicating this information in your code.
If no Analyzer exists, primary key columns must be decorated with the PrimaryKey attribute, and foreign keys and their mappings must be declared using the ForeignKey attribute. The TableColumn attribute provides properties allowing you to provide details on type, size and null-handling. If an Analyzer does exist, the information obtained automatically overrides any such setting.
Business objects may optionally inherit from the Persistent class, which provides a set of standard methods for persisting and retrieving objects. You can replicate these on a different base class if needed, or on a manager class if you prefer a more SOA-oriented design. Gentle provides support for identity columns (where the database assigns a primary key value to the row being inserted) to implementors of IPersistent (which includes the Persistent class).
The main access point into the framework functionality is provided by the PersistenceBroker class, which is responsible for orchestrating all access to a given database provider.
The PersistenceBroker is responsible for basic query construction and caching, as well as interaction with the database backends. You can create as many PersistenceBroker instances as needed, such as one for every database to which you need to connect. Various classes permit or require you to pass a PersistenceBroker instance, which will be used subsequently for all database operations performed by the class.
If you need to connect to a single database only, you can use the static Broker class, which delegates all calls to a default PersistenceBroker instance (using the DefaultProvider configured in the configuration file).
Persistent objects are identified by a Key, which is really just a Hashtable with some convenient methods for gathering property values from objects. The Key class knows how to populate itself when given an object instance and a set of property names, and also provides a means of obtaining a key holding just the primary key fields.
This is useful when constructing custom queries as constraints can be passed as Key instances to methods on both the (Persistence)Broker and SqlBuilder classes. This encapsulation also enables Gentle to work with multi-column primary keys.
To execute custom SQL statements use the SqlStatement class. Use the SqlBuilder class to construct instances of this class whenever the statement is for a supported type (i.e. a class decorated with the proper attributes as outlined above).
The SqlBuilder provides a database independent way of constructing queries and has many methods for adding constraints and otherwise customizing the query. It is used internally by the PersistenceBroker whenever it needs to generate statements.
You can declare a DataView layout using the CustomView attribute on the properties to include in the DataView. The actual DataView can be obtained using the ObjectView class by supplying an array of business objects.
Multiple statements can be transacted (grouped) using the Transaction class.
Enhancements:
- This release features a complete rewrite of the cache subsystem, with significant performance improvements as a result.
- There have also been several minor improvements and bugfixes throughout the code base.

doxWiki is a simple-to-use Wiki for a Web site, personal database, or flexible document source. It has a compatible mark-up language with powerful extensions.
doxWiki project can use any Web server or built-in personal server. The output is XHTML-compliant.
Enhancements:
- Jot mode added; different users (as identified by the IP address of their browser) can now keep separate BeenThere pages; editing textarea is now 100% width; bugs fixed in finding references by clicking on page title, in poetic mode, as well as errors fixed in WikiEdit; EasyWiki updated; FindWikiWords.pl command-line program added for ease of entering "donotlink" controls.

AudioFile::Identify::MusicBrainz is a pure-perl MusicBrainz client implementation.

A::I::M is, at heart, a pure-perl implementation of the MusicBrainz client protocol, encapsulated in some sensible Track/Album/Artist objects that have the sort of methods youd expect. So I can, given a Track object, go

my $some_title = $track->album->track(4)->artist->title;

Eventually, this is intended to be merely a plugin to a more general AudioFile::Identify architecture, along with such exciting things as A::I::Amazon, A::I::CDDB, etc, but until theyre ready and we have a decent API for it, its useful to have this out in the wild, as its very useful.

USAGE

See AudioFile::Identify::MusicBrainz::Query for details, but in summary:

use AudioFile::Identify::MusicBrainz::Query;
my $query = AudioFile::Identify::MusicBrainz::Query->new();
$query->FileInfoLookup(
artist => coldplay,
title => yellow,
items => 5,
) or die "Could not query: " . $query->error();
print "I got ".scalar(@{$query->results})." resultsn";

print "Most likely album is ".
$query->result(0)->album->title ."n";
print "Most likely trackNum is ".
$query->result(0)->track->trackNum ."n";

See AudioFile::Identify::MusicBrainz::Album, AudioFile::Identify::MusicBrainz::Artist and AudioFile::Identify::MusicBrainz::Track for details of the methods you can call on these returned objects.

Theres an example of its use in the examples folder in the tarball, tagger.pl (see tagger.pl). This is a utility that examines the ID3 tags of an MP3 file, and will print what MusicBrainz suggests for the rest of the tags.

GO::TermFinder is a Perl module that can identify GO nodes that annotate a group of genes with a significant p-value.

This package is intended to provide a method whereby the P-values of a set of GO annotations can be determined for a set of genes, based on the number of genes that exist in the particular genome (or in a selected background distribution from the genome), and their annotation, and the frequency with which the GO nodes are annotated across the provided set of genes.

The P-value is simply calculated using the hypergeometric distribution as the probability of x or more out of n genes having a given annotation, given that G of N have that annotation in the genome in general. We chose the hypergeometric distribution (sampling without replacement) since it is more accurate, though slower to calculate, than the binomial distibution (sampling with replacement).

In addition, a corrected p-value can be calculated, to correct for multiple hypothesis testing. The correction factor used is the total number of nodes to which the provided list of genes are annotated, excepting any nodes which have only a single annotation in the background, as a priori, we know that these cannot be significantly enriched.

The client has access to both the corrected and uncorrected values. It is also possible to correct the p-value using 1000 simulations, which control the Family Wise Error Rate - using this option suggests that the Bonferroni correction is in fact somewhat liberal, rather than conservative, as might be expected. Finally, the False Discovery Rate can also be calculated.

The general idea is that a list of genes may have been identified for some reason, e.g. they are coregulated, and TermFinder can be used to find out if any nodes annotate the set of genes to a level which is extremely improbable if the genes had simply been picked at random.

The BIND consists of a server (or `daemon) called `named and a resolver library.
A name server is a network service that enables clients to name resources or objects and share this information with other objects in the network.
BIND 8.4.5 is the latest version of ISC BIND 8; it is a maintenance release to BIND 8.4.0, which provides IPv6 transport support for named, named-xfer and ndc. It also includes the BIND 8.4.2 release which includes a security fix which prevents negative answers being cached from the wrong source. (also released as BIND 8.3.7).
Main features:
- a Domain Name System server (named)
- a Domain Name System resolver library
- tools for verifying the proper operation of the DNS server
Enhancements:
- This fixes the security problem identified as CVE-2007-2925.
- The problem is that the default access control lists (ACLs) are not being correctly set.
- If not set, anyone can make recursive queries and/or query the cache contents.

CGI::Test is a CGI regression test framework.

SYNOPSIS

# In some t/script.t regression test, for instance
use CGI::Test; # exports ok()

my $ct = CGI::Test->new(
-base_url => "http://some.server:1234/cgi-bin",
-cgi_dir => "/path/to/cgi-bin",
);

my $page = $ct->GET("http://some.server:1234/cgi-bin/script?arg=1");
ok 1, $page->content_type =~ m|text/htmlb|;

my $form = $page->forms->[0];
ok 2, $form->action eq "/cgi-bin/some_target";

my $menu = $form->menu_by_name("months");
ok 3, $menu->is_selected("January");
ok 4, !$menu->is_selected("March");
ok 5, $menu->multiple;

my $send = $form->submit_by_name("send_form");
ok 6, defined $send;

#
# Now interact with the CGI
#

$menu->select("March"); # "click" on the March label
my $answer = $send->press; # "click" on the send button
ok 7, $answer->is_ok; # and make sure we dont get an HTTP error

The CGI::Test module provides a CGI regression test framework which allows you to run your CGI programs offline, i.e. outside a web server, and interact with them programmatically, without the need to type data and click from a web browser.

If youre using the CGI module, you may be familiar with its offline testing mode. However, this mode is appropriate for simple things, and there is no support for conducting a full session with a stateful script. CGI::Test fills this gap by providing the necessary infrastructure to run CGI scripts, then parse the output to construct objects that can be queried, and on which you can interact to "play" with the scripts control widgets, finally submitting data back. And so on...
Note that the CGI scripts you can test with CGI::Test need not be implemented in Perl at all. As far as this framework is concerned, CGI scripts are executables that are run on a CGI-like environment and which produce an output.

To use the CGI::Test framework, you need to configure a CGI::Test object to act like a web server, by providing the URL base where CGI scripts lie on this pseudo-server, and which physical directory corresponds to that URL base.
From then on, you may issue GET and POST requests giving an URL, and the pseudo-server returns a CGI::Test::Page object representing the outcome of the request. This page may be an error, plain text, some binary data, or an HTML page (see CGI::Test::Page for details).

The latter (an HTML page) can contain one or more CGI forms (identified by tags), which are described by instances of CGI::Test::Form objects (see CGI::Test::Form for details).

Forms can be queried to see whether they contain a particular type of widget (menu, text area, button, etc...), of a particular name (thats the CGI parameter name). Once found, one may interact with a widget as the user would from a browser. Widgets are described by polymorphic objects which conform to the CGI::Test::Form::Widget type. The specific interaction that is offered depends on the dynamic type of the object (see CGI::Test::Form::Widget for details).

An interaction with a form ends by a submission of the form data to the server, and getting a reply back. This is done by pressing a submit button, and the press() routine returns a new page. Naturally, no server is contacted at all within the CGI::Test framework, and the CGI script is ran through a proper call to one of the GET/POST method on the CGI::Test object.

Finally, since CGI::Test is meant to be used from regression test scripts, it exports a single ok() routine which merely prints the messages expected by Test::Harness. This is the only functional routine in this module, all other accesses being made through a CGI::Test object.