Free import software for linux

importgraph.py is a Python script that attempts to extract module dependencies from the import statements in a Python project.

This projects output can be fed into graphviz to produce graphs as these examples show.

JDBCImporter provides a consistent mechanism for importing data from a file to a database, exporting data from a database to a file, and generating data.
JDBCImporter API can run from the command line using an XML config file or from inside an Ant build script. It works with CSV, fixed data, and XML files and supports numbers, strings, and date/times as database column types.
Custom classes can be used to parse different file formats, format column values into different file formats, translate column values before importing or after exporting, or allocate or release JDBC connections.
Installation:
Below are the installation steps for installing JDBC Importer:
unzip the jdbcimporter.zip file
add jdbcimporter.jar and commons-logging.jar to the CLASSPATH.
For example: set CLASSPATH=%CLASSPATH%;INSTALL_DIRlibjdbcimporter.jar;INSTALL_DIRlibcommons-logging.jar
JDBC Importer
Basic Usage:
> java [options] net.sourceforge.jdbcimporter.Importer [plugin file]
where :
config file : the import config file
plugin file : the (optional) property file that describes the plugins available during the import
options : two system properties may be set (both are optional)
jdbcimporter.engine = The import engine to use
jdbcimporter.failonerror = Flag indicating that the import should end if an error occurrs
Enhancements:
- This release fixes a bug with CSV delimiter parser.

JDatabaseImport is a simple tool created to import data between different databases.
How does it work?
You can work with it in two ways, either using a configuration file or accessing its api using Java.
Example:
The following code show an example of a file called *export.xml*:
< export >
< from >
< driver >org.hsqldb.jdbcDriver< / driver >
< url >jdbc:hsqldb:hsql://localhost/source< / url >
< username >sa< / username >
< password >mysapass< / password >
< / from >
< to >
< driver >com.mysql.jdbc.Driver< / driver >
< url >jdbc:mysql://localhost/target< / url >
< username >root< / username >
< password >myrootpass< / password >
< / to >
< table name="firstTable"/ >
< table name="secondTable" >
< ignore >fieldToBeIgnored< / ignore >
< / table >
< table name="thirdTable"/ >
< / export >
Note that JDatabaseImport *will not* generate the target tables, but only import data from one source into the other.
In order to run JDatabaseImport, you need to put all drivers in the classpath and run it. The following code is an example on how to use it to import from mysql to hsqldb
java -cp mysql-connector-3.1.1.jar:hsqldb.jar:jdatabaseimport.jar br.com.caelum.jdatabaseimport.Main export.xml
Enhancements:
- This initial release has been tested with hsqldb, MySQL, Derby, and Oracle using some field types and different configurations.

Java::Import::Design is the design of the Java::Import Module.

MOTIVATIONS

The original motivation for writing this module came out of a project I was working on during my previous employment. We had built a system in which a major part was implimented using EJBs on a J2EE server. In addition, we had a large component of the system, that already existed, and was written in Perl. We did not want to scrap our Perl work but it was becoming more tedious to maintain two implimentations as more and more things were being added to the system.

So, we decided that the major pieces of business logic would reside on the J2EE server and the Perl would be modified to make calls to the server. After some time and experimentation we began to realize that the memory footprint as well as the amount of time needed to make calls to the server using existing Perl to Java integration sulutions were just not acceptable. We therefore set out to find some other way. We tried all sorts of things but in the end we couldnt find anything that met our requirements and therefore decided to keep the origional system of doing things.

While at that job we never did find a suitable way to integrate our two systems. However, the problem still haunted me. It wasnt until the end of my career at that company that I saw an announcement for Googles first Summer of Code. It just so happened that as Google was announcing their brand new program that I had begun to play with the GNU GCJ suite of Java tools and came up with the idea of taking advantage of their ability to natively compile Java code for use with Perl. This may not have been a new idea but I couldnt find anything that would help me so I decided to write and submit a proposal to Google. Well, I was accepted and you now have Java::Import.

When I began to work on this project I started by creating my own namespace instead of stepping on the toes of the other existing Java/Perl integration project, Inline::Java. I did this primarily because I wanted a clean slate on which I could fully explore the nuances of GCJ, in particular its CNI interface. As I worked my module started to evolve into its own beast and at that point it seemed locigal to keep my own namespace. It is not my intention to replace Inline::Java and I still think that in te future much of the work I have done can be used by Inline::Java as an option to use GCJ specific functionality.

Java::Import::Examples is an example of how to use Java::Import to call into Java classes.

Making RMI calls from Perl

One nice thing about Java is the extremely straight forward manner in which it allows you to make calls to remote objects residing on distant servers. Many people use this ability as a point of integration between their system and a posible third party or legacy system. Unfortunatly, for the most part the ability to make calls to these remote objects is something that only other Java applications can do without making a big fuss about it. However, we can now do this from Perl.

Assume that I have a RMI server from which I can get data from in the form of simple Java Beans. One method of doing this is to use the GCJ::Cni library and natively compile and wrap a set of Java Classes which can then be used from my Perl script. However, there is an easier way.

Lets begin by descriping the Java interfaces that well be working with. We first have the Remote Interface that we will be interacting with:

import java.rmi.*;
public interface RemoteInterface extends Remote {
public SomeBean getMessage(String seedMessage) throws RemoteException;
}
And we also have the bean we will be asking for:
import java.io.*;
public class SomeBean implements Serializable {
private String value;
public SomeBean() {}
public void setValue ( String _value ) { ... }
public String getValue ( ) { ... }
}
As far as any Perl client program is concerned this is all we need to know about.
Now all there is left to do is write a client:
use Java::Import qw(
java.rmi.Naming
);

my $remote_interface = java::rmi::Naming->lookup(jstring("//localhost/Home"));
my $bean = $remote_interface->getMessage(jstring("Hi there"));
print $bean->getValue(), "n";

Thats all there is. Notice that all we had to tell Java::Import about was java.rmi.Naming, this is because it was the only class we used by name in our Perl code, every other Java class (the objects held by $bean and $remote_interface) was returned by some other method call originating from java.rmi.Naming.

In order to run this example we have to make sure everything is in its place. We start by compiling the client code. Assuming that we have been given a Stub class file (RemoteObject_Stub.class) we can do the following:

gcj -C SomeBean.java RemoteInterface.java
fastjar -cvf client.jar SomeBean.class RemoteInterface.class RemoteObject_Stub.class

Making sure our server is reachable we can then run the client code:

CLASSPATH=client.jar perl client.pl

Thats it, you should then see the message returned by your server.

IMS Transport provides a Plone product that supports importing and exporting of IMS packages.
The IMS Transport Tool allows Plone users to upload content in the form of an IMS package.
Although preliminary support is included for popular proprietary learning management system packages, support for extending this product to handle the import or export of any IMS package is also included.
Works with:
- Plone 2.5.1
- Plone 2.5
This is the first major release of this product.

iPeer is an application to develop and deliver rubric-based peer evaluations, to review and release student comments, to build progress report forms online, and to analyze evaluation results.
iPeer features a built-in user management system, data import/export, and an easy-to-use installer.
Main features:
- Assignment creation.
- Custom rubric creation.
- User management system, including bulk import of students and groups.
- Student reminders via email.
- Reminder scheduling.
- Profile management.
- Student Feedback System.
- Release Comments to Students.
- Wizard Feature, Step by Step Guide for New Users.
- Easy-to-Use Installer.
- Simple Evaluatoin for TBL (Team-Based Learning).
- Export Results to Excel or txt files.
- Student Self Registration.

MuseScore is a graphical WYSIWYG music score typesetter. It uses a TrueType music font derived from the lilypond project feta fonts. Notes are entered on an "virtual note sheet". When you enter the notes, the score is immediately reformatted.
Main features:
- WYSIWYG, notes are entered on a "virtual note sheet"
- uses TrueType fonts for screen and printing (adapted from the LilyPond project feta fonts)
- easy and fast note entry
- integrated fluid sound font player; JACK audio server driver
- MusicXml import/export
- standard midifile (SMF) import/export
- programmed in C++ using the Qt gui library
- Xml file format
- GPL licenced