PISE (*), a tool to generate Web interfaces for Molecular Biology programs

Catherine Letondal (letondal@pasteur.fr), Pasteur Institute.

the tower
  1. Description
    1. Summary
    2. Design
  2. What's new?
  3. Documentation
    1. Installation
    2. XML definition of a new program interface
  4. Pise/Bioperl
  5. Pise/SeWeR
  6. Pise/Biopython
  7. G-pipe
  8. Distribution
  9. Mirrors sites
  10. Pise contrib
  11. FAQ
  12. Suggestions for evolutionnew
  13. Contact, mailing list
  14. References
  15. Credits

Page updated on: April, 20 2007

Summary

Almost all users encounter problems using sequence analysis programs. Not only are they difficult to learn because of the parameters syntax and semantic, but they are all different. However, as it would certainly be useful to add a friendly interface to each program, this is totally infeasible given the increasing number of new software in molecular biology.

That is why we have developed a software that, given an abstract definition of a program's parameters, can generate whatever style of interface provided there is a configuration module for it (there are already modules for Web, conversational, SeqLab, Tcl/Tk and X11 interfaces - not all fully maintained though). What we consider as a parameter is very general and includes: command line parameters, simple interaction on standard input and parameters files.

It quickly turned out that the most useful interface would be a Web interface, because it's widely available and users are accustomed to it (this is why the SeqLab, conversational and X11 interfaces are not really maintained). Features include:

The Web server interfaces are meant to be run on any Unix machine.

The current operational server contains about 200 programs, including EMBOSS programs, ranging from Blast and Fasta databases searches or classic comparison programs (clustalw, Wise,...) to gene finding and modelling (Genscan, GeneMark, ...), RNA analysis (mfold, Vienna package), phylogeny (Phylip, fastDNAml, Puzzle, Molphy, ...), protein and DNA analysis, pattern discovery (HMMER, PFTOOLS, ...) and structure analysis.

Links

Design

  1. Objectives
  2. General layout
  3. HTML design
  4. CGI design

  1. Objectives

  2. General layout

     The following figure shows the general architecture of Pise.
    One can enter Pise at different levels:
    1. at the end-user level, by using the HTML and CGI files on a Web server,
    2. at the software administrator level, by customizing and installing these files (see Installation steps), or by defining new program interfaces: the section Definition of a new program interface shows you how to define new interfaces. This should not be very hard to learn.
    3. at the interface developper level by programming a new maker for a new kind of interface.
    Schema

  3. HTML design

    We have run some usability tests with a dozen users grouped by two, one telling to the other what s/he intended to do, the other one describing what s/he was seeing.
    Among a lot of useful informations, like where to put the submit button, how to indicate on-line help... these tests have showed that it's necessary to design two levels of use :
    1. a simple level, without fancy capabilities, proposing only the mandatory parameters without predefined default value, like the input data;
    2. an advanced level, proposing as many parameters as available in the program, no matter how complex they are. The parameters are grouped into paragraphs, according to the software documentation (see Paragraph).
    The level of a parameter is determined by an associated attribute (see simple attribute).

    The on-line help is made of comments at the end of the HTML document. Parameters prompts are linked to the approppriate part of this section. HTML

  4. CGI design

    1. Access to results:
      As some analysis can be very long - several days, and due to the synchronous aspect of a CGI based Web interface, it's necessary to delay results delivery. However, we think it's worth adapting a Web interface system in order to give access to results by the Web, even if not immediatly. That's why, in case of a long analysis, the user receives one email by result file, as well as an additional email giving the URL of the results Web page.
      You can see in the following schema how the two different cases (fast program < 60 seconds, slow program > 60 seconds) are handled by exchanging Unix signals between the CGI and the generated script. CGI

    2. Redundant submissions:
       As some analysis can be very heavy regarding the CPU resource, it's very important to prevent similar submissions. There are two cases:
      1. the user has clicked twice on the Submit button;
      2. the job is not done after a while, and the user submit it again (just in case);
      The first case is handled during the "interactive" period within the first 60 seconds (see above): both submissions are cancelled, and a message is displayed explaining the problem and asking the user to resubmit.

      In the second case, the first job is not killed. A message is displayed telling that a similar job has been submitted, and that the user should wait for the results.

      Technically speaking, a similar job is detected by a checksum on the submitted data. As all the processes are under the same Unix group, it's very easy to kill them according to a stored PID value (first case only).

    3. Piping programs:
      As shown on the picture below, the results of a program, say clustalw, can be used as an input to another program, say dnadist. This is similar to the Unix pipe behaviour (except it's implemented with ordinary copies). CGI

What's new?

Documentation

  1. Installation
  2. Definition of a new program interface

Installation

  1. Check that you have the required packages

  2. Create a directory , say /local/lib/Pise, and download Pise.tar in this directory. This will create the /local/lib/Pise/version directory, which will be the PISEDIR directory in which you will have the following files and subdirectories: 
    drwxrwxr-x 2 you team 8192 Jun 18 15:21 Doc	documentation files
drwxrwxr-x 3 you team 8192 Jun 17 17:44 Html	generated .html
drwxrwxr-x 2 you team 8192 Jun 17 16:56 Images  GIF files
-rw-r--r-- 1 you team 5668 Jun 18 16:15 Makefile
-rw-r--r-- 1 you team 1762 Jun 18 16:13 Makefile.global
drwxrwxr-x 2 you team 8192 Jun 18 14:58 Maker	interface generators
drwxrwxr-x 2 you team 8192 Jun 17 18:30 Parser	lex&yacc or XML parser
drwxrwxr-x 2 you team 8192 Jun 17 14:50 PerlDef	generated perl data structures
drwxrwxr-x 2 you team 8192 Jun 18 19:28 Xml	XML text definitions (version 5.a)
drwxrwxr-x 2 you team 8192 Jun 17 16:03 lib	perl utilities
-rw-rw-r-- 2 you team 1801  Jun 17 14:50 README
-rw-r--r-- 1 you team 32464 Jun 18 16:20 configure.in
-rw-r-xr-x 1 you team 32864 Jun 18 16:20 configure configuration script
-rw-r--r-- 1 you team 637 Jun 18 16:20 aclocal.m4 macros for configure
  3. Web setup and installation variables. The place for changes are in bold above:
    1. Makefile.global
    2. lib/web.pl

    Makefile.global let you define:

    lib/web.pl let you define:

  4. Run configure. 
    	./configure --prefix=/local/lib/Pise

  5. Copy the GIF files from the Images subdirectory to the $IMAGES_DIR directory (see lib/web.pl).

  6. optional -- Define program interfaces. This is optional, as you have to learn how to. See the documentation below. All the definitions mentioned in the Description part are available in the Xml sub-directory.

  7. Try some program interfaces:
    1. make PROGRAM=xxx
      This should create the following files:
      1. PerlDef/xxx.pl: perl data structures
      2. Html/xxx.html: HTML advanced form
      3. Html/xxx-simple.html: HTML simple form (see explanations)
      4. Cgi/xxx.pl: CGI file
    2. make install PROGRAM=xxx
      This should create the following files (copied from Html and Cgi subdirectories to installation directories defined in Makefile):
      1. HTML-INSTALL-DIR/xxx.html
      2. HTM-INSTALL-DIR/xxx-simple.html
      3. CGI-INSTALL-DIR/xxx.pl

  8. Go to WEB_SERVER/Pise/xxx.html, enter some data and run the program...

    If successfull, this should create a temporary directory in HTMLDIR/tmp/xxx/, containing your input and output files, as well as an index.html file presenting the results, a xxx.out file containing the standard output, a xxx.err file containing the standard error and a script perl file to run everything.

  9. Warning: XML command definition files are customized for their use at the Pasteur Institute site. You may have to adapt them for your own use.

  10. Administration:

    Log file, technical support and statistics:
    The LOGDIR/log file contains a description for each submitted job: 
    command||{simple,advanced} form||Unix command||email||temporary dir||date
    this can be used to trace user requests as well as doing some use statistics.
    The Logs sub-directory contains a Makefile and a perl script to generate HTML reports from the LOGDIR/log file.

    Temporary files cleaning:
    You can use the lib/clean_cgi.pl perl script as an example to clean the work files en the HTMLDIR/tmp subdirectory.

    Note that this directory should be linked to a big partition :-)

    Lock files cleaning at boot time:
    In order to prevent many similar jobs, the directory HTMLDIR/tmp/REQUESTS contains 2 files for each submitted job:
    1. command.checksum
    2. command.checksum.pid
    These files should be cleaned at reboot.

Definition of a new program interface

Only for XML 5.a version version.
The definition of a program interface is described in XML, according to a DTD.
You may look at some examples.

This part explain how to create a new interface for a program. You have to describe the program title and name as well as its parameters.

The definition of a program interface comprise the following parts: 

<!ELEMENT pise (head, command, parameters)>

header
Headers: title, name, authors, bibliographic reference, categories. 
<!ELEMENT head (title, description?, authors?, reference?, category*,doclink*)>

Example: 
<head>
   <title>Clustalw</title>
   <description>Multiple Alignements</description>
   <authors>Des Higgins</authors>
   <category>alignment</category>
   <doclink>http://www-igbmc.u-strasbg.fr/BioInfo/ClustalW</doclink>
</head>
command
command is the name of this definition; it's used everywhere (filenames, data structures, ...); it's kind of a key.
Example: 
<command>clustalw</command>
This means that the files containing this program descriptions will be: clustalw.html, clustalw.pl, ..., and that the effective Unix command will start by the string: "clustalw".

You can also define the command as a parameter.

parameters

There is one definition for every "parameter" of the command.
Parameters have a name and a given type, describing their general behaviour and properties.
A definition is composed of a list of attributes, defining the prompted text, the default value, etc... Here is the definition: 
<!ELEMENT parameter (paragraph|(name,attributes)+)> 
<!ATTLIST parameter
    type    (InFile|Sequence|OutFile|Results|Switch|Excl|List|Integer|Float|String|Paragraph|Label) #REQUIRED
    ismandatory %boolean; #IMPLIED
    iscommand   %boolean; #IMPLIED
    ishidden    %boolean; #IMPLIED
    isstandout  %boolean; #IMPLIED
    issimple    %boolean; #IMPLIED
    isclean     %boolean; #IMPLIED
>
Example: 
<parameter type="Sequence" ismandatory="1" issimple="1" ishidden="0">
<name>sequence</name>
<attributes>
        <prompt>DNA sequence (-seq)</prompt>
        <format>
                <language>perl</language>
                <code>" -seq=$value"</code>
        </format>
        <group>1</group>
        <seqtype><value>dna</value></seqtype>
        <seqfmt>
                <value>8</value>
        </seqfmt>
</attributes>
</parameter>
where:

Additionals notes:
  1. Grouping parameters in paragraphs:

    It's convenient, as some programs have a lot of parameters, to group these into appropriate rubrics. The Paragraph attribute describes such grouping. The grouped variables are listed within the vlist attribute: 

    <paragraph>
  <name>fastpw</name>
  <prompt>Fast Pairwise Alignments parameters</prompt>
  <precond>
        <language>perl</language>
        <code>($quicktree eq "fast")</code>
  </precond>
  <group>2</group>
  <comment>
        <value>These similarity scores calculation</value>
  </comment>
<parameters>
   .. list of parameters ..
</parameters>
</paragraph>
    The order of this list is significant: parameters of this group will be presented in such order in the     HTML form.

  2. Defining 2 user levels:

    There are 2 type of HTML forms:

    1. a simple form, with very few parameters, for beginners; this form is named xxx-simple.html for a program called xxx; there is no Paragraph at this level,
    2. an advanced form, proposing all the parameters, when possible grouped into paragraphs (see above); this form is named xxx.html for a program called xxx.

    In order to distinguish simple/advanced parameter, you can use the issimple attribute: 

    <parameter ismandatory="1" issimple="1" type="Sequence">
  3. Sharing definitions

    As programs of the same package (like PHYLIP programs) often used the same parameters, it's possible to recursively include definition files. 

    <?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE pise SYSTEM "/local/gensoft/inst/Pise/5.a/Parser/pise.dtd" [
<!ENTITY emboss_init SYSTEM "/local/gensoft/inst/Pise/5.a/Xml/emboss.xml">
]>
...
&emboss_init;
    This will include the file named emboss.xml which may contain initialization code.

  4. Using parameter names as variables:


    A parameter name ($quicktree in the following example) is like a variable name that can be used in the attributes containing code (format, ctrl, precond); example: 

      <precond>
        <language>perl</language>
        <code>($quicktree eq "fast")</code>
  </precond>

  5. Using a parameter file:

    This attribute directs the part of the command line for this parameter into a file; this is useful for programs wo take their parameters from a file of from the standard input, like Phylip programs. Example: 

            <parameter type="Switch">
        <name>use_threshold</name>
        <attributes>

                <prompt>Use Threshold parsimony (T)</prompt>
                <format>
                        <language>perl</language>
                        <code>($value)? "T\\n$threshold\\n" : ""</code>
                </format>
                <vdef><value>0</value></vdef>
                <group>3</group>
                <paramfile>params</paramfile>

        </attributes>
        </parameter>
    This means that, if the use_threshold parameter is on, and the value for $threshold is, say 10, the paramfile "params" will contain these 2 lines: 
    T
10
    when using paramfile, the group attribute defines the order of the parameter in the file, not on the command line.

  6. About command:

    As you can see in the following example, the command itself can be described as a parameter. The attribute to use for this purpose is the boolean command attribute. 

    <parameter ismandatory="1" iscommand="1" type="Excl">
 <name>molphy</name>
 <attributes>
    <prompt>Program</prompt>
    <format>
      <language>perl</language>
      <code> "$value" </code>
    </format>
    <vdef><value>nucml</value></vdef>
    <group>0</group>
    <vlist>
      <value>protml</value>
      <label>protml</label>
      <value>nucml</value>
      <label>nucml</label>
      <value>njdist</value>
      <label>njdist</label>
    </vlist>
 </attributes>
</parameter>
    There can be only one such parameter. It's name stands for the name of all the program files (here : molphy.def, molphy.pl, molphy.html, ...).

  7. Using the group attribute:

    This attribute defines at which position in the command line the string for this parameter should be. In the following example (simplified) : 

    <parameter type="Excl">
 <name>database</name>
 <attributes>
   <group>2</group>
 </attributes>
</parameter>

<parameter type="Sequence">
 <name>query></name>
 <attributes>
   <group>3</group>
 </attributes>
</parameter>
    according to the values entered by the user, the generated Unix command will be:
    % blast gb seq

    The group attribute can be defined at the paragraph level: all the paragraph's variables will be ranged at the same position in the command line.

    See also the paramfile attribute note.

  8. Connecting a program's output to another program input:

    See design section for a general explanation.

    The attribute to implement this is pipe. Example:

    clustalw.def: 

    <name>aligfile</name>
  <attributes>
        <filenames>*.aln *.gde</filenames>
        <pipe>
                <pipetype>readseq_ok_alig</pipetype>
                        <language>perl</language>
                        <code>1</code>
        </pipe>
  </attributes>
</parameter>

    dnadist.def: 

    <parameter ismandatory="1" issimple="1" type="Sequence">
<name>infile</name>
  <attributes>
        <prompt>Alignement File</prompt>
        <format>
                <language>perl</language>
                <code>"ln -s $infile infile; "</code>
        </format>
        <group>-10</group>
        <seqfmt>
                <value>12</value>
        </seqfmt>
        <pipe>
                <pipetype>readseq_ok_alig</pipetype>
                        <language>perl</language>
                        <code>1</code>
        </pipe>

  </attributes>
</parameter>

    To "connect" clustalw output to dnadist input, you have to run a:
    % make connect
    from the Pise directory. This run the Maker/make-connections.pl generator, which updates the PerlDef/pipeins perl definition file, used by the CGI to generate menus in the results form.

  9. Sequence format conversion:

    For the Sequence parameters, as long as the required format is described with the seqfmt attribute, the CGI automatically convert the input data into the appropiate format, by using the readseq program. In the following example, if the sequence data is neither in the fasta (8) nor in the GCG (5) format, it will be converted in the former. 

    <parameter ismandatory="1" issimple="1" type="Sequence">
 <name>query</name>
 <attributes>
     <prompt>Sequences File</prompt>
        <seqfmt>
                <value>8</value>
                <value>5</value>
        </seqfmt>
 </attributes>
</parameter>
    The values for the seqfmt attribute are the readseq codes. Code 100 stands for the Clustalw format.

Pise/bioperl

Pise/Bioperl modules (http://www.bioperl.org).

Pise/SeWeR

Pise/SeWer GUI (still experimental!!).

Based on Basu M K SeWeR customization facility. SeWeR stands for SEquence analysis using WEb Resources.

The great advantage of this Web gateway is that:

See our local SeWeR installation, with EMBOSS programs, as well as several other Pise programs.

Distribution: ftp://ftp.pasteur.fr/pub/GenSoft/unix/misc/Pise/PiseSeWer.tar.gz.

In order to use it for your local installation, you have to:

  1. edit the file Maker/make-sewer.pl (after configure) to change the ROOT_HTML_FORM variable to go to your Pise path to Web GUI.
  2. Issue the following build commands:
    1. For one category of program, e.g nucleic acid:
      1. copy SeWer/nucleicacid.htm.init to SeWer/nucleicacid.htm
      2. make sewercat CATEGORY=nucleic SEWER_FILE=SeWer/nucleicacid.htm
      3. this generates a SeWer/nucleicacid.htm.new file that you can copy to your local SeWeR path (e.g .../htdocs/SeWeR/nucleicacid.htm)
      4. move the SeWer/nucleicacid.htm.new to SeWer/nucleicacid.htm if you are happy with it
    2. repeat these steps for EMBOSS CATEGORY=protein, alignment (SeWer: align.htm) and edit (SeWer: tools.htm)
    3. you can add individual programs (not classified or not belonging to EMBOSS) by:
      make sewerprog PROGRAM=program SEWER_FILE=SeWer/xxx.htm
      (xxx according to the category you think best)

Pise/Biopython package

A Pise/Biopython API: this package enables to run Pise jobs from a python program.

You don't need to install Pise in order to use this package, for it's only a client.

Example:
The following example show how to run a toppred analysis on a Biopython SeqRecord instance: 
from Pise import PiseFactory
import Bio.Fasta
import sys

factory = PiseFactory(email='user@domain')
program = factory.program("toppred",
                          graph_output=1,
                          profile_format="ps")

handle = open(sys.argv[1])
it = Bio.Fasta.Iterator(handle, Bio.Fasta.SequenceParser())
seq = it.next()

# for Sequence parameters, you can either provide: 
#  a Seq, or SeqRecord instance, a file,or a string
job = program.run(query=seq)

if job.error():
      print job.error_message()
else:
      print "url of the job: " + job.jobid()
      print job.stdout()
      print "Results: ", job.get_results()
      psfile = job.save('.ps')
      print "PostScript file saved in: ", psfile

As shown above, this package is compatible with the Biopython (http://www.biopython.org/) sequence and alignement types. You can also feed the output as a handle for a Biopython parser, such as the parser for the EMBOSS primersearch program: 

from Pise import PiseFactory
from Bio.Emboss.Primer import PrimerSearchParser
import sys

parser = PrimerSearchParser()
factory = PiseFactory()
primersearch = factory.program('primersearch',
                       	        sequences = sys.argv[1],
                                primers = sys.argv[2])
job=primersearch.run()
if job.error():
    print "Error: " + job.error_message()
else:
    handle = job.fh('.out')
    primer_record = parser.parse(handle)
    for key in primer_record.amplifiers.keys():
        for a in primer_record.amplifiers[key]:
            print "Length: ", a.length
            print "Info: ", a.hit_info
    handle.close()

You can find more examples here: ftp://ftp.pasteur.fr/pub/GenSoft/unix/misc/Pise/python-examples.tar.gz

Download:
ftp://ftp.pasteur.fr/pub/GenSoft/unix/misc/Pise/Pise-python-5.a.tar.gz.

G-Pipe

G-Pipe is a graphical pipeline generator that allows the definition of pipelines, and parameterisation of its component methods using Pise web interfaces. The entire analysis protocol is stored in XML and a complete bioinformatic experiment (linked set of methods and parameters) can hence be reproduced or shared among users. A Perl macro making use of Pise/Bioperl and implementing the pipeline can also be downloaded (for developers). You can try it here: http://if-web1.imb.uq.edu.au/Pise/5.a/gpipe.html.

Authors : Alexander Garcia (a.garcia@imb.uq.edu.au)
Samuel Thoraval (samuel.thoraval@librophyt.com)

Download:
ftp://ftp.pasteur.fr/pub/GenSoft/unix/misc/Pise/G-Pipe.tar.gz.

PiseWorkflow for Python

The G-pipe PiseWorkflow.pm bioperl component has been ported to Python by Pierre Tuffery. You can find it on the Pise ftp site in the (pise-python distribution). 

from PiseWorkflow import *
from Pise import PiseFactory
import Bio.Clustalw
import sys

alig = Bio.Clustalw.parse_file(sys.argv[1])          

factory  = PiseFactory()
dnapars  = factory.program('dnapars', infile=alig, print_treefile=True)
drawtree = factory.program('drawtree')

wf = PiseWorkflow()
wf.addpipe(method=dnapars, tomethod=drawtree, pipetype="phylip_tree")
wf.run()
Examples can be found in the python examples file.

Distribution

Ftp directory: ftp://ftp.pasteur.fr/pub/GenSoft/unix/misc/Pise/. The complete distribution is available at ftp://ftp.pasteur.fr/pub/GenSoft/unix/misc/Pise/Pise-light.tar.gz.The current version is 5.a (XML version).

EMBOSS XML files are distributed with the standard Pise distribution. There are also in a separate file: ftp://ftp.pasteur.fr/pub/GenSoft/unix/misc/Pise/emboss_xml_files.tar.gz.

In case of problem, you may try one of the ftp mirrors.

Copyright

Packages required:
  1. perl5, with the following modules (if you look for a Perl module which is not already in your Perl installation, see the CPAN):
  2. Sequence format conversion:
  3. perl5 modules:
  4. rxp: an XML parser (download).
  5. PSGML: GNU Emacs Major Mode for editing SGML and XML coded documents -- optional.
  6. PBS: Portable Batch System. -- optional. If you choose to install it, the PBS variable in the lib/web.pl file should be set to 1 (defautl). If not, don't forget to set hits variable to 0.
    IMPORTANT: you must configure PBS not to use its spool directory to store standard ouput files before job completion. Uncomment the following line in file ./src/include/server_limits.h: 
    #define NO_SPOOL_OUTPUT 1   /* User output in home directory,not spool */
  7. Others:

Copyright

Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 Institut Pasteur & Catherine Letondal

This program is free software; you can redistribute it and/or modify it under the terms of the General Public Licence as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

Pise stands for Pasteur Institute Software Environment!!

Mirror sites

Contribs

Pise users' contributed XML files: ftp://ftp.pasteur.fr/pub/GenSoft/unix/misc/Pise/contrib.

Send XML definition files you would like to be added in this repository to: pise@pasteur.fr.

Pise FAQ

See also the README, the lib/web.pl file and the required packages.
  1. Why isn't a particular program working while the others are?

  2. I get a perl error in the Web server error log: 
    Can't locate Pasteur/Email.pm in @INC (...)
    Why is that?

  3. Where is it possible to define my local databases?

  4. Where do I set up environment variables for the x program to work? (e.g: BLASTDB environment variable for the blast program)

  5. I don't need to install interfaces for that many programs or I don't want all this long list of programs which can be subsequently run on the output of another. Is there a list of local programs somewhere?

  6. How do I configure the EMBOSS PLPLOT_LIB variable?

  7. I get an error when using make, which is calling a false command: 
    % make PROGRAM=clustalw
[...]
PISEDIR=/local/lib/Pise/5.a; export PISEDIR ; \
VERSION=5.a; export VERSION ; \
          false -e -V ./Xml/clustalw.xml | ./Parser/runparser.pl > PerlDef/clustalw.pm
no element found at line 1, column 0, byte 0 at
[...]
make: Fatal error: Command failed for target `PerlDef/clustalw.pm'
    Why is that?

  8. I get an error when using make, when calling rxp: 
    % make PROGRAM=clustalw
[...]
PISEDIR=/local/lib/Pise/5.a; export PISEDIR ; \
VERSION=5.a; export VERSION ; \
          /usr/local/bin/rxp -V ./Xml/clustalw.xml | ./Parser/runparser.pl > PerlDef/clustalw.pm
Error: Document ends too soon
  in unnamed entity at line 1 char 1 of
 file:///local/lib/Pise/5.a/Xml/clustalw.xml
    Why is that?

  9. I get an error when compiling seqio: 
    gcc -g -O2 -Wall -Wshadow   -c -o grepseq.o grepseq.c
grepseq.c:21: error: conflicting types for `sys_errlist'
/usr/include/bits/sys_errlist.h:28: error: previous declaration of `sys_errlist'
    Just comment the line: 
    extern char *sys_errlist[];
    ==> 
    /* extern char *sys_errlist[]; */
    into the C source files (e.g: grepseq.c, fmtseq.c, ...).

  10. I get errors when running the CGI: Error while executing... or Internal server error ...

  11. I get an error when running the CGI: PANIC: An error occured while executing program , and the Web error log file displays: CGI for program received SIGCHLD from ...

  12. How do I find the fastDNAml_boot_web and concattree scripts called through the fastdnaml Web interface?

  13. I would like to install the PHYLIP package under Pise, but I don't have indenttree, which the Xml files include in the command?

  14. I have troubles finding, installing or compiling the x program for which there is a Pise interface definition?

  15. I am writing an XML definition for a program foobar in the file barfoo. When I try to make the interface, Ím getting a message: Can't locate object method "new" via package "barfoo" at ./Maker/make-html.pl line 20.. What's going on?

  16. I am writing an XML definition for a program do.analysis. When I try to make the interface, Ím getting a message: Can't locate object method "new" via package "do.analysis" at.... What's going on?

  17. Where is it possible to set up our local batch commands?

  18. Are there any cleaning scripts for temporary jobs data?

  19. Is there a way to display the resultant output to the user as a web page rather than emailing the html document?

  20. I have put a default value in the XML definition file, but it is not correctly set at run time.

  21. I have installed Pise, but when I run the program, nothing appends?

  22. When using the fuzzpro or fuzznuc EMBOSS programs, I tried to use the normal PROSITE style, but it seems that the definitions [] for alternative and {} for forbidden were not acceptable?

  23. How do you pronounce "Pise"?

Contacts:

References

Letondal C. A Web interface generator for molecular biology programs in Unix, Bioinformatics, 17(1), 2001, pp 73-82.

Credits:

Stéphane Bortzmeyer has helped me a lot by helping me start this program, and giving me very important advice on making it a correct package.

Many thanks also to Stéphane Bortzmeyer, Daniel Azuelos, Christophe Wolfhugel and Frédéric Chauveau for the discussions about the security and synchronization issues and to all the users that have tested the interface.

Many thanks as well to the persons who have helped for the installation steps and who have given a lot of feedback: Alan Bleasby, Leonardo Marino-Ramirez, Katja Schuerer, Nicolas Joly and Burkhard Linke.

Several colleagues have help building the XML definition files over the years: Katja Schuerer, Nicolas Joly, Bertrand Neron, Eric Deveaud, Corinne Maufrais, Bernard Caudron, Thierry Rose.

Pierre Tuffery, François Moreews, Cynthia Alland and Yan Wong have built a whole integrated Web portal based on a Pise-like DTD, re-developped in Python. Their work is a rich source of inspiration, ideas and even source code for Mobyle, the next version of Pise.

Bertrand Neron is now the full-time co-developer of Mobyle. Thanks to him for his creative and very professional participation to the project.