Free lucene software for linux

Lucene is a Perl API to the C++ port of the Lucene search engine.

SYNOPSIS

Initialize/Empty Lucene index

my $analyzer = new Lucene::Analysis::Standard::StandardAnalyzer();
my $store = Lucene::Store::FSDirectory->getDirectory("/home/lucene", 1);

my $tmp_writer = new Lucene::Index::IndexWriter($store, $analyzer, 1);
$tmp_writer->close;
undef $tmp_writer;

Choose your Analyzer (string tokenizer)

# lowercases text and splits it at non-letter characters
my $analyzer = new Lucene::Analysis::SimpleAnalyzer();
# same as before and removes stop words
my $analyzer = new Lucene::Analysis::StopAnalyzer();
# same as before but you provide your own stop words
my $analyzer = new Lucene::Analysis::StopAnalyzer([qw/that this in or and/]);
# splits text at whitespace characters
my $analyzer = new Lucene::Analysis::WhitespaceAnalyzer();
# lowercases text, tokenized it based on a grammer that
# leaves named authorities intact (e-mails, company names,
# web hostnames, IP addresses, etc) and removed stop words
my $analyzer = new Lucene::Analysis::Standard::StandardAnalyzer();
# same as before but you provide your own stop words
my $analyzer = new Lucene::Analysis::Standard::StandardAnalyzer([qw/that this in or and/]);
# takes string as it is (only when using clucene-0.9.17 or above)
my $analyzer = new Lucene::Analysis::KeywordAnalyzer();

Create a custom Analyzer

package MyAnalyzer;

use base Lucene::Analysis::Analyzer;

# You MUST called SUPER::new if you implement new()
sub new {
my $class = shift;
my $self = $class->SUPER::new();
# ...
return $self;
}

sub tokenStream {
my ($self, $field, $reader) = @_;
my $ret = new Lucene::Analysis::StandardTokenizer($reader);
if ($field eq "MyKeywordField") {
return $ret;
}
$ret = new Lucene::Analysis::LowerCaseFilter($ret);
$ret = new Lucene::Analysis::StopFilter($ret, [qw/foo bar bax/]);
return $ret;
}
package main;
my $analyzer = new MyAnalyzer;

Choose your Store (storage engine)

# in-memory storage
my $store = new Lucene::Store::RAMDirectory();
# disk-based storage
my $store = Lucene::Store::FSDirectory->getDirectory("/home/lucene", 0);

Open and configure an IndexWriter

my $writer = new Lucene::Index::IndexWriter($store, $analyzer, 0);
# optional settings for power users
$writer->setMergeFactor(100);
$writer->setUseCompoundFile(0);
$writer->setMaxFieldLength(255);
$writer->setMinMergeDocs(10);
$writer->setMaxMergeDocs(100);

Create Documents and add Fields

my $doc = new Lucene::Document;
# field gets analyzed, indexed and stored
$doc->add(Lucene::Document::Field->Text("content", $content));
# field gets indexed and stored
$doc->add(Lucene::Document::Field->Keyword("isbn", $isbn));
# field gets just stored
$doc->add(Lucene::Document::Field->UnIndexed("sales_rank", $sales_rank));
# field gets analyzed and indexed
$doc->add(Lucene::Document::Field->UnStored("categories", $categories));

PyLucene is a GCJ-compiled version of Java Lucene integrated with Python via SWIG.
PyLucene goal is to allow you to use Lucenes text indexing and searching capabilities from Python. It is designed to be API compatible with the latest version of Java Lucene.
PyLucene is supported on Mac OS X, Linux and Windows. Binaries for PyLucene are available below. See the INSTALL file for information about building PyLucene from sources.
Installation:
To build PyLucene from sources, please see the INSTALL file.
To install PyLucene binaries you just downloaded:
- install the files in the python directory into pythons site-packages directory
- if you downloaded binaries with Berkeley DB support, install the files in the db directory into the directory containing your Berkeley DB shared libraries, such as /usr/local/BerkeleyDB.4.3/lib
- if you are installing Unix (Mac OS X or Linux) binaries, install the files in the gcj directory into /usr/local/lib
Enhancements:
- This release wraps the newly-released Java Lucene 2.1.0.

kio-clucene provides an indexed search engine for KDE.
kio-clucene is a KDE search ioslave that uses clucene, a C++ implementation of lucene, a well-known full-featured text search engine library. kio-clucene gives any KDE application friendly access to searching the content of files inside directories, archives, and many virtual file systems. Optical character recognition (OCR) is supported by using a program like gocr, allowing the text content of images to be indexed.
Main features:
kio-clucene can search for
- full text content
- mimetype
- metainfo
- mod. dates
- path names
- multifield queries are possible (a multifield search-dialog can be used (or not))
kio-clucene can index
- local files
- remote files (ftp,pop3,... (basic support))
- archives (basic local support)
- read-only data stored on cds,dvds.
- text inside images using optical character recognition OCR programs like gocr
kio-clucene stores previews of
- all images
- all videos
kio-clucene can search on
- a single index
- multiple indexes
- Multithreaded search-daemon.
Integration with KDE
- kio-clucene integrates well to the existing kde-framework. You can use kio-clucene from
- konqueror location-bar
- kicker "run command"
- "Alt+F2" "run command"
- any apps, using the openfile dialog
- Example: from kpdf, you could open the file-dialog and search very fast for your pdfs like adobe acrobat reader can do.
The ioslave is build to be user-friendly
- it works a bit like KDE remote-ioslave
- it can call a search-dialog which allow for multifields queries
- it displays recent queries
- recent queries can be saved to desktop-files
- => this almost emulates "virtual folders"
Search-engine
- The search engine is based on clucene, a c++ implementation of apache/lucene. clucene allows for sophisticated queries like:
- proximity-words queries
- but kio-clucene does not implements queries of the form *substring yet.
Display of the results
- So far only standard KDE-listviews are used to display the URLs of the matching documents. No kpart is provided for the display/sorting of the results like beagle can do.
Instantaneous file indexing
- This is not provided by the indexer, but any KDE application can make use of DCOP to request the indexing of any URL. Instantaneous indexing is a kernel/kdecore problem. But Suse 9.3 already ships with beagle installed, and an inotify-enabled kernel. So those features should soon be available with KDE too.
kio-clucene build-system is Scons-enabled
- Kio-clucene make use of the scons build and install system.

Lucene::Search::Highlight is a Perl module with highlight terms in Lucene search results.

SYNOPSIS

Load highlight classes into namespace

use Lucene::Search::Highlight;

Create Formatter and Query Scorer

my $formatter = new

Lucene::Search::Highlight::SimpleHTMLFormatter("< b >", "< /b >");

my $scorer = new

Lucene::Search::Highlight::QueryScorer($query);

Create Highlighter

my $highlighter = new

Lucene::Search::Highlight::Highlighter($formatter, $scorer);

Get best fragements with highlighted terms

my $fragement = $highlighter->getBestFragment($analyzer, $field, $text);

my $fragements = $highlighter->getBestFragments($analyzer, $field, $text, $num_fragements, $separator);

LibreSource is a software platform dedicated to software development and management of distributed communities.
LibreSource offers configuration management with the generic synchronization module So6 from INRIA research. It includes numerous tools dealing with project and user management, including bug trackers, forums, wiki pages, mailing lists, etc. An integrated search engine (Lucene) indexes the data hosted on the platform in full text mode.
With its naming tree, LibreSource makes it possible to hierarchize access to documents and resources. It makes it easy to define public and private areas. Its decentralized approach makes it possible to develop a set of robust applications while disregarding the underlying software architecture.
Enhancements:
- Integration of the Jabber instant messaging (Tigase server and Jeti client). LDAP group resource (map groups of users from LDAP groups).
- Dropbox resource (upload files to a confidential area).
- Form resource (create an electronic form online).
- Smart security rights behaviour. RSS feeds on most of the resources, public or private.
- Files included into a download area are easier to sort and to comment.
- Forums show the thread content inside the response page.
- A best children macro has been added.
- Several bugs have been fixed.
- Performance improvements.
- A smaller memory footprint.
- Better packaging.

Pauker is a generic flashcard program written in Java. Pauker uses a combination of ultra-shortterm, shortterm, and longterm memory.
You can use it to learn all the things you never want to forget, like vocabulary, capitals, important dates, etc.
Pauker uses a combination of ultra-shortterm, shortterm, and longterm memory. You can use it to learn all the things efficiently you never want to forget, like vocabulary, capitals, important dates, etc.
Main features:
- completely free (OpenSource, GPL)
- flash card based,
- learning application,
- written in java
- using the leitner cardfile system,
- and works offline without the need of an internet connection.
Enhancements:
- Pauker works now with accidently unpacked lesson files.
- The French translation was updated.
- Wrong newline characters are shown when an answer was mistyped.
- The chosen repeating method when inserting new cards is now saved between program starts.
- An unobtrusive button for donations was added.
- The internal search engine was updated to Apache Lucene v2.1.
- The internal keyboard focus and default button handling was cleaned up.

Pyndexter (pronounced poindexter) is an abstraction layer for full-text indexing engines. It presents a uniform query syntax to the user, includes a basic but functional pure-Python indexer, and has adapters for Hype, Hyperestraier, Lucene, Lupy, Pyndex, Swish-e and Xapian.
How do I install it?
Pyndexter should be installable with setuptools:
easy_install pyndexter
Enhancements:
- The API has been revamped considerably and is now much more flexible and extensible.

eSearch provides a Java-based search engine.
eSearch is a server side Java-based search engine which supplies basic search capabilities for Web use. Its basic capabilities can be extended to include intelligent agents and other expert-system behaviors.
Main features:
- Free and Open Source
- Written in Java, and therefore platform-independent
- Uses Lucene API for Text and Index operation.
- Supplies basic search capabilities comparable to other existing search engines, for both intranet and internet use.
- Allows the basic capabilities to be extended to include intelligent agents and other expert-system behaviours, with the end result of smarter searching than is possible with existing search engines.
- Scaleable to truly mind-boggling dimensions of collections and users.
- Can dynamically index multiple servers and sources simultaneously
- Have a powerful Developer kit that include eSearch TAG Library, Samples & Documentation.
- Powerful Administration Center that let you control all crawl & search operation in your enterprise.
- Extensible architecture. You can plug new component from third party.
- Can be easily integrated with any other Web Applications: i.e. ePortal, eContent, eForum, eFAQ, eHelpDesk.