This is an automated email from the git hooks/post-receive script.

malex-guest pushed a commit to branch master
in repository plip.

commit 2b99b24c066d096c9fad811d556f3dcb4b3db4e9
Author: Alexandre Mestiashvili <a...@biotec.tu-dresden.de>
Date:   Mon Sep 19 16:55:44 2016 +0200

    New upstream version 1.3.2+dfsg
---
 CHANGES.txt                            |   7 +
 DOCUMENTATION.md                       | 365 +++++++++++++++++++++++++++------
 README.md                              | 105 +++++++---
 plip/modules/config.py                 |   4 +-
 plip/modules/detection.py              |   5 +-
 plip/modules/preparation.py            | 111 +++++++---
 plip/modules/pymolplip.py              |  10 +-
 plip/modules/report.py                 |  87 +++++++-
 plip/modules/supplemental.py           |  11 +
 plip/modules/visualize.py              |  43 +++-
 plip/modules/webservices.py            |  67 ++++++
 plip/plipcmd                           | 121 ++---------
 plip/test/test_basic_functions.py      |  90 +++++++-
 plip/test/test_literature_validated.py |   4 +-
 plip/test/test_remote_services.py      |  46 +++++
 setup.py                               |   2 +-
 16 files changed, 828 insertions(+), 250 deletions(-)

diff --git a/CHANGES.txt b/CHANGES.txt
index 431fb7b..921ce28 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -1,6 +1,13 @@
 Changelog
 ---------
 
+### 1.3.2
+* __Processing of protein-peptide interactions via --peptides__
+* option to keep modified residues as ligands (--keepmod)
+* Improved code for reports
+* Smart ordering of ligand in composite compounds
+* Fixes handling and visualization of DNA/RNA
+
 ### 1.3.1
 * __Support for amino acids as ligands__
 * __Plugin-ready for PyMOL and Chimera__
diff --git a/DOCUMENTATION.md b/DOCUMENTATION.md
index 7099037..947cc0d 100644
--- a/DOCUMENTATION.md
+++ b/DOCUMENTATION.md
@@ -1,122 +1,345 @@
-===========
-PLIP v1.2.2
-===========
+# Protein-Ligand Interaction Profiler (PLIP)
 
+## What is PLIP?
 The Protein-Ligand Interaction Profiler (PLIP) is a tool to analyze and 
visualize protein-ligand interactions in PDB files.
 
+## Why should I use PLIP?
 
-Features
-========
-* Detection of eight different types of noncovalent interactions, including 
metal complexes
-* Works for complexes of protein with small molecules, ions, polymers, or 
DNA/RNA (and all combinations)
+#### Comprehensive Detection of Interaction
+* Eight types of noncovalent interactions
+* Interaction between proteins and
+  * small molecules
+  * ions
+  * polymers
+  * DNA / RNA
+* Rich additiona information on binding, e.g. unpaired functional groups
+
+#### Everything Is Automated
+
+* Direct download of PDB structures from PDB server
 * Automatic detection and grouping of relevant ligands in a PDB file
-* Rich additional information on binding, e.g. unpaired functional groups
-* Direct download of PDB structures from wwPDB server if valid PDB ID is given
-* Processing of custom PDB files containing protein-ligand complexes (e.g. 
from docking)
 * No need for special preparation of a PDB file, works out of the box
+* Automatic fixiing of errors in PDB files
+
+#### Flexible Usage
+* Processing of custom PDB files containing protein-ligand complexes (e.g. 
from docking)
 * Atom-level interaction reports in TXT and XML formats for easy parsing
 * Generation of PyMOL session files (.pse), enabling easy preparation of 
images for publications and talks
 * Rendering of 3D interaction diagram for each ligand and its interactions 
with the protein
 
-Quickstart
-==========
-Run the PLIP python script with the option `-h` to list all available command 
line options.
-To analyze a protein-ligand complex from a Protein Data Bank entry -- e.g. 
1vsn --, run
-    `plipcmd -i 1vsn`.
-To analyze a PDB file from your workstation, run
-    `plipcmd -f path_to_pdbfile.pdb`.
-The output format(s) can be chosen freely, ranging from ...
-* XML report files (`-x`, highest level of detail)
-* Text report files (`-t`, medium level of detail)
+## Get PLIP running
+
+#### 1. Install dependencies
+The following instructions work on a unix machine.
+If you are using Windows or OSX, the process may differ.
+Please refer to the webpages of the corresponding tools to get help for 
installation.
+
+To install all dependencies for PLIP, either just install PyMOL and then use 
the `pip` installation routine or install all tools and clone from GitHub.
+The current version of PLIP depends on
+* OpenBabel >=2.3.2
+* PyMOL 1.7.x with Python bindings
+* Imagemagick >=6.9.x (optional)
+
+and should be executed with Python 2.7.x.
+
+Example command for Ubuntu using apt-get
+```bash
+sudo apt-get install pymol openbabel python-openbabel imagemagick
+```
+
+
+#### 2. Get PLIP on your machine
+
+There are several options to get PLIP on your machine.
+If you have the Python package manager `pip` installed, you can install PLIP 
in a terminal via the following command:
+
+```bash
+pip install plip
+```
+If you want to clone from Github, open a new system terminal and clone the 
repository using
+```bash
+git clone https://github.com/ssalentin/plip.git ~/pliptool
+```
+You can use any other user directory, but we will use the one given above for 
the documentation.
+
+#### 3. Simplify access to PLIP
+
+The package manager `pip` will create symlinks for you so you can call PLIP 
using `plip` in the command line. If you cloned from Github, use the following 
command to do the same:
+
+```bash
+alias plip='~/pliptool/plip/plipcmd'
+```
+
+## Analyze a PDB structure with PLIP
+
+### Single Structures
+Having PLIP installed, you can run
+```bash
+plip -h
+```
+to list all available command line options.
+We will go through all important settings in this section.
+A typical application of PLIP involves the analysis of protein-ligand 
interactions in a structure from the Protein Data Bank (PDB).
+PLIP can automatically fetch the entry from the PDB server when a valid PDB ID 
is provided.
+```bash
+plip -i 1vsn -v
+```
+The command above will fetch the PDB entry 1vsn from the server, analyze all 
interactions and print out the results (verbose mode).
+No output files are produced at this point.
+
+The same can be done for local PDB files.
+
+```bash
+wget http://files.rcsb.org/download/1EVE.pdb
+plip -f 1EVE.pdb -v
+```
+
+The output formats can be added in any combination, currently including:
+* XML report files (`-x`, best for automatic processing)
+* Text report files (`-t`, human-readable)
 * PyMOL session files (`-y`)
 * Ray-traced images (`-p`)
-* Verbose output on command line (`-v`)
 
-Threshold settings
-==================
-All geometric thresholds used for detection of interactions in PLIP are stored 
in the `config.py` module and can be
-changed there permanently if desired. Another possibility is to change single 
parameters via command line options when
-running plip. The naming of the variables is identical to those in the config 
file, but all lowercase. Specify the
+```bash
+plip -i 1osn -pyx
+```
+
+The command above will fetch the PDB entry 1osn, analyze all interactions and 
produce one XML result file (`-x`) as well as rendered images (`-p`) and PyMOL 
session files (`-y`) for each binding site.
+
+### Batch Mode
+PLIP can process multiple structures at once, either from PDB or local files.
+To activate batch mode, just provide a list of PDB IDs or local file names, 
e.g.:
+
+```bash
+plip -i 1vsn 1osn 2reg -vx
+```
+
+PLIP will create subdirectories for each given structure in the output folder.
+If in PDB ID mode (`i`), the folder structure will be nested and based on the 
two middle characters of the PDB ID.
+The structure 1vsn in batch processing will have its output files in 
<outputfolder>/vs/1vsn .
+
+### Detection of protein-peptide interactions
+For the detection of ligands, PLIP relies on the separation of ATOM and HETATM 
entries in the PDB file.
+The latter are searched for suitable ligands when running in normal mode.
+Peptide ligands, however, are usually deposited as ATOM entries in a separate 
chain.
+PLIP can not detect these entities automatically.
+To switch into protein-peptide interaction mode, start PLIP with the option 
`--peptide`, followed by the peptide chain of interest, e.g.:
+
+```bash
+plip -i 5hi4 --peptides I -vx
+```
+
+## Changing detection thresholds
+The PLIP algorithm uses a rule-based detection to report non-covalent 
interaction between proteins and their partners.
+The current settings are based on literature values and have been refined 
based on extensive testing with independent cases from mainly crystallography 
journals, covering a broad range of structure resolutions.
+For most users, it is not recommended to change the standard settings.
+However, there may be cases where changing detection thresholds is advisable 
(e.g. sets with multiple very low resolution structures)
+PLIP allows you to change the setting permanently or for one run.
+
+#### Permanent change
+PLIP settings are stored in the file `modules/config.py`, which is loaded in 
each run.
+One section in the file includes assignments of standard values to all 
distance and angle thresholds, together with short descriptions.
+Changing the values in this file means they will be changed permanently for 
PLIP.
+Furthermore, filter settings for ligands (metal ions in complexes, unsupported 
ligands, warnings for possible artifacts) can be changed in this file as well.
+
+#### Temporary change
+
+Thresholds can be changed for each run using command-line parameters.
+The naming of the variables is identical to those in the config file, but all 
lowercase.
+Specify the
 threshold you want to change and the new value, e.g. to change 
