reference implementation
PubSubHubbub_Publisher 1.0
A simple, open, web-hook-based pubsub protocol & open source reference implementation more>>
PubSubHubbub_Publisher 1.0 is yet another excellent utility for everyone. It is actually a simple, open, server-to-server web-hook-based pubsub (publish/subscribe) protocol as a simple extension to Atom.
Parties (servers) speaking the PubSubHubbub protocol can get near-instant notifications (via webhook callbacks) when a topic (Atom URL) they're interested in is updated.
This tool works as follow:
- An Atom URL (a "topic") declares its Hub server(s) in its Atom XML file, via . The hub(s) can be run by the publisher of the Atom, or can be a community hub that anybody can use.
- A subscriber (a server that's interested in a topic), initially fetches the Atom URL as normal. If the Atom file declares its hubs, the subscriber can then avoid lame, repeated polling of the URL and can instead register with the feeds hub(s) and subscribe to updates.
- The subscriber subscribes to the Topic URL from the Topic URLs declared Hub(s).
- When the Publisher next updates the Topic URL, the publisher software pings the Hub(s) saying that there's an update.
- The hub efficiently fetches the published feed and multicasts the new/changed content out to all registered subscribers.
- The protocol is decentralized and free. No company is at the center of this controlling it. Anybody can run a hub, or anybody can ping (publish) or subscribe using open hubs.
- To bootstrap this, the publisher has provided an open source reference implementation of the hub (the hard part of the protocol) that runs on Google App Engine, and is open for anybody to use.
Requirements:
- Python
ANUGA 1.0 Beta 4669
ANUGA is a software implementation of a hydrodynamic model that is specifically designed to model wetting and drying processes. more>>
GDataFS 0.9
GDataFS is a FUSE implementation that mounts your account at Googles Picassa web to your filesystem. more>>
The filesystem supports full read/write and delete of album and photos.
Text::Bloom 1.07
Text::Bloom can evaluate Bloom signature of a set of terms. more>>
SYNOPSIS
my $b = Text::Bloom->new();
$b->Compute( qw( foo bar baz ) );
my $sig = $b->WriteToString();
$b->WriteToFile( afile.sig );
my $b2 = Text::Bloom::NewFromFile( afile.sig );
my $b3 = Text::Bloom->new();
$b3->Compute( qw( foo bar barbaz ) );
my $sim = $b->Similarity( $b2 );
my $b4 = Text::Bloom::NewFromString( $sig );
Text::Bloom applies the Bloom filtering technique to the statistical analysis of documents.
The terms in the document are quantized using a base-36 radix representation; each term thus corresponds to an integer in the range 0..p-1, where p is a prime, currently set to the greatest prime less than 2^32.
Each quantized value is mapped to d integers in the range 0..size-1, where size is an integer less than p, currently 2^17, using a family of hash functions, computed by the HashV function.
Each hashed value is used as the index in a large bit vector. Bits corresponding to terms present in the document are set to 1; all other bits are set to 0.
Of course, collisions may cause the same bit to be set twice, by different terms. It follows that, if the document contains n distinct terms, in the resulting bit vector at most n * d bits are set to 1.
The resulting bit string is a very compact representation of the presence/absence of terms in the document, and is therefore characterised as a signature. Moreover, it does not depend on a pre-set dictionary of terms.
The signature may be used for:
testing whether a given set of terms is present in the document,
computing which fraction of terms are common to two documents.
The bit representation may be written to and read from a file. Text::Bloom prepends a header to the bit stream proper; moreover, whenever the package Compress::Zlib is available, the bit vector is compressed, so that disk space requirements are drastically reduced, especially for small documents.
The hash function is obviously a crucial component of the filter; the reference implementation uses a radix representation of strings. Each term must therefore match the regular expression /[0-9a-z]+/.
There are quite a few viable alternatives, which can be pursued by subclassing and redefining the method QuantizeV.
Math::Amoeba 0.04
Math::Amoeba is a Multidimensional Function Minimization. more>>
SYNOPSIS
use Math::Amoeba qw(ConstructVertices EvaluateVertices Amoeba MinimiseND);
my ($vertice,$y)=MinimiseND(@guess,@scales,&func,$tol,$itmax,$verbose);
my @vertices=ConstructVertices(@vector,@offsets);
my @y=EvaluateVertices(@vertices,&func);
my ($vertice,$y)=Amoeba(@vertices,@y,&func,$tol,$itmax,$verbose);
This is an implementation of the Downhill Simpex Method in Multidimensions (Nelder and Mead) for finding the (local) minimum of a function. Doing this in Perl makes it easy for that function to actually be the output of another program such as a simulator.
Arrays and the function are passed by reference to the routines.
The simplest use is the MinimiseND function. This takes a reference to an array of guess values for the parameters at the function minimum, a reference to an array of scales for these parameters (sensible ranges around the guess in which to look), a reference to the function, a convergence tolerance for the minimum, the maximum number of iterations to be taken and the verbose flag (default ON). It returns an array consisting of a reference to the function parameters at the minimum and the value there.
The Amoeba function is the actual implementation of the Downhill Simpex Method in Multidimensions. It takes a reference to an array of references to arrays which are the initial n+1 vertices (where n is the number of function parameters), a reference to the function valuation at these vertices, a reference to the function, a convergence tolerance for the minimum, the maximum number of iterations to be taken and the verbose flag (default ON). It returns an array consisting of a reference to the function parameters at the minimum and the value there.
The ConstructVertices is used by MinimiseND to construct the initial vertices for Amoeba as the initial guess plus the parameter scale parameters as vectors along the parameter axis.
The EvaluateVertices takes these set of vertices, calling the function for each one and returning the vector of results.
EXAMPLE
use Math::Amoeba qw(MinimiseND);
sub afunc {
my ($a,$b)=@_;
print "$at$bn";
return ($a-7)**2+($b+3)**2;
}
my @guess=(1,1);
my @scale=(1,1);
($p,$y)=MinimiseND(@guess,@scale,&afunc,1e-7,100);
print "(",join(,,@{$p}),")=$yn";
produces the output
(6.99978191653352,-2.99981241563247)=1.00000008274829
RBrainz 0.3.0
RBrainz is a Ruby client library to query the MusicBrainz database using the MusicBrainz XML web service. more>>
RBrainz follows the design of the MusicBrainz client library reference implementation and supports the MusicBrainz XML Metadata Schema Version 1.2.
Usage:
A simple example on how to use RBrainz is shown below. For more detailed instructions see the API documentation.
require rbrainz
include MusicBrainz
# With the ArtistInclude object we can control what
# kind of information the MusicBrainz server will
# include in its answer.
artist_includes = Webservice::ArtistIncludes.new(
:aliases => true,
:releases => [Album, Official],
:artist_rels => true,
:release_rels => true,
:track_rels => true,
:label_rels => true,
:url_rels => true
)
# Query the webservice for the artist with a given ID.
# The result will contain all the information
# specified in artist_includes.
query = Webservice::Query.new
id = c0b2500e-0cef-4130-869d-732b23ed9df5
artist = query.get_artist_by_id(id, artist_includes)
# Display the fetched artist data together with
# all release titles.
print<<less
Procinfo NG 2.0.113 (C++ Implementation)
Procinfo NG is a ground-up rewrite of the procinfo program. more>>
The original program was written for Linux 1.0, and updated through 2.2. This version is for 2.6.
Enhancements:
- Updates were made to match what some Linux distributions have done to procinfo-18.
- Support for MSI and XEN interrupts were added.
- Some non-x86 architectures are handled.
- Assorted bugs and 80-character console nonsense were fixed.
Bio::LiveSeq::Translation 1.4
Bio::LiveSeq::Translation is a translation class for LiveSeq. more>>
This stores informations about aminoacids translations of transcripts. The implementation is that a Translation object is the translation of a Transcript object, with different possibilities of manipulation, different coordinate system and eventually its own ranges (protein domains).
APPENDIX
The rest of the documentation details each of the object methods. Internal methods are usually preceded with a _
new
Title : new
Usage : $protein = Bio::LiveSeq::Translation->new(-transcript => $transcr);
Function: generates a new Bio::LiveSeq::Translation
Returns : reference to a new object of class Translation
Errorcode -1
Args : reference to an object of class Transcript
get_Transcript
Title : valid
Usage : $transcript = $obj->get_Transcript()
Function: retrieves the reference to the object of class Transcript (if any)
attached to a LiveSeq object
Returns : object reference
Args : none
aa_ranges
Title : aa_ranges
Usage : @proteinfeatures = $translation->aa_ranges()
Function: to retrieve all the LiveSeq AARange objects attached to a
Translation, usually created out of a SwissProt database entry
crossreferenced from an EMBL CDS feature.
Returns : an array
Args : none
libSpiff 0.7.2
libSpiff brings XSPF playlist reading and writing support to your C++ application. more>>
libSpiff uses Expat for XML parsing and CppTest for unit testing. libSpiff is the official reference implementation for XSPF of the Xiph.Org Foundation.
Daikon 4.3.1
Daikon is an implementation of dynamic detection of likely invariants. more>>
Restlet 1.0.4
Restlet is a framework that brings the simplicity and efficiency of the REST architectural style to Java developers. more>>
Restlet project is composed of two parts, a neutral API and a reference implementation (Noelios Restlet Engine). It supports all REST concepts (resource, representation, data, connector, components, etc.) and is suitable for both client and server REST applications.
The server connectors provided are HTTP (via Mortbays Jetty or an adapter Servlet) and the client connectors are HTTP, JDBC, and SMTP (via JavaMail).
Mission
- Bring the simplicity and efficiency of the REST architectural style to Java developers
Restlet API
- Supports all REST concepts (resource, representation, data, connector, components, etc.)
- Suitable for both client and server Web applications
- Maplets support the concept of URIs as UI with advanced pattern matching features
- Chainlets filter calls to implement features such as logging and authentication
- Complete alternative to Servlet API with no external dependency (JAR < 60kb)
- Supports blocking and non-blocking NIO modes
Noelios Restlet Engine (NRE)
- Reference implementation of the Restlet API provided by Noelios Consulting (core JAR < 110kb)
- Server connector provided: HTTP (via Jetty connectors or Servlet connector)
- Client connectors provided: HTTP, JDBC, SMTP (via JavaMail)
- Supports logging (LogChainlet), authentication (GuardChainlet) and cool URIs rewriting (RedirectRestlet)
- Static files serving (DirectoryRestlet) with metadata association based on file extensions
- FreeMarker template representations as an alternative to JSP pages
- Automatic server-side content negotiation based on media type and language
Bio::Ontology::OntologyEngineI 1.4
OntologyEngineI is a Perl interface a minimal Ontology implementation should satisfy. more>>
This describes the minimal interface an ontology query engine should provide. It intentionally doesnt make explicit references to the ontology being a DAG, nor does it mandate that the ontology be a vocabulary. Rather, it tries to generically express what should be accessible (queriable) about an ontology.
The idea is to allow for different implementations for different purposes, which may then differ as to which operations are efficient and which arent, and how much richer the functionality is on top of this minimalistic set of methods. Check modules in the Bio::Ontology namespace to find out which implementations exist. At the time of writing, there is a SimpleOntologyEngine (which does not use Graph.pm), and a Graph.pm-based implementation in SimpleGOEngine.
Ontology parsers in Bio::OntologyIO are required to return an implementation of this interface.
z3c.formjs 0.2.0
This provides a Python API to common Javascript features for forms written with the z3c.form packages. more>>
z3c.formjs 0.2.0 with its excellent features will surely support your work. It can actually provide a Python API to common Javascript features for forms written with the 'z3c.form' packages. While the reference backend-implementation is for the JQuery library, any other Javascript library can be hooked into the Python API.
In the 'z3c.form' package, buttons are most commonly rendered as "submit" input fields within a form, meaning that the form will always be submitted. When working with Javascript, on the other hand, a click on the button often simply executes a script. The 'jsaction' module of this package is designed to implement the latter kind.
Enhancements: 7/18/2007
- Feature: Registration of public AJAX server calls via a simple decorator. The calls are made available via a special 'ajax' view on the original view.
- Feature: Allow registering of JS subscriptions via a decorator within the presentation component.
- Feature: Added a new CSS selector.
- Feature: Implementation of AJAX-driven widget value validation.
- Restructure: Completely overhauled the entire API to be most easy to use and have the most minimal implementation.
- Bug: The package is now 100% tested.
- Feature: Implementation of AJAX request handlers in forms.
Direct Access Provider Library 3.03
Direct Access Provider Library is a transport-independent, platform-independent, high-performance API. more>>
This is the reference implementation of that specification by the DAT Collaborative who maintain the DAPL API.
Enhancements:
- Support was added for new IB verbs client register event.
- Some problems supporting create qp without recv cq handle or recv qp resources were fixed.
- Some timeout and long disconnect delay issues exposed during scalability tests were fixed.
- Minor build problems were fixed.
- Support for multiple IB devices was added to dat.conf to support IPoIB HA failover.
- Support for returning local and remote port information was added.
- The RPM spec file was cleaned up.
- Enviroment variables to configure connection management timers were added.
libbehate 0.0.1
libbehate is a library with implementation of BHT communication protocol. more>>
This protocol is used in communication with Toyota Denso data collection terminals. Library itself uses librs232 for link layer.
Library is released under the term of LGPL license.
Copyright (c)2005-2009 WareSeeker.com. All rights reserved.