Free sample mission statements software for linux

Sample Inventory Program provides a laboratory inventory management system (LIMS) for Zope.
Many integration tests exist for various aspects of the SIP application, ranging from command line importing of samples and project configuration to CSV Web-based importing of sample modifications.
Main features:
- Cross platform using the Zope 3 appliation server and Python language. Contains over 200 unit and integrations tests.
- Command line import functionality (import application configuration, projects, samples, aliquots and container heirarchies)
- Cross project searches based on Subject Ids, Other Ids, Additional Sample Data, and Sample Types. Uses REPORT Permission.
- Search Form Screenshot
- Project level permissions. Users can be enabled/disabled by removing User Permission in the Applicaiton root. Lab Technician Permission allows users to put contents into a shipment and add/modify Samples. Project Manager permission allows project configuration as well as administering Users for specified projects.
- User and Permission Screenshot
- 100% Web based interface (IE, Mozilla, Safari tested). QT based client in development.
- Projects Overview Screenshot
- Ability to Split Aliquots into smaller units and put them into separate physical containers.
- Ability to Derive Aliquots into other Sample Types. Derived Samples/Aliquots links to their origin sample.
- Locations/Containers are heirarchical and can be restricted to a Project
- Shipments act as virtual containers where Lab Technicans can split aliquots into. AlsocShipments contain Contact Info, Shipping Info and Funding Info. While the Shipment Status will control the status of the Shipment moving from: Incomplete, In-Transit, and finally Received based on date fields being filled out.
- Shipment Screenshot
- Understandable relational model that enables simple reporting to be easily constructed by third party tools such as Jasper Reports
- Batch editing available using CSV files. All changes are transactional. You can easily import hundreds of samples into multiple projects by using CSV files and importing them through the web interface. You can change locations of aliquots by using the CSV import functionality. Any functionality that can be done in the web interface is complimented by CSV functionality.
- Project Search Results Screenshot
- Ability to administer Sample Type, Container Type, Locations and Unit of Measure at the application level to enforce standards across all Projects. Requires Application Manager permission.
- Ability to assign Sample Type, Locations, Technicans in a Project by Project basis.
- Project Administration Screenshot
- Advance Attribute Capture forms enable Project Administrators to specify what attributes for their Sample Types need to be captured for their project. Now non-technical users can ensure that Lab Technicans capture any attribute for any Sample Type. Attributes are limited to: DateTime, Boolean, Float, Integer, String and Text fields. Default Values can be assigned.
- Sample Type Attributes Screenshot
- Finally Sample Type Attributes can have validation scripted on a field by field basis. By using the TALES Validation functionality for Sample Type Attribute Fields. Examples of TALES validation:
- python: value < 100 # value of the field is less than 100
- python: value < datetime.date(2006, 10, 31)
- # value of the field is less than 10/31/2006
- Edit Comments will require a comment to be added to any field that is edited. These are used in conjunction with RDBMS triggers to keep a audit log to ensure that all changes to all inventory can be tracked.

SQL::Statement::Embed can embed a SQL engine in a DBD or module.

SQL::Statement is designed to be easy to embed in other modules and to be especially easy to embed in DBI drivers. It provides a SQL Engine and the other module needs to then provide a data source and a storage mechanism. For example, the DBD::CSV module uses SQL::Statement as an embedded SQL engine by implementing a file-based data source and by using DBI as the user interface. Similarly DBD::Amazon uses SQL::Statement as its SQL engine, provides its own extensions to the supported SQL syntax, and uses on-the-fly searches of Amazon.com as its data source.

SQL::Statement is the basis for eight existing DBDs (DBI database drivers). If you have a new data source, you too can create a DBD without having to reinvent the SQL wheel. Its fun, its easy, become a DBD author today!

SQL::Statement can be also be embedded without DBI. Well explore that first since developing a DBD uses most of the same methods and techniques.

The role of SQL::Statement subclasses

SQL::Statement provides a SQL parsing and execution engine. It does not provide a data source or storage mechanism other than in-memory tables. The DBD::File module is a subclass of SQL::Statement that provides access to file-based storage mechanisms. Its quite possible to use things other than files as data souces, in which case we wouldnt use DBD::File, instead wed replace DBD::Files methods with our own. In the examples below, well use DBD::File, replacing only a few methods.

SQL::Statement provides SQL parsing and evaluation and DBD::File provides file-based storage. The only thing missing is a data source - what we actually want to store and query. As an example suppose we are going to create a subclass called Foo that will provide as a data source a simple file similar to a passwd file - one record per line, fields separated by colons, with only three fields "username, uid, gid".

Consider what needs to happen to perform a SELECT query on our Foo data:

* recieve a SQL string
* parse the SQL string into a request structure
* open the table(s) specified in the request
* define column names and postions for the table
* read rows from the table
* convert the rows from colon-separated format into perl arrays
* match the columns and rows against the requested selection criteria
* return requested rows and columns to the user

To perform operations like INSERT and DELETE, we also need to:

* convert rows from perl arrays into colon-separated format
* write rows
* delete rows

SQL::Statement takes care of all of the SQL parsing and evaluation. DBD::File takes care of file opening, reading, writing, and deleting. So the only things Foo is really responsible for are:

* define column names and postions for the table
* convert rows from colon-separated format into perl arrays
* convert rows from perl arrays into colon-separated format

In SQL::Statement subclasses these responsibilities are assigned to two objects, a ::Statement object is responsible for opening the table, defining the column names and positions, and for creating new ::Table objects. A ::Table object is responsible for reading, converting, writing, and deleting data.

Mission Photo, an easy-to-use photo management application for the Linux desktop.
Main features:
- Detects attachment and detachment of digital cameras
- Imports photos from digital cameras
- Imports image files from disk
- Skips duplicate photos during import
- Losslessly rotates photos, fully preserving image quality
- Lets you rate, sort and filter your photos
- Lets you share your photos on Flickr

SQL::Interpolate is a Perl module to interpolate Perl variables into SQL statements.

SYNOPSIS

use SQL::Interpolate qw(:all);

# Some sample data to interpolate:
my $s = blue; my @v = (5, 6);

# Variable references are transformed into bind parameters.
# The most basic usage involves scalarrefs (as well as arrayrefs
# preceeded by "IN").
my ($sql, @bind) = sql_interp
SELECT * FROM table WHERE x = , $s, AND y IN, @v;
# RESULT:
# $sql = SELECT * FROM mytable WHERE x = ? AND y IN (?, ?)
# @bind = ($s, @v);

# In certain contexts, an arrayref or hashref acts as a single tuple:
my ($sql, @bind) = sql_interp
INSERT INTO table, {x => $s, y => 1};
# RESULT:
# $sql = INSERT INTO mytable (x, y) VALUES(?, ?);
# @bind = ($s, 1);
my ($sql, @bind) = sql_interp
UPDATE table SET, {x => $s, y => 1}, WHERE y , 2;
# RESULT:
# $sql = UPDATE mytable SET x = ?, y = ? WHERE y ?;
# @bind = ($s, 1, 2);

# In general, a hashref provides a shortcut for specifying
# a logical-AND construction:
my ($sql, @bind) = sql_interp
SELECT * FROM table WHERE, {x => $s, y => @v};
# RESULT:
# $sql = SELECT * FROM mytable WHERE (x = ? AND y IN (?, ?));
# @bind = ($s, @v);

# In general, an arrayref acts as a result set or reference to
# a temporary table:
my ($sql, @bind) = sql_interp
[[1, 2], [4, 5]], UNION, [{x => 2, y => 3}, {x => 5, y => 6};
# RESULT:
# $sql = (SELECT ?, ? UNION ALL SELECT ?, ?) UNION
# (SELECT ? AS x, ? AS y UNION ALL SELECT ?, ?);
# @bind = (1,2,4,5, 2,3,5,6);
my ($sql, @bind) = sql_interp
SELECT * FROM, [[1, 2], [4, 5]]
# RESULT:
# $sql = SELECT * FROM (SELECT ?, ? UNION ALL SELECT ?, ?) AS tbl0;
# @bind = (1,2,4,5);

# Each result above is suitable for passing to DBI:
my $res = $dbh->selectall_arrayref($sql, undef, @bind);

# Besides these simple techniques shown, SQL-Interpolate includes
# various optional modules to further integrate SQL::Interpolate with
# DBI and streamline the syntax with source filtering and macros (see
# the L section):

use DBIx::Interpolate FILTER => 1;
...
my $rows = $dbx->selectall_arrayref(sql[
SELECT thid, date, title, subject
FROM threads
WHERE date > $x AND subject IN @subjects
]);

After decades of war one company, who had gained powerful supplying both sides with weaponary, steps forwards and crushes both warring factions in one swift movement.
Using far superior weaponary and AI craft, the company was completely unstoppable and now no one can stand in their way.
Thousands began to perish under the iron fist of the company. The people cried out for a saviour, for someone to light this dark hour... and someone did.
Main features:
- 26 missions over 4 star systems
- Primary and Secondary Weapons (including a laser cannon and a charge weapon)
- A weapon powerup system
- Wingmates
- Missions with Primary and Secondary Objectives
- A Variety of Missions (Protect, Destroy, etc)
- 13 different music tracks
- Boss battles

Grammidity project is a Java-based framework for evolutionary programming.

It can be used to evolve solutions to problems, or to evolve "objects" under user control.

It has a limitless range of possible applications.

This program has been tested on sample projects generating 3D objects and imitation plants.

PowerDNS Oracle Backend provides a backend which allows PowerDNS to use Oracle as its data store.

PowerDNS Oracle Backend is a backend driver for the PowerDNS nameserver which allows DNS data to be stored in an Oracle database. PowerDNS can load backend modules at runtime. This backend is fully configurable, and SQL statements can be specified in the configuration file.

Extended Python Debugger is a complete debugger for Python than the stock pdb.py debugger.

It supports a "restart" command and stack traces that show fewer ?s and give better information for exec statements.

Stepping/nexting skips over method/function "defs". It tries to follow gdbs command set unless there is good reason not to.