HYDROPH_DIST_MAX to 5 Angstrom, run PLIP using
-    `python plip-cmd.py -i 1vsn --hydroph_dist_max 5`
+```bash
+plip -i 1vsn --hydroph_dist_max 5
+```
 All distance thresholds can be increased to up to 10 Angstrom. Thresholds for 
angles can be set between 0 and 180 degree.
 If two interdependent thresholds have conflicting values, PLIP will show an 
error message.
 
-Web Service
-===========
+## Further Options
+PLIP offers further command line options which enables you to switch advanced 
settings.
+* Set number `n` of maximum threads used for parallel processing 
(`--maxthreads <n>`)
+* Do not automatically combine covalently bound ligands (`--breakcomposite`)
+* Do not discard alternate locations (`--altlocation`)
+* Set debug mode (`--debug`)
+* Turn off automatic fixing of errors in PDB files (`--nofix`)
+* Keep modified residues as ligands (`--keepmod`)
+
+## Web Service
 A web service for analysis of protein-ligand complexes using PLIP is available 
at
-http://projects.biotec.tu-dresden.de/plip-web
+http://plip.biotec.tu-dresden.de/
 The web site offers advanced functions to search for specific entries from PDB 
and lists the interaction results in the browser.
+Additionally, the service used the BioLiP database to annotate biologically 
relevant ligands.
+The option to change threshold, ligand filtering, and batch processing is only 
available in the command line tool and with the Python modules.
+
+## Algorithm
+PLIP uses a rule-based system for detection of non-covalent interactions 
between protein residues and ligands.
+Information on chemical groups able to participate in a specific interaction 
(e.g. requirements for hydrogen bond donors) and interaction geometry (e.g. 
distance and angle thresholds) from literature are used to detect 
characteristics of non-covalent interactions between contacting atoms of 
protein and ligands.
+For each binding site, the algorithm searches first for atoms or atom groups 
in the protein and ligand which could possibly be partner in specific 
interactions.
+In the second step, geometric rules are applied to match groups in protein and 
ligand forming an interaction.
+
+#### Detection and filtering of ligands
+Previous to the detection step for the interactions, PLIP extracts all ligands 
contained in the structure.
+Modified amino acids are identified and excluded using MODRES entries of the 
PDB files.
+Additionally, it uses the BioLiP list of possible artifacts to remove ligands 
which are in this list and appear 15 times or more in a structure.
+Just a few compounds are currently excluded, being listed in the PLIP config 
file.
+
+#### Preparation of structures
+Polar hydrogens are added to the structure and alternative 
conformations/models/positions removed.
+Missing chains are assigned to ligands and non-standard ligand names (with 
special characters) altered to LIG.
+
+#### Detection of possible interacting groups
+
+##### Binding site atoms
+The binding site distance cutoff is determined by adding up BS_DIST_MAX to the 
maximum extent to the ligand (maximum distance of a ligand atom to ligand 
centroid).
+All protein atoms within this distance cutoff to any binding site atoms are 
counted as belonging to the binding site.
+
+##### Hydrophobic Atoms
+An atom is classified as hydrophobic if it is a carbon and has only carbon or 
hydrogen atoms as neighbours.
+
+##### Aromatic Rings
+OpenBabel is used to identify rings (SSSR perception) and their aromaticity.
+In cases where no aromaticity is reported by OpenBabel, the ring is checked 
for planarity.
+To this end, the normals of each atom in the ring to its neighbors is 
calculated.
+The angle between each pair of normals has to be less than AROMATIC_PLANARITY.
+If this holds true, the ring is also considered as aromatic.
+
+##### Hydrogen Bond Donors and Acceptors
+OpenBabel is used to identify hydrogen bond donor and acceptor atoms.
+Halogen atoms are excluded from this group and treated separately (see below).
+
+##### Charged Groups
+The detection of charged groups is only exhaustive for the binding site, not 
the ligands.
+For proteins, positive charges are attributed to the side chain nitrogens of 
Arginine, Histidine and Lysine.
+Negative charged are assigned to the carboxyl groups in Aspartic Acid and 
Glutamic Acid.
+In ligands, positive charges are assigned to quaterny ammonium groups, 
tertiary amines (assuming the nitrogen could pick up a hydrogen and thus get 
charged), sulfonium and guanidine groups.
+Negative charges are reported for phosphate, sulfonate, sulfonic acid and 
carboxylate.
+
+##### Halogen bonds donors and acceptors
+Assuming that halogen atoms are not present in proteins (unless they are 
artificially modified), halogen bond donors are searched for only in ligands.
+All fluorine, chlorine, bromide or iodine atoms connected to a carbon atom 
qualify as donors.
+Halogen bond acceptors in proteins are all carbon, phosphor or sulphur atoms 
connected to oxygen, phosphor, nitrogen or sulfur.
 
+##### Water
+Water atoms are assigned to a ligand-binding site complex if their oxygen 
atoms are within a certain cutoff to the ligand.
+The cutoff is determined by adding up BS_DIST_MAX to the maximum extent to the 
ligand (maximum distance of a ligand atom to ligand centroid).
+This means the farthest distance of a ligand to a water atom is BS_DIST_MAX.
+
+#### Detection of interactions
+For an overview on geometric cutoffs used for the prediction of interactions, 
please refer to the config file.
+Note that the threshold can not be changed for jobs running on PLIP Web.
+The command line tool (sourcecode available for download), however, allows 
changing all listed parameters permanently or for single runs.
+
+##### Hydrophobic Interactions
+As hydrophobic interactions result from entropic changes rather than 
attractive forces between atoms, there are no clear geometries of hydrophobic 
association.
+The observed attraction between hydrophobic atoms decays exponentionally with 
the distance between them.
+
+A generous cutoff was chosen, identifying a prime set of hydrophobic 
interactions between all pairs of hydrophobic atoms within a distance of 
HYDROPH_DIST_MAX.
+Since the number of hydrophobic interactions with such an one-step approach 
can easily surpass all other interaction types combined, it may strongly 
influence subsequent evaluation or applications as interaction fingerprinting.
+To overcome this problem, the number of hydrophobic interactions is reduced in 
several steps.
+First, hydrophobic interactions between rings interacting via π-stacking are 
removed.
+This is done because stacking already involves hydrophobic interactions.
 
-Documentation
-=============
+Second, two clustering steps are applied.
+If a ligand atom interacts with several binding site atoms in the same 
residue, only the interaction with the closest distance is kept.
+Subsequently, the set of hydrophobic interactions is checked from the opposite 
perspective: if a protein atom interacts with several neighboring ligand atoms, 
just the interaction with the closest distance is kept.
+Together, these reduction steps help to report only the most representative 
hydrophobic interactions.
 
-Algorithm
----------
-PLIP uses a rule-based algorithm for the detection of non-covalent 
interactions. For details on the algorithm, visit
-http://projects.biotec.tu-dresden.de/plip-web
+##### Hydrogen Bonds
+A hydrogen bond between a hydrogen bond donor and acceptor is reported if 
several geometric requirements are fulfilled.
+The distance has to be less than HBOND_DIST_MAX and the angle at the donor 
group (D-H...A) above HBOND_DON_ANGLE_MIN.
 
-Exit codes
-----------
-1 : Unspecified Error
-2 : Empty PDB file as input
-3 : Invalid PDB ID (wrong format)
-4 : PDB file can't be read by OpenBabel (due to invalid input files)
-5 : PDB ID is valid, but wwPDB offers no file in PDB format for download.
+Since salt bridges involve purely electrostatic interactions as well as 
hydrogen bonds, it is not meaningful to report both interaction types between 
the same groups.
+Thus, hydrogen bonds between atoms are removed if they belong to groups that 
already form a salt bridge to that atom.
 
-Legend for PyMOL visualization
-------------------------------
-All colors given as RGB values.
-<Description> - <RGB> - <PyMOL color> - <Representation>
+As a general rule, a hydrogen bond donor can take part in only one hydrogen 
bond, while acceptor atoms can be partners in multiple hydrogen bonds (e.g. 
bifurcated hydrogen bonds).
+For multiple possible hydrogen bonds from one donor, only the contact with the 
donor angle closer to 180 ° is kept.
 
-__Structural Elements__
+##### π-Stacking
+π-Stacking for two aromatic rings is reported whenever their centers are 
within a distance of PISTACK_DIST_MAX, the angle deviates no more than 
PISTACK_ANG_DEV from the optimal angle of 90 ° for T-stacking or 180 ° for 
P-stacking.
 
+Additionally, each ring center is projected onto the opposite ring plane.
+The distance between the other ring center and the projected point (i.e. the 
offset) has to be less than PISTACK_OFFSET_MAX.
+This value corresponds approximately to the radius of benzene + 0.6 Å.
 
-Protein - [43, 131, 186] - myblue (custom) - sticks
+##### π-Cation Interactions
+π-Cation interactions are reported for each pairing of a positive charge and 
an aromatic ring if the distance between the charge center and the aromatic 
ring center is less than PICATION_DIST_MAX.
+In the case of a putative π-cation interaction with a tertiary amine of the 
ligand, an additional angle criterion is applied (see documentation in the 
source code).
 
-Ligand - [253, 174, 97] - myorange (custom) - sticks
+##### Salt Bridges
+Whenever two centers of opposite charges come within a distance of 
SALTBRIDGE_DIST_MAX, a salt bridge is reported.
+In contrast to hydrogen bonds, there are no additonal geometric restrictions.
 
-Water - [191, 191, 255] - lightblue - nb_spheres
+##### Water bridges
+While residues can be bridged by more than one water molecule, for the 
prediction in this script the only case considered is one water molecule 
bridging ligand and protein atoms via hydrogen bonding.
 
-Charge Center - [255, 255, 0] - yellow - spheres
+The water molecule has to be positioned between hydrogen bond donor/acceptor 
pairs of ligand and protein with distances of the water oxygen within 
WATER_BRIDGE_MINDIST and WATER_BRIDGE_MAXDIST to the corresponding polar atoms 
of the donor or acceptor groups.
+If a constellation with a water atom fulfils these requirements, two angles 
are checked.
+The angle ω between the acceptor atom, the water oxygen and donor hydrogen has 
to be within WATER_BRIDGE_OMEGA_MIN and WATER_BRIDGE_OMEGA_MAX.
+Additionally, the angle θ between the water oxygen, the donor hydrogen and the 
donor atom has to be larger than WATER_BRIDGE_THETA_MIN.
 
-Aromatic Ring Center - [230, 230, 230] -  grey90 - spheres
+Similar to standard hydrogen bonds, a water molecule is only allowed to 
participate as donor in two hydrogen bonds (two hydrogen atoms as donors).
+In the case of more than two possible hydrogen bonds for a water molecule as 
donor, only the two contacts with a water angle closest to 110 ° are kept
 
-Ions - [255, 255, 128] - hotpink - spheres
+##### Halogen Bonds
+Halogen bonds are reported for each pairing of halogen bond acceptor and donor 
group having a distance of less than HALOGEN_DIST_MAX and angles at the donor 
and acceptor group of HALOGEN_DON_ANGLE and HALOGEN_ACC_ANGLE with a deviation 
of no more than HALOGEN_ANG_DEV
 
+##### Metal Complexes
+For metal complexes, PLIP considers metal ions from a set of more than 50 
species (see PLIP config for more details).
+Possible interacting groups in the protein are sidechains of cystein (S), 
histidine (N), asparagine, glutamic acid, serin, threonin, and tyrosin (all O), 
as well as all main chain oxygens.
 
-__Interactions__
+In ligands, following groups are considered for metal complexation: alcohols, 
phenolates, carboxylates, phosphoryls, thiolates, imidazoles, pyrroles, and the 
iron-sulfur cluster as a special constellation.
+For one metal ions, all groups with a maximum distance of METAL_DIST_MAX to 
the ligand are considered for the complex.
 
+After assigning all target groups to one metal ions, the resulting set of 
angles of the complex is compared with known sets of angles from common 
coordination geometries (linear [2], trigonal planar [3], trigonal pyramidal 
[3], tetrahedral [4], square planar [4], trigonal bipyramidal [5], square 
pyramidal [5], and octahedral [6]).
+The best fit with the least difference in observed targets is chosen as an 
estimated geometry and targets superfluous to the constellation are removed.
 
-Hydrophobic Interaction - [128, 128, 128] - grey50 - dashed Line
+## Additional Information
 
-Hydrogen Bond - [0, 0, 255] - blue - solid Line
+### Exit error codes
 
-Water Bridges - [191, 191, 255] - lightblue - solid Line
+| Exit code  | Description |
+| ------------- | ------------- |
+| **1**  | Unspecified Error  |
+| **2**  | Empty PDB file as input |
+| **3**  | Invalid PDB ID (wrong format)  |
+| **4**  | PDB file can't be read by OpenBabel  |
+| **5**  | Valid PDB ID, but no PDB file on wwwPDB  |
 
-pi-Stacking (parallel) - [0, 255, 0] - green - dashed Line
+### Legend for PyMOL visualization
 
-pi-Stacking (perpendicular) - [140, 179, 102] - smudge - dashed Line
+#### Structural Elements
 
-pi-Cation Interaction - [255, 128, 0] - orange - dashed Line
+| Description  | RGB | PyMOL color | Representation |
+| ------------ | --- | ------------| ---------------|
+| Protein  | [43, 131, 186] | myblue (custom) | sticks |
+| Ligand  | [253, 174, 97] | myorange (custom) | sticks |
+| Water  | [191, 191, 255]  | lightblue | nb_spheres |
+| Charge Center | [255, 255, 0] | yellow | spheres |
+| Aromatic Ring Center  | [230, 230, 230] | grey90 | spheres |
+| Ions | [250, 255, 128] | hotpink | spheres |
 
-Halogen Bond - [64, 255, 191] - greencyan - solid Line
 
-Salt Bridge - [255, 255, 0] - yellow - dashed Line
+#### Interactions
 
-Metal Complexation - [140, 64, 153] - violetpurple - dashed Line
+| Description  | RGB | PyMOL color | Representation |
+| ------------ | --- | ------------| -------------- |
+| Hydrophobic Interaction  | [128, 128, 128] | grey50 | dashed |
+| Hydrogen Bond  | [0, 0, 255] | blue | solid line |
+| Water Bridges  | [191, 191, 255]  | lightblue | solid line |
+| pi-Stacking (parallel) | [0, 255, 0] | green | dashed line |
+| pi-Stacking (perpendicular)  | [140, 179, 102] | smudge | dashed line |
+| pi-Cation Interaction | [255, 128, 0] | orange | dashed line |
+| Halogen Bond | [54, 255, 191] | greencyan | solid line |
+| Salt Bridge | [255, 255, 0] | yellow | dashed line |
+| Metal Complex | [140, 64, 153] | violetpurple | dashed line |
 
 
-XML Report Documentation
-------------------------
 
+### XML Report Documentation
 
 **report**
 
 Contains all binding site information
 
-
 **plipversion**
 
 Version of PLIP used for generating the output file
@@ -260,3 +483,11 @@ Coordinates of interacting ligand atom or interaction 
center in ligand
 **protcoo**
 
 Coordinates of interacting protein atom or interaction center in ligand
+
+## Testing
+To run the tests, run the following set of commands.
+
+```bash
+cd ~/pliptool/plip/test
+python -m unittest test*
+```
diff --git a/README.md b/README.md
index fb8cb63..df1d8cf 100644
--- a/README.md
+++ b/README.md
@@ -1,43 +1,94 @@
-PLIP
-====
+# PLIP
 
-Protein-Ligand Interaction Profiler (PLIP) - Analyze non-covalent 
protein-ligand interactions in 3D structures
+**Protein-Ligand Interaction Profiler (PLIP)**
 
-Versions
---------
-The latest commits may contain newer, but untested features. The last version 
marked as release is always stable.
 
-Installation
-------------
+ Analyze non-covalent protein-ligand interactions in 3D structures
 
-Previous to the installation of PLIP, make sure you have the following tools 
and libraries installed:
-* Python 2.x
+## How to use PLIP
+
+#### 1. Clone the repository
+
+Open a new system terminal and clone this repository using
+```bash
+git clone https://github.com/ssalentin/plip.git ~/pliptool
+```
+#### 2. Run PLIP
+
+##### As a command line tool
+
+Run the `plipcmd` script inside the PLIP folder to detect, report, and 
visualize interactions. The following example creates a PYMOL visualization for 
the interactions
+between the inhibitor NFT and its target protein in the PDB structure 1VSN.
+
+```bash
+alias plip='~/pliptool/plip/plipcmd'
+mkdir /tmp/1vsn && cd /tmp/1vsn
+plip -i 1vsn -yv
+pymol 1VSN_NFT_A_283.pse
+```
+
+##### As a python library
+
+In your terminal, add the PLIP repository to your PYTHONPATH variable.
+For our example, we also download a PDB file for testing.
+```bash
+export PYTHONPATH=~/pliptool/plip:${PYTHONPATH}
+cd /tmp && wget http://files.rcsb.org/download/1EVE.pdb
+python
+```
+In python, import the PLIP modules, load a PDB structure and run the analysis.
+This small example shows how to print all numbers of residues involved in 
pi-stacking:
+
+```python
+from plip.modules.preparation import PDBComplex
+
+my_mol = PDBComplex()
+my_mol.load_pdb('/tmp/1EVE.pdb') # Load the PDB file into PLIP class
+print my_mol # Shows name of structure and ligand binding sites
+my_bsid = 'E20:A:2001' # Unique binding site identifier (HetID:Chain:Position)
+my_mol.analyze()
+my_interactions = my_mol.interaction_sets[my_bsid] # Contains all interaction 
data
+
+# Now print numbers of all residues taking part in pi-stacking
+print [pistack.resnr for pistack in s.pistacking] # Prints [84, 129]
+```
+
+#### 3. View and process the results
+PLIP offers various output formats, ranging from renderes images and PyMOL 
session files to human-readable text files and XML files.
+By default, all files are deposited in the working directory unless and output 
path is provided.
+For a full documentation of running options and output formats, please refear 
to the documentation.
+
+## Versions and Branches
+For production environments, you should use the latest versioned commit from 
the stable branch.
+Newer commits from the stable and development branch may contains new but 
untested and not documented features.
+
+## Requirements
+Previous to using PLIP, make sure you have the following tools and libraries 
installed:
+* Python 2.7.x
 * OpenBabel >=2.3.2
 * PyMOL 1.7.x with Python bindings
-* pip (Python package managaer)
-* Imagemagick (optional, needed for automatic cropping of images)
-
-To install PLIP, simply run the following command using a terminal
-> python setup.py install
+* Imagemagick >=6.9.x (optional)
 
-Code Contributions
-------------------
+## Contributions
 Sebastian Salentin sebastian.salentin (at) biotec.tu-dresden.de
 
-Joachim Haupt joachim.haupt (at) biotec.tu-dresden.de
+Joachim Haupt joachim.haupt (at) biotec.tu-dresden.de | 
https://github.com/vjhaupt
+
+Melissa F. Adasme Mora melissa.adasme (at) biotec.tu-dresden.de
 
-Melissa F. Adasme Mora melissa.adasme (at) biotec.tu-dresden.de (Testing and 
Validation)
+## PLIP Web Server
+Visit our PLIP Web Server on http://plip.biotec.tu-dresden.de/
 
-PLIP Web Server
----------------
-Visit our PLIP Web Server on http://projects.biotec.tu-dresden.de/plip-web
+## Contact Me
+Do you have feature requests, found a bug or want to use `PLIP` in your 
project?
+Write me an email to sebastian.salentin (at) biotec.tu-dresden.de
 
-Contact Me
-----------
-Questions or comments about `PLIP`? Write me an email to sebastian.salentin 
(at) biotec.tu-dresden.de
+## License Information
+PLIP is published under the Apache License. For more information, please read 
the LICENSE.txt file.
+Using PLIP in your commercial or non-commercial project is generally possible 
when giving a proper reference to this project and the publication in NAR.
+If you are unsure about usage options, don't hesitate to contact me.
 
-Citation Information
---------------------
+## Citation Information
 If you are using PLIP in your work, please cite
 > Salentin,S. et al. PLIP: fully automated protein-ligand interaction profiler.
 > Nucl. Acids Res. (1 July 2015) 43 (W1): W443-W447. doi: 10.1093/nar/gkv315
diff --git a/plip/modules/config.py b/plip/modules/config.py
index 7f78ad4..3f1a8ea 100644
--- a/plip/modules/config.py
+++ b/plip/modules/config.py
@@ -23,13 +23,14 @@ XML = False
 TXT = False
 PICS = False
 PYMOL = False
-VISJSON = False  # JSON File of PyMOL helper class (for web service)
 OUTPATH = './'
 BASEPATH = './'
 BREAKCOMPOSITE = False  # Break up composite ligands with covalent bonds
 ALTLOC = False  # Consider alternate locations
 PLUGIN_MODE = False  # Special mode for PLIP in Plugins (e.g. PyMOL)
 NOFIX = False  # Turn off fixing of errors in PDB files
+PEPTIDES = []  # Definition which chains should be considered as peptide 
ligands
+KEEPMOD = False
 
 # Configuration file for Protein-Ligand Interaction Profiler (PLIP)
 # Set thresholds for detection of interactions
@@ -79,6 +80,7 @@ other = ['MO', 'RE', 'HO']
 UNSUPPORTED = anions + other
 
 # BioLiP list of suspicious ligands from 
http://zhanglab.ccmb.med.umich.edu/BioLiP/ligand_list (2014-07-10)
+# Add ligands here to get warnings for possible artifacts.
 biolip_list = ['ACE', 'HEX', 'TMA', 'SOH', 'P25', 'CCN', 'PR', 'PTN', 'NO3', 
'TCN', 'BU1', 'BCN', 'CB3', 'HCS', 'NBN',
                'SO2', 'MO6', 'MOH', 'CAC', 'MLT', 'KR', '6PH', 'MOS', 'UNL', 
'MO3', 'SR', 'CD3', 'PB', 'ACM', 'LUT',
                'PMS', 'OF3', 'SCN', 'DHB', 'E4N', '13P', '3PG', 'CYC', 'NC', 
'BEN', 'NAO', 'PHQ', 'EPE', 'BME', 'TB',
diff --git a/plip/modules/detection.py b/plip/modules/detection.py
index 5aa64f9..2087552 100644
--- a/plip/modules/detection.py
+++ b/plip/modules/detection.py
@@ -372,8 +372,9 @@ def metal_complexation(metals, metal_binding_lig, 
metal_binding_bs):
                     final_geom, final_coo, = next_total.geometry, 
next_total.coordination
                     rms, excluded = next_total.rms, next_total.excluded
                     break
-                elif i == len(all_total) - 1:
-                    final_geom, final_coo, rms, excluded = "NA", "NA", 0.0, []
+                elif i == len(all_total) - 2:
+                    final_geom, final_coo, rms, excluded = "NA", "NA", 
float('nan'), []
+                    break
 
         # Record all contact pairing, excluding those with targets superfluous 
for chosen geometry
         only_water = set([x[0].location for x in contact_pairs]) == {'water'}
diff --git a/plip/modules/preparation.py b/plip/modules/preparation.py
index d083c9b..a8b12be 100644
--- a/plip/modules/preparation.py
+++ b/plip/modules/preparation.py
@@ -182,41 +182,72 @@ class LigandFinder:
         self.ligands = self.getligs()
         self.excluded = 
sorted(list(self.lignames_all.difference(set(self.lignames_kept))))
 
+    def getpeptides(self, chain):
+        """If peptide ligand chains are defined via the command line options,
+        try to extract the underlying ligand formed by all residues in the
+        given chain without water
+        """
+        data = namedtuple('ligand', 'mol hetid chain position water members 
longname type atomorder can_to_pdb')
+        all_from_chain = [o for o in 
pybel.ob.OBResidueIter(self.proteincomplex.OBMol) if o.GetChain() == chain] # 
All residues from chain
+        if len(all_from_chain) == 0:
+            return None
+        else:
+            #TODO Can be done shorter with a split
+            water = [o for o in all_from_chain if o.GetResidueProperty(9)]
+            non_water = water = [o for o in all_from_chain if not 
o.GetResidueProperty(9)]
+            ligand = self.extract_ligand(non_water)
+            return ligand
+
+
     def getligs(self):
         """Get all ligands from a PDB file and prepare them for analysis.
         Returns all non-empty ligands.
         """
-        ligands = []
 
-        # Filter for ligands using lists
-        ligand_residues, self.lignames_all, self.water = 
self.filter_for_ligands()
+        if config.PEPTIDES == []:
+            # Extract small molecule ligands (default)
+            ligands = []
+
+            # Filter for ligands using lists
+            ligand_residues, self.lignames_all, self.water = 
self.filter_for_ligands()
 
-        all_res_dict = {(a.GetName(), a.GetChain(), a.GetNum()): a for a in 
ligand_residues}
-        self.lignames_kept = list(set([a.GetName() for a in ligand_residues]))
+            all_res_dict = {(a.GetName(), a.GetChain(), a.GetNum()): a for a 
in ligand_residues}
+            self.lignames_kept = list(set([a.GetName() for a in 
ligand_residues]))
+
+            if not config.BREAKCOMPOSITE:
+                #  Update register of covalent links with those between 
DNA/RNA subunits
+                self.covalent += nucleotide_linkage(all_res_dict)
+                #  Find fragment linked by covalent bonds
+                res_kmers = self.identify_kmers(all_res_dict)
+            else:
+                res_kmers = [[a, ] for a in ligand_residues]
+            for kmer in res_kmers:  # iterate over all ligands and extract 
molecules + information
+                ligands.append(self.extract_ligand(kmer))
 
-        if not config.BREAKCOMPOSITE:
-            #  Update register of covalent links with those between DNA/RNA 
subunits
-            self.covalent += nucleotide_linkage(all_res_dict)
-            #  Find fragment linked by covalent bonds
-            res_kmers = self.identify_kmers(all_res_dict)
         else:
-            res_kmers = [[a, ] for a in ligand_residues]
-        for kmer in res_kmers:  # iterate over all ligands and extract 
molecules + information
-            ligands.append(self.extract_ligand(kmer))
+            # Extract peptides from given chains
+            self.water = [o for o in 
pybel.ob.OBResidueIter(self.proteincomplex.OBMol) if o.GetResidueProperty(9)]
+            peptide_ligands = [self.getpeptides(chain) for chain in 
config.PEPTIDES]
+            ligands = [p for p in peptide_ligands if p is not None ]
+            self.covalent, self.lignames_kept, self.lignames_all = [], [], 
set()
+
         return [lig for lig in ligands if len(lig.mol.atoms) != 0]
 
     def extract_ligand(self, kmer):
         """Extract the ligand by copying atoms and bonds and assign all 
information necessary for later steps."""
         data = namedtuple('ligand', 'mol hetid chain position water members 
longname type atomorder can_to_pdb')
         members = [(res.GetName(), res.GetChain(), 
int32_to_negative(res.GetNum())) for res in kmer]
-        members = sorted(members, key=lambda x: (x[1], x[2]))
+        members = sort_members_by_importance(members)
         rname, rchain, rnum = members[0]
         write_message("Finalizing extraction for ligand %s:%s:%s\n" % (rname, 
rchain, rnum), mtype='debug')
         names = [x[0] for x in members]
         longname = '-'.join([x[0] for x in members])
 
-        # Classify a ligand by its HETID(s)
-        ligtype = classify_by_name(names)
+        if config.PEPTIDES == []:
+            # Classify a ligand by its HETID(s)
+            ligtype = classify_by_name(names)
+        else:
+            ligtype = 'PEPTIDE'
 
         hetatoms = set()
         for obresidue in kmer:
@@ -275,29 +306,37 @@ class LigandFinder:
         return ligand
 
     def is_het_residue(self, obres):
-        """Given an OBResidue, determines if the residue is indeed a ligand
-        in the PDB file (any atoms has to be a HETATM entry)"""
-        het_atoms = []
-        for atm in pybel.ob.OBResidueAtomIter(obres):
-                het_atoms.append(obres.IsHetAtom(atm))
-        if True in het_atoms:
+        """Given an OBResidue, determines if the residue is indeed a possible 
ligand
+        in the PDB file"""
+        if not obres.GetResidueProperty(0):
+            # If the residue is NOT amino (0)
+            # It can be amino_nucleo, coenzme, ion, nucleo, protein, purine, 
pyrimidine, solvent
+            # In these cases, it is a ligand candidate
             return True
         else:
-            return False
+            # Here, the residue is classified as amino
+            # Amino acids can still be ligands, so we check for HETATM entries
+            # Only residues with at least one HETATM entry are processed as 
ligands
+            het_atoms = []
+            for atm in pybel.ob.OBResidueAtomIter(obres):
+                    het_atoms.append(obres.IsHetAtom(atm))
+            if True in het_atoms:
+                return True
+        return False
 
 
     def filter_for_ligands(self):
         """Given an OpenBabel Molecule, get all ligands, their names, and 
water"""
 
-        #candidates1 = [o for o in 
pybel.ob.OBResidueIter(self.proteincomplex.OBMol) if not 
(o.GetResidueProperty(9)
-        #                                                                      
          or o.GetResidueProperty(0))]
-
         candidates1 = [o for o in 
pybel.ob.OBResidueIter(self.proteincomplex.OBMol) if not 
o.GetResidueProperty(9) and self.is_het_residue(o)]
         all_lignames = set([a.GetName() for a in candidates1])
 
         water = [o for o in pybel.ob.OBResidueIter(self.proteincomplex.OBMol) 
if o.GetResidueProperty(9)]
         # Filter out non-ligands
-        candidates2 = [a for a in candidates1 if is_lig(a.GetName()) and 
a.GetName() not in self.modresidues]
+        if not config.KEEPMOD:  # Keep modified residues as ligands
+            candidates2 = [a for a in candidates1 if is_lig(a.GetName()) and 
a.GetName() not in self.modresidues]
+        else:
+            candidates2 = [a for a in candidates1 if is_lig(a.GetName())]
         write_message("%i ligand(s) after first filtering step.\n" % 
len(candidates2), mtype='debug')
 
         ############################################
@@ -1152,6 +1191,10 @@ class PDBComplex:
         self.Mapper = Mapper()
         self.ligands = []
 
+    def __str__(self):
+        formatted_lig_names = [":".join([x.hetid, x.chain, str(x.position)]) 
for x in self.ligands]
+        return "Protein structure %s with ligands:\n" % (self.pymol_name) + 
"\n".join([lig for lig in formatted_lig_names])
+
     def load_pdb(self, pdbpath, as_string=False):
         """Loads a pdb file with protein AND ligand(s), separates and prepares 
them.
         If specified 'as_string', the input is a PDB string instead of a 
path."""
@@ -1224,6 +1267,11 @@ class PDBComplex:
         else:
             write_message("Structure contains no ligands.\n\n")
 
+    def analyze(self):
+        """Triggers analysis of all complexes in structure"""
+        for ligand in self.ligands:
+            self.characterize_complex(ligand)
+
     def characterize_complex(self, ligand):
         """Handles all basic functions for characterizing the interactions for 
one ligand"""
 
@@ -1277,9 +1325,14 @@ class PDBComplex:
         return [obres.GetIdx() for obres in resis if 
self.res_belongs_to_bs(obres, cutoff, ligcentroid)]
 
     def res_belongs_to_bs(self, res, cutoff, ligcentroid):
-        """Check for each residue if its centroid is within a certain distance 
to the ligand centroid."""
+        """Check for each residue if its centroid is within a certain distance 
to the ligand centroid.
+        Additionally checks if a residue belongs to a chain restricted by the 
user (e.g. by defining a peptide chain)"""
         rescentroid = centroid([(atm.x(), atm.y(), atm.z()) for atm in 
pybel.ob.OBResidueAtomIter(res)])
-        return True if euclidean3d(rescentroid, ligcentroid) < cutoff else 
False
+        # Check geometry
+        near_enough = True if euclidean3d(rescentroid, ligcentroid) < cutoff 
else False
+        # Check chain membership
+        restricted_chain = True if res.GetChain() in config.PEPTIDES else False
+        return (near_enough and not restricted_chain)
 
     def get_atom(self, idx):
         return self.atoms[idx]
diff --git a/plip/modules/pymolplip.py b/plip/modules/pymolplip.py
index 4012dcc..14a9914 100644
--- a/plip/modules/pymolplip.py
+++ b/plip/modules/pymolplip.py
@@ -16,6 +16,7 @@ See the License for the specific language governing 
permissions and
 limitations under the License.
 """
 from pymol import cmd
+from time import sleep
 import sys
 import os
 import subprocess
@@ -26,7 +27,8 @@ class PyMOLVisualizer:
         if not plcomplex is None:
             self.plcomplex = plcomplex
             self.protname = plcomplex.pdbid  # Name of protein with binding 
site
-            self.ligname = plcomplex.hetid  # Name of ligand
+            self.hetid = plcomplex.hetid
+            self.ligname = "Ligand_" + self.hetid  # Name of ligand
             self.metal_ids = plcomplex.metal_ids
 
     def set_initial_representations(self):
@@ -328,9 +330,11 @@ class PyMOLVisualizer:
                 cmd.zoom(self.ligname, 3)
         cmd.origin(self.ligname)
 
-    def save_session(self, outfolder):
+    def save_session(self, outfolder, override=None):
         """Saves a PyMOL session file."""
-        filename = '%s_%s' % (self.protname.upper(), "_".join([self.ligname, 
self.plcomplex.chain, self.plcomplex.position]))
+        filename = '%s_%s' % (self.protname.upper(), "_".join([self.hetid, 
self.plcomplex.chain, self.plcomplex.position]))
+        if override is not None:
+            filename = override
         cmd.save("/".join([outfolder, "%s.pse" % filename]))
 
     def png_workaround(self, filepath, width=1200, height=800):
diff --git a/plip/modules/report.py b/plip/modules/report.py
index a5fd480..d8cbeb3 100644
--- a/plip/modules/report.py
+++ b/plip/modules/report.py
@@ -20,13 +20,96 @@ limitations under the License.
 # Python Standard Library
 import time
 from operator import itemgetter
+import sys
+
 
 # External libraries
 import lxml.etree as et
 
+__version__ = '1.3.2'
+
+class StructureReport:
+    """Creates reports (xml or txt) for one structure/"""
+    def __init__(self, mol):
+        self.mol = mol
+        self.excluded = self.mol.excluded
+        self.xmlreport = self.construct_xml_tree()
+        self.txtreport = self.construct_txt_file()
+        self.get_bindingsite_data()
+        self.outpath = mol.output_path
+
+    def construct_xml_tree(self):
+        """Construct the basic XML tree"""
+        report = et.Element('report')
+        plipversion = et.SubElement(report, 'plipversion')
+        plipversion.text = __version__
+        date_of_creation = et.SubElement(report, 'date_of_creation')
+        date_of_creation.text = time.strftime("%Y/%m/%d")
+        citation_information = et.SubElement(report, 'citation_information')
+        citation_information.text = "Salentin,S. et al. PLIP: fully automated 
protein-ligand interaction profiler. " \
+           "Nucl. Acids Res. (1 July 2015) 43 (W1): W443-W447. doi: 
10.1093/nar/gkv315"
+        pdbid = et.SubElement(report, 'pdbid')
+        pdbid.text = self.mol.pymol_name.upper()
+        filetype = et.SubElement(report, 'filetype')
+        filetype.text = self.mol.filetype.upper()
+        pdbfile = et.SubElement(report, 'pdbfile')
+        pdbfile.text = self.mol.sourcefiles['pdbcomplex']
+        pdbfixes = et.SubElement(report, 'pdbfixes')
+        pdbfixes.text = str(self.mol.information['pdbfixes'])
+        filename = et.SubElement(report, 'filename')
+        filename.text = str(self.mol.sourcefiles['filename'])
+        exligs = et.SubElement(report, 'excluded_ligands')
+        for i, exlig in enumerate(self.excluded):
+            e = et.SubElement(exligs, 'excluded_ligand', id=str(i + 1))
+            e.text = exlig
+        return report
+
+    def construct_txt_file(self):
+        """Construct the header of the txt file"""
+        textlines = ['Prediction of noncovalent interactions for PDB structure 
%s' % self.mol.pymol_name.upper(), ]
+        textlines.append("=" * len(textlines[0]))
+        textlines.append('Created on %s using PLIP v%s\n' % 
(time.strftime("%Y/%m/%d"), __version__))
+        textlines.append('If you are using PLIP in your work, please cite:')
+        textlines.append('Salentin,S. et al. PLIP: fully automated 
protein-ligand interaction profiler.')
+        textlines.append('Nucl. Acids Res. (1 July 2015) 43 (W1): W443-W447. 
doi: 10.1093/nar/gkv315\n')
+        if len(self.excluded) != 0:
+            textlines.append('Excluded molecules as ligands: %s\n' % 
','.join([lig for lig in self.excluded]))
+        return textlines
+
+    def get_bindingsite_data(self):
+        """Get the additional data for the binding sites"""
+        for i, site in enumerate(sorted(self.mol.interaction_sets)):
+            s = self.mol.interaction_sets[site]
+            bindingsite = BindingSiteReport(s).generate_xml()
+            bindingsite.set('id', str(i + 1))
+            bindingsite.set('has_interactions', 'False')
+            self.xmlreport.insert(i + 1, bindingsite)
+            for itype in BindingSiteReport(s).generate_txt():
+                self.txtreport.append(itype)
+            if not s.no_interactions:
+                bindingsite.set('has_interactions', 'True')
+            else:
+                self.txtreport.append('No interactions detected.')
+            sys.stdout = sys.__stdout__  # Change back to original stdout, 
gets changed when PyMOL has been used before
+
+    def write_xml(self, as_string=False):
+        """Write the XML report"""
+        if not as_string:
+            et.ElementTree(self.xmlreport).write('%s/report.xml' % 
self.outpath, pretty_print=True, xml_declaration=True)
+        else:
+            print et.tostring(self.xmlreport, pretty_print=True)
+
+    def write_txt(self, as_string=False):
+        """Write the TXT report"""
+        if not as_string:
+            with open('%s/report.txt' % self.outpath, 'w') as f:
+                [f.write(textline + '\n') for textline in self.txtreport]
+        else:
+            print '\n'.join(self.txtreport)
+
 
-class TextOutput:
-    """Gather report data and generate reports for one binding site in 
different formats"""
+class BindingSiteReport:
+    """Gather report data and generate reports for one binding site in 
different formats."""
     def __init__(self, plcomplex):
 
         ################
diff --git a/plip/modules/supplemental.py b/plip/modules/supplemental.py
index 27398af..f49c538 100644
--- a/plip/modules/supplemental.py
+++ b/plip/modules/supplemental.py
@@ -318,6 +318,17 @@ def classify_by_name(names):
                     ligtype += '+ION'
     return ligtype
 
+def sort_members_by_importance(members):
+    """Sort the members of a composite ligand according to two criteria:
+    1. Split up in main and ion group. Ion groups are located behind the main 
group.
+    2. Within each group, sort by chain and position."""
+    main = [x for x in members if x[0] not in config.METAL_IONS]
+    ion = [x for x in members if x[0] in config.METAL_IONS]
+    sorted_main = sorted(main, key=lambda x: (x[1], x[2]))
+    sorted_main = sorted(main, key=lambda x: (x[1], x[2]))
+    sorted_ion = sorted(ion, key=lambda x: (x[1], x[2]))
+    return sorted_main + sorted_ion
+
 
 def get_isomorphisms(reference, lig):
     """Get all isomorphisms of the ligand."""
diff --git a/plip/modules/visualize.py b/plip/modules/visualize.py
index 5a72279..0de5ae7 100644
--- a/plip/modules/visualize.py
+++ b/plip/modules/visualize.py
@@ -18,7 +18,7 @@ limitations under the License.
 
 
 # Own modules
-from supplemental import initialize_pymol, start_pymol, write_message, colorlog
+from supplemental import initialize_pymol, start_pymol, write_message, 
colorlog, sysexit
 import config
 from pymolplip import PyMOLVisualizer
 from plipremote import VisualizerData
@@ -29,6 +29,7 @@ import sys
 
 # Special imports
 from pymol import cmd
+import pymol
 
 
 def select_by_ids(selname, idlist, selection_exists=False, chunksize=20, 
restrict=None):
@@ -60,7 +61,12 @@ def visualize_in_pymol(plcomplex):
     pdbid = plcomplex.pdbid
     lig_members = plcomplex.lig_members
     chain = plcomplex.chain
-    ligname = plcomplex.hetid
+    if config.PEPTIDES != []:
+        vis.ligname = 'PeptideChain%s' % plcomplex.chain
+
+    ligname = vis.ligname
+    hetid = plcomplex.hetid
+
     metal_ids = plcomplex.metal_ids
     metal_ids_str = '+'.join([str(i) for i in metal_ids])
 
@@ -76,7 +82,12 @@ def visualize_in_pymol(plcomplex):
     write_message('Setting current_name to "%s" and pdbid to "%s\n"' % 
(current_name, pdbid), mtype='debug')
     cmd.set_name(current_name, pdbid)
     cmd.hide('everything', 'all')
-    cmd.select(ligname, 'resn %s and chain %s and resi %s*' % (ligname, chain, 
plcomplex.position))
+    if config.PEPTIDES != []:
+        cmd.select(ligname, 'chain %s and not resn HOH' % plcomplex.chain)
+    else:
+        cmd.select(ligname, 'resn %s and chain %s and resi %s*' % (hetid, 
chain, plcomplex.position))
+    write_message("Selecting ligand for PDBID %s and ligand name %s with: " % 
(pdbid, ligname), mtype='debug')
+    write_message('resn %s and chain %s and resi %s*' % (hetid, chain, 
plcomplex.position), mtype='debug')
 
     # Visualize and color metal ions if there are any
     if not len(metal_ids) == 0:
@@ -84,9 +95,11 @@ def visualize_in_pymol(plcomplex):
         cmd.show('spheres', 'id %s and %s' % (metal_ids_str, pdbid))
 
     # Additionally, select all members of composite ligands
-    for member in lig_members:
-        resid, chain, resnr = member[0], member[1], str(member[2])
-        cmd.select(ligname, '%s or (resn %s and chain %s and resi %s)' % 
(ligname, resid, chain, resnr))
+    if len(lig_members) > 1:
+        for member in lig_members:
+           resid, chain, resnr = member[0], member[1], str(member[2])
+           cmd.select(ligname, '%s or (resn %s and chain %s and resi %s)' % 
(ligname, resid, chain, resnr))
+
     cmd.show('sticks', ligname)
     cmd.color('myblue')
     cmd.color('myorange', ligname)
@@ -97,6 +110,7 @@ def visualize_in_pymol(plcomplex):
         cmd.set('sphere_scale', 0.3, ligname)
     cmd.deselect()
 
+
     vis.make_initial_selections()
 
     vis.show_hydrophobic()  # Hydrophobic Contacts
@@ -116,8 +130,15 @@ def visualize_in_pymol(plcomplex):
     vis.selections_cleanup()
     vis.selections_group()
     vis.additional_cleanup()
-    if config.PYMOL:
-        vis.save_session(config.OUTPATH)
-    if config.PICS:
-        filename = '%s_%s' % (pdbid.upper(), "_".join([ligname, 
plcomplex.chain, plcomplex.position]))
-        vis.save_picture(config.OUTPATH, filename)
+    if config.PEPTIDES == []:
+        if config.PYMOL:
+            vis.save_session(config.OUTPATH)
+        if config.PICS:
+            filename = '%s_%s' % (pdbid.upper(), "_".join([hetid, 
plcomplex.chain, plcomplex.position]))
+            vis.save_picture(config.OUTPATH, filename)
+    else:
+        filename = "%s_PeptideChain%s" % (pdbid.upper(), plcomplex.chain)
+        if config.PYMOL:
+            vis.save_session(config.OUTPATH, override=filename)
+        if config.PICS:
+            vis.save_picture(config.OUTPATH, filename)
diff --git a/plip/modules/webservices.py b/plip/modules/webservices.py
new file mode 100644
index 0000000..c1f283f
--- /dev/null
+++ b/plip/modules/webservices.py
@@ -0,0 +1,67 @@
+"""
+Protein-Ligand Interaction Profiler - Analyze and visualize protein-ligand 
interactions in PDB files.
+webservices.py - Connect to various webservices to retrieve data
+Copyright 2014-2016 Sebastian Salentin
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+# Own modules
+from supplemental import write_message, sysexit
+
+# Python standard libary
+import urllib2
+
+# External libraries
+import lxml.etree as et
+
+
+
+def check_pdb_status(pdbid):
+    """Returns the status and up-to-date entry in the PDB for a given PDB ID"""
+    url = 'http://www.rcsb.org/pdb/rest/idStatus?structureId=%s' % pdbid
+    xmlf = urllib2.urlopen(url)
+    xml = et.parse(xmlf)
+    xmlf.close()
+    status = None
+    current_pdbid = pdbid
+    for df in xml.xpath('//record'):
+        status = df.attrib['status']  # Status of an entry can be either 
'UNKWOWN', 'OBSOLETE', or 'CURRENT'
+        if status == 'OBSOLETE':
+            current_pdbid = df.attrib['replacedBy']  # Contains the up-to-date 
PDB ID for obsolete entries
+    return [status, current_pdbid.lower()]
+
+
+def fetch_pdb(pdbid):
+    """Get the newest entry from the RCSB server for the given PDB ID. Exits 
with '1' if PDB ID is invalid."""
+    pdbid = pdbid.lower()
+    write_message('\nChecking status of PDB ID %s ... ' % pdbid)
+    state, current_entry = check_pdb_status(pdbid)  # Get state and current 
PDB ID
+
+    if state == 'OBSOLETE':
+        write_message('entry is obsolete, getting %s instead.\n' % 
current_entry)
+    elif state == 'CURRENT':
+        write_message('entry is up to date.\n')
+    elif state == 'UNKNOWN':
+        sysexit(3, 'Invalid PDB ID (Entry does not exist on PDB server)\n')
+    write_message('Downloading file from PDB ... ')
+    pdburl = 'http://www.rcsb.org/pdb/files/%s.pdb' % current_entry  # Get URL 
for current entry
+    try:
+        pdbfile = urllib2.urlopen(pdburl).read()
+        # If no PDB file is available, a text is now shown with "We're sorry, 
but ..."
+        # Could previously be distinguished by an HTTP error
+        if 'sorry' in pdbfile:
+            sysexit(5, "No file in PDB format available from wwPDB for the 
given PDB ID.\n")
+    except urllib2.HTTPError:
+        sysexit(5, "No file in PDB format available from wwPDB for the given 
PDB ID.\n")
+    return [pdbfile, current_entry]
diff --git a/plip/plipcmd b/plip/plipcmd
index 576bac0..e929955 100755
--- a/plip/plipcmd
+++ b/plip/plipcmd
@@ -25,30 +25,29 @@ try:
     from plip.modules.preparation import *
     from plip.modules.visualize import visualize_in_pymol
     from plip.modules.plipremote import VisualizerData
-    from plip.modules.report import TextOutput
+    from plip.modules.report import StructureReport,__version__
     from plip.modules import config
     from plip.modules.mp import parallel_fn
+    from plip.modules.webservices import check_pdb_status, fetch_pdb
 except ImportError:
     from modules.preparation import *
-    from modules.visualize import visualize_in_pymol, PyMOLComplex
+    from modules.visualize import visualize_in_pymol
     from modules.plipremote import VisualizerData
-    from modules.report import TextOutput
+    from modules.report import StructureReport, __version__
     from modules import config
     from modules.mp import parallel_fn
+    from modules.webservices import check_pdb_status, fetch_pdb
 
 # Python standard library
 import sys
 import argparse
 from argparse import ArgumentParser
-import urllib2
 import time
 import multiprocessing
 import json
-
 # External libraries
 import lxml.etree as et
 
-__version__ = '1.3.1'
 descript = "Protein-Ligand Interaction Profiler (PLIP) v%s " \
            "is a command-line based tool to analyze interactions in a 
protein-ligand complex. " \
            "If you are using PLIP in your work, please cite: " \
@@ -63,41 +62,7 @@ def threshold_limiter(aparser, arg):
     return arg
 
 
-def check_pdb_status(pdbid):
-    """Returns the status and up-to-date entry in the PDB for a given PDB ID"""
-    url = 'http://www.rcsb.org/pdb/rest/idStatus?structureId=%s' % pdbid
-    xmlf = urllib2.urlopen(url)
-    xml = et.parse(xmlf)
-    xmlf.close()
-    status = None
-    current_pdbid = pdbid
-    for df in xml.xpath('//record'):
-        status = df.attrib['status']  # Status of an entry can be either 
'UNKWOWN', 'OBSOLETE', or 'CURRENT'
-        if status == 'OBSOLETE':
-            current_pdbid = df.attrib['replacedBy']  # Contains the up-to-date 
PDB ID for obsolete entries
-    return [status, current_pdbid.lower()]
-
-
-def fetch_pdb(pdbid):
-    """Get the newest entry from the RCSB server for the given PDB ID. Exits 
with '1' if PDB ID is invalid."""
-    pdbid = pdbid.lower()
-    write_message('\nChecking status of PDB ID %s ... ' % pdbid)
-    state, current_entry = check_pdb_status(pdbid)  # Get state and current 
PDB ID
-
-    if state == 'OBSOLETE':
-        write_message('entry is obsolete, getting %s instead.\n' % 
current_entry)
-    elif state == 'CURRENT':
-        write_message('entry is up to date.\n')
-    elif state == 'UNKNOWN':
-        sysexit(3, 'Invalid PDB ID (Entry does not exist on PDB server)\n')
-    write_message('Downloading file from PDB ... ')
-    pdburl = 'http://www.rcsb.org/pdb/files/%s.pdb' % current_entry  # Get URL 
for current entry
-    pdbfile = urllib2.urlopen(pdburl).read()
-    # If no PDB file is available, a text is now shown with "We're sorry, but 
..."
-    # Could previously be distinguished by an HTTP error
-    if 'sorry' in pdbfile:
-        sysexit(5, "No file in PDB format available from wwPDB for the given 
PDB ID.\n")
-    return [pdbfile, current_entry]
+
 
 
 def process_pdb(pdbfile, outpath):
@@ -111,50 +76,14 @@ def process_pdb(pdbfile, outpath):
     # #@todo Offers possibility for filter function from command line (by 
ligand chain, position, hetid)
     for ligand in mol.ligands:
         mol.characterize_complex(ligand)
-    excluded = mol.excluded
+
     create_folder_if_not_exists(outpath)
 
-    # Begin constructing the XML tree
-    report = et.Element('report')
-    plipversion = et.SubElement(report, 'plipversion')
-    plipversion.text = __version__
-    pdbid = et.SubElement(report, 'pdbid')
-    pdbid.text = mol.pymol_name.upper()
-    filetype = et.SubElement(report, 'filetype')
-    filetype.text = mol.filetype.upper()
-    pdbfile = et.SubElement(report, 'pdbfile')
-    pdbfile.text = mol.sourcefiles['pdbcomplex']
-    pdbfixes = et.SubElement(report, 'pdbfixes')
-    pdbfixes.text = str(mol.information['pdbfixes'])
-    filename = et.SubElement(report, 'filename')
-    filename.text = str(mol.sourcefiles['filename'])
-    exligs = et.SubElement(report, 'excluded_ligands')
-    for i, exlig in enumerate(excluded):
-        e = et.SubElement(exligs, 'excluded_ligand', id=str(i + 1))
-        e.text = exlig
-
-    # Write header of rST file
-    textlines = ['Prediction of noncovalent interactions for PDB structure %s' 
% mol.pymol_name.upper(), ]
-    textlines.append("=" * len(textlines[0]))
-    textlines.append('Created on %s using PLIP v%s\n' % 
(time.strftime("%Y/%m/%d"), __version__))
-    if len(excluded) != 0:
-        textlines.append('Excluded molecules as ligands: %s\n' % ','.join([lig 
for lig in excluded]))
+    # Generate the report files
+    streport = StructureReport(mol)
 
     config.MAXTHREADS = min(config.MAXTHREADS, len(mol.interaction_sets))
 
-    ####
-    # Create JSON dump of PyMOL helper class
-    ###
-
-    if config.VISJSON:
-        complexes = [VisualizerData(mol, site) for site in 
sorted(mol.interaction_sets)
-        if not len(mol.interaction_sets[site].interacting_res) == 0]
-
-        with open('%s/plipvis.json' % outpath, 'w') as f:
-            cplx_dict = {}
-            for cplx in complexes:
-                cplx_dict[cplx.uid] = cplx.to_json()
-            json.dump(cplx_dict, f)
 
     ######################################
     # PyMOL Visualization (parallelized) #
@@ -170,31 +99,11 @@ def process_pdb(pdbfile, outpath):
         else:
             [visualize_in_pymol(plcomplex) for plcomplex in complexes]
 
-    ##################################################################
-    # Generate XML- and rST-formatted reports for each binding site. #
-    ##################################################################
-
-    for i, site in enumerate(sorted(mol.interaction_sets)):
-        s = mol.interaction_sets[site]
-        bindingsite = TextOutput(s).generate_xml()
-        bindingsite.set('id', str(i + 1))
-        bindingsite.set('has_interactions', 'False')
-        report.insert(i + 1, bindingsite)
-        for itype in TextOutput(s).generate_txt():
-            textlines.append(itype)
-        if not s.no_interactions:
-            bindingsite.set('has_interactions', 'True')
-        else:
-            textlines.append('No interactions detected.')
-        sys.stdout = sys.__stdout__  # Change back to original stdout, gets 
changed when PyMOL has been used before
-
-    tree = et.ElementTree(report)
     if config.XML:  # Generate report in xml format
-        tree.write('%s/report.xml' % outpath, pretty_print=True, 
xml_declaration=True)
+        streport.write_xml()
 
     if config.TXT:  # Generate report in txt (rst) format
-        with open('%s/report.txt' % outpath, 'w') as f:
-            [f.write(textline + '\n') for textline in textlines]
+        streport.write_txt()
 
 def download_structure(inputpdbid):
     """Given a PDB ID, downloads the corresponding PDB structure.
@@ -297,6 +206,12 @@ if __name__ == '__main__':
     parser.add_argument("--nofix", dest="nofix", default=False,
                         help="Turns off fixing of PDB files.",
                         action="store_true")
+    parser.add_argument("--peptides", dest="peptides", default=[],
+                        help="Allows to define one or multiple chains as 
peptide ligands",
+                        nargs="+")
+    parser.add_argument("--keepmod", dest="keepmod", default=False,
+                        help="Keep modified residues as ligands",
+                        action="store_true")
     # Optional threshold arguments, not shown in help
     thr = namedtuple('threshold', 'name type')
     thresholds = [thr(name='aromatic_planarity', type='angle'),
@@ -327,7 +242,9 @@ if __name__ == '__main__':
     config.BASEPATH = config.OUTPATH  # Used for batch processing
     config.BREAKCOMPOSITE = arguments.breakcomposite
     config.ALTLOC = arguments.altlocation
+    config.PEPTIDES =arguments.peptides
     config.NOFIX = arguments.nofix
+    config.KEEPMOD = arguments.keepmod
     # Assign values to global thresholds
     for t in thresholds:
         tvalue = getattr(arguments, t.name)
diff --git a/plip/test/test_basic_functions.py 
b/plip/test/test_basic_functions.py
index 763cc47..79ffd51 100644
--- a/plip/test/test_basic_functions.py
+++ b/plip/test/test_basic_functions.py
@@ -17,10 +17,30 @@ See the License for the specific language governing 
permissions and
 limitations under the License.
 """
 
-
+# Python Standard Library
 import unittest
+import numpy
+import random
+
+# Own modules
 from plip.modules.preparation import PDBComplex
+from plip.modules.supplemental import euclidean3d, vector, vecangle, projection
+from plip.modules.supplemental import normalize_vector, cluster_doubles, 
centroid
 
+class TestLigandSupport(unittest.TestCase):
+    """Test for support of different ligands"""
+
+    def test_dna_rna(self):
+        """Test if DNA and RNA is correctly processed as ligands"""
+        tmpmol = PDBComplex()
+        tmpmol.load_pdb('./pdb/1tf6.pdb')
+        bsid = 'DA:B:1'
+        # DNA ligand four times consisting of 31 parts (composite)
+        self.assertEqual([len(ligand.members) for ligand in 
tmpmol.ligands].count(31), 4)
+        for ligset in [set((x[0] for x in ligand.members)) for ligand in 
tmpmol.ligands]:
+            if len(ligset) == 4:
+                # DNA only contains four bases
+                self.assertEqual(ligset, set(['DG', 'DC', 'DA', 'DT']))
 
 class TestMapping(unittest.TestCase):
     """Test"""
@@ -57,4 +77,70 @@ class TestMapping(unittest.TestCase):
                 self.assertEqual(contact.acc.o_orig_idx, 485)
             if contact.restype == 'LEU' and contact.resnr == 157:
                 self.assertEqual(contact.don.x_orig_idx, 1628)
-                self.assertEqual(contact.acc.o_orig_idx, 1191)
\ No newline at end of file
+                self.assertEqual(contact.acc.o_orig_idx, 1191)
+
+class GeometryTest(unittest.TestCase):
+    """Tests for geometrical calculations in PLIP"""
+
+    def vector_magnitude(self, v):
+        return numpy.sqrt(sum(x**2 for x in v))
+
+    # noinspection PyUnusedLocal
+    def setUp(self):
+        """Generate random data for the tests"""
+        # Generate two random n-dimensional float vectors, with -100 <= n <= 
100 and values 0 <= i <= 1
+        dim = random.randint(1, 100)
+        self.rnd_vec = [random.uniform(-100, 100) for i in xrange(dim)]
+
+    def test_euclidean(self):
+        """Tests for mathematics.euclidean"""
+        # Are the results correct?
+        self.assertEqual(euclidean3d([0.0, 0.0, 0.0], [0.0, 0.0, 0.0]), 0)
+        self.assertEqual(euclidean3d([2.0, 3.0, 4.0], [2.0, 3.0, 4.0]), 0)
+        self.assertEqual(euclidean3d([4.0, 5.0, 6.0], [4.0, 5.0, 8.0]), 2.0)
+        # Does the function take vectors or tuples as an input? What about 
integers?
+        self.assertEqual(euclidean3d((4.0, 5.0, 6.0), [4.0, 5.0, 8.0]), 2.0)
+        self.assertEqual(euclidean3d((4.0, 5.0, 6.0), (4.0, 5.0, 8.0)), 2.0)
+        self.assertEqual(euclidean3d((4, 5, 6), (4.0, 5.0, 8.0)), 2.0)
+        # Is the output a float?
+        self.assertIsInstance(euclidean3d([2.0, 3.0, 4.0], [2.0, 3.0, 4.0]), 
float)
+
+    def test_vector(self):
+        """Tests for mathematics.vector"""
+        # Are the results correct?
+        self.assertEqual(list(vector([1, 1, 1], [0, 1, 0])), [-1, 0, -1])
+        self.assertEqual(list(vector([0, 0, 10], [0, 0, 4])), [0, 0, -6])
+        # Do I get an Numpy Array?
+        self.assertIsInstance(vector([1, 1, 1], [0, 1, 0]), numpy.ndarray)
+        # Do I get 'None' if the points have different dimensions?
+        self.assertEqual(vector([1, 1, 1], [0, 1, 0, 1]), None)
+
+    def test_vecangle(self):
+        """Tests for mathematics.vecangle"""
+        # Are the results correct?
+        self.assertEqual(vecangle([3, 4], [-8, 6], deg=False), 
numpy.radians(90.0))
+        self.assertEqual(vecangle([3, 4], [-8, 6]), 90.0)
+        self.assertAlmostEqual(vecangle([-1, -1], [1, 1], deg=False), numpy.pi)
+        # Correct if both vectors are equal?
+        self.assertEqual(vecangle([3, 3], [3, 3]), 0.0)
+
+    def test_centroid(self):
+        """Tests for mathematics.centroid"""
+        # Are the results correct?
+        self.assertEqual(centroid([[0, 0, 0], [2, 2, 2]]), [1.0, 1.0, 1.0])
+        self.assertEqual(centroid([[-5, 1, 2], [10, 2, 2]]), [2.5, 1.5, 2.0])
+
+    def test_normalize_vector(self):
+        """Tests for mathematics.normalize_vector"""
+        # Are the results correct?
+        
self.assertAlmostEqual(self.vector_magnitude(normalize_vector(self.rnd_vec)), 1)
+
+    def test_projection(self):
+        """Tests for mathematics.projection"""
+        # Are the results correct?
+        self.assertEqual(projection([-1, 0, 0], [3, 3, 3], [1, 1, 1]), [3, 1, 
1])
+
+    def test_cluster_doubles(self):
+        """Tests for mathematics.cluster_doubles"""
+        # Are the results correct?
+        self.assertEqual(set(cluster_doubles([(1, 3), (4, 1), (5, 6), (7, 
5)])), {(1, 3, 4), (5, 6, 7)})
diff --git a/plip/test/test_literature_validated.py 
b/plip/test/test_literature_validated.py
index 1f10530..31c56a7 100644
--- a/plip/test/test_literature_validated.py
+++ b/plip/test/test_literature_validated.py
@@ -142,7 +142,7 @@ class LiteratureValidatedTest(unittest.TestCase):
         """
         tmpmol = PDBComplex()
         tmpmol.load_pdb('./pdb/2w0s.pdb')
-        bsid = 'MG:B:1206'  # Complex of BVDU with Magnesium Cofactor
+        bsid = 'BVP:B:1207'  # Complex of BVDU with Magnesium Cofactor
         for ligand in tmpmol.ligands:
             if ':'.join([ligand.hetid, ligand.chain, str(ligand.position)]) == 
bsid:
                 tmpmol.characterize_complex(ligand)
@@ -736,5 +736,3 @@ class LiteratureValidatedTest(unittest.TestCase):
         # Hydrogen bonds
         hbonds = {str(hbond.resnr)+hbond.reschain for hbond in 
s.hbonds_pdon+s.hbonds_ldon}
         self.assertTrue({'594A', '530A'}.issubset(hbonds))
-
-
diff --git a/plip/test/test_remote_services.py 
b/plip/test/test_remote_services.py
new file mode 100644
index 0000000..c8ecde8
--- /dev/null
+++ b/plip/test/test_remote_services.py
@@ -0,0 +1,46 @@
+# coding=utf-8
+"""
+Protein-Ligand Interaction Profiler - Analyze and visualize protein-ligand 
interactions in PDB files.
+test_remote_services.py - Unit Tests for remote services.
+Copyright 2014-2016 Sebastian Salentin
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+
+import unittest
+from plip.modules.webservices import check_pdb_status
+
+
+class TestPDB(unittest.TestCase):
+    """Test PDB Web Service methods"""
+
+    def test_pdb_entry_status(self):
+        # 1a0v is an obsolete entry and is replaced by 1y46
+        status, current_pdbid = check_pdb_status('1a0v')
+        self.assertEqual(status, 'OBSOLETE')
+        self.assertEqual(current_pdbid, '1y46')
+
+        # 1vsn is an current entry
+        status, current_pdbid = check_pdb_status('1vsn')
+        self.assertEqual(status, 'CURRENT')
+        self.assertEqual(current_pdbid, '1vsn')
+
+        # xxxx is not an PDB entry
+        status, current_pdbid = check_pdb_status('xxxx')
+        self.assertEqual(status, 'UNKNOWN')
+        self.assertEqual(current_pdbid, 'xxxx')
+
+
+        #print "Latest PDB ---", "passed" if get_latest_pdb("1a0v") == "1y46" 
else "not passed"
+#print "Resolution ---", "passed" if get_resolution("4HHB") == 1.74 else "not 
passed"
diff --git a/setup.py b/setup.py
index 1fff2dc..752d5cd 100644
--- a/setup.py
+++ b/setup.py
@@ -19,7 +19,7 @@ limitations under the License.
 from setuptools import setup
 
 setup(name='plip',
-      version='1.3.1',
+      version='1.3.2',
       description='PLIP - Fully automated protein-ligand interaction profiler',
       classifiers=[
           'Development Status :: 5 - Production/Stable',

-- 
Alioth's /usr/local/bin/git-commit-notice on 
/srv/git.debian.org/git/debian-med/plip.git

_______________________________________________
debian-med-commit mailing list
debian-med-commit@lists.alioth.debian.org
http://lists.alioth.debian.org/cgi-bin/mailman/listinfo/debian-med-commit

Reply via email to