Mol2, SDF and XYZ File Parsers

.gitignore

@@ -55,3 +55,4 @@ biotite.egg-info
 
 # Ignore fuse_hidden files on Linux systems
 *.fuse_hidden*
+

CONTRIB.rst

@@ -9,3 +9,4 @@ CONTRIBUTORS
 - Thomas Nevolianis <https://github.com/thomasnevolianis>
 - Maximilian Greil <https://github.com/MaxGreil>
 - Claude J. Rogers <https://github.com/claudejrogers>
+- Benjamin E. Mayer <https://github.com/entropybit>

src/biotite/structure/io/ctab.py

@@ -61,6 +61,8 @@ def read_structure_from_ctab(ctab_lines):
     .. footbibliography::
     """
     n_atoms, n_bonds = _get_counts(ctab_lines[0])
+
+
     atom_lines = ctab_lines[1 : 1 + n_atoms]
     bond_lines = ctab_lines[1 + n_atoms : 1 + n_atoms + n_bonds]
 

src/biotite/structure/io/general.py

@@ -78,7 +78,8 @@ def load_structure(file_path, template=None, **kwargs):
             # Stack containing only one model -> return as atom array
             return array[0]
         else:
-            return array
+            return array                    
+
     elif suffix == ".cif" or suffix == ".pdbx":
         from .pdbx import PDBxFile, get_structure
         file = PDBxFile.read(file_path)
@@ -115,12 +116,33 @@ def load_structure(file_path, template=None, **kwargs):
             return array[0]
         else:
             return array
-    elif suffix == ".mol" or suffix == ".sdf":
+    elif suffix == ".mol":
         from .mol import MOLFile
         file = MOLFile.read(file_path)
         array = file.get_structure(**kwargs)
         # MOL files only contain a single model
         return array
+    elif suffix == ".sdf":
+        from .sdf import SDFile
+        file = SDFile.read(file_path)
+        array = file.get_structure(**kwargs)
+        #  SDFile automatically detects if to return        
+        #  AtomArray or AtomArrayStack
+        return array          
+    elif suffix == ".xyz":
+        from .xyz import XYZFile
+        file = XYZFile.read(file_path)
+        array = file.get_structure(**kwargs)
+        # XYZFile automatically detects if to return
+        # AtomArray or AtomArrayStack
+        return array
+    elif suffix == ".mol2":
+        from .mol2 import MOL2File
+        file = MOL2File.read(file_path)
+        array = file.get_structure(**kwargs)
+        # MOL2File automatically detects if to return        
+        # AtomArray or AtomArrayStack
+        return array        
     elif suffix in [".trr", ".xtc", ".tng", ".dcd", ".netcdf"]:
         if template is None:
             raise TypeError("Template must be specified for trajectory files")
@@ -204,11 +226,26 @@ def save_structure(file_path, array, **kwargs):
         file = NpzFile()
         file.set_structure(array, **kwargs)
         file.write(file_path)
-    elif suffix == ".mol" or suffix == ".sdf":
+    elif suffix == ".mol":
         from .mol import MOLFile
         file = MOLFile()
         file.set_structure(array, **kwargs)
         file.write(file_path)
+    elif suffix == ".sdf":
+        from .sdf import SDFile
+        file = SDFile()
+        file.set_structure(array, **kwargs)
+        file.write(file_path)  
+    elif suffix == ".xyz":
+        from .xyz import XYZFile
+        file = XYZFile()
+        file.set_structure(array, **kwargs)
+        file.write(file_path) 
+    elif suffix == ".mol2":
+        from .mol2 import MOL2File
+        file = MOL2File()
+        file.set_structure(array, **kwargs)
+        file.write(file_path)                      
     elif suffix in [".trr", ".xtc", ".tng", ".dcd", ".netcdf"]:
         from .trr import TRRFile
         from .xtc import XTCFile

src/biotite/structure/io/mol/file.py

@@ -18,7 +18,7 @@
 
 # Number of header lines
 N_HEADER = 3
-DATE_FORMAT = "%d%m%y%H%M"
+DATE_FORMATS = ["%d%m%y%H%M", "%m%d%y%H%M"]
 
 
 class MOLFile(TextFile):
@@ -44,7 +44,9 @@ class MOLFile(TextFile):
     --------
 
     >>> from os.path import join
-    >>> mol_file = MOLFile.read(join(path_to_structures, "molecules", "TYR.sdf"))
+    >>> mol_file = MOLFile.read(
+    ...     join(path_to_structures, "molecules", "TYR.sdf")
+    ... )
     >>> atom_array = mol_file.get_structure()
     >>> print(atom_array)
                 0             N         1.320    0.952    1.428
@@ -91,7 +93,8 @@ def get_header(self):
         program : str
             The program name.
         time : datetime
-            The time of file creation.
+            The time of file creation. Returns None in this field if not
+            able to parse according entry in MOLFile as datetime string.
         dimensions : str
             Dimensional codes.
         scaling_factors : str
@@ -103,19 +106,40 @@ def get_header(self):
         comments : str
             Additional comments.
         """
-        mol_name        = self.lines[0].strip()
-        initials        = self.lines[1][0:2].strip()
-        program         = self.lines[1][2:10].strip()
-        time            = datetime.datetime.strptime(self.lines[1][10:20],
-                                                     DATE_FORMAT)
-        dimensions      = self.lines[1][20:22].strip()
+        mol_name = self.lines[0].strip()
+        initials = self.lines[1][0:2].strip()
+        program = self.lines[1][2:10].strip()
+        # sometimes the string can not be interpreted as datetime
+        # in those cases instead of failing simply warn the user
+        time = None
+        if len(self.lines[1][10:20]) > 1:
+            time_parsing_succesfull = False
+            msg_last = ""
+            for format_i in DATE_FORMATS:
+                try:
+                    time = datetime.datetime.strptime(
+                        self.lines[1][10:20],
+                        format_i
+                    )
+                    time_parsing_succesfull = True
+                    break
+                except ValueError:
+                    msg_last = self.lines[1][10:20].strip()[:len(format_i)]
+                    msg_last += " could not be interpreted as datetime"
+
+            if not time_parsing_succesfull:
+                warn(UserWarning(msg_last))
+                time = self.lines[1][10:20]
+
+        dimensions = self.lines[1][20:22].strip()
         scaling_factors = self.lines[1][22:34].strip()
-        energy          = self.lines[1][34:46].strip()
+        energy = self.lines[1][34:46].strip()
         registry_number = self.lines[1][46:52].strip()
-        comments        = self.lines[2].strip()
-        return mol_name, initials, program, time, dimensions, \
-               scaling_factors, energy, registry_number, comments
-
+        comments = self.lines[2].strip()
+        return (
+            mol_name, initials, program, time, dimensions,
+            scaling_factors, energy, registry_number, comments
+        )
 
     def set_header(self, mol_name, initials="", program="", time=None,
                    dimensions="", scaling_factors="", energy="",
@@ -132,7 +156,7 @@ def set_header(self, mol_name, initials="", program="", time=None,
         program : str, optional
             The program name. Maximum length is 8.
         time : datetime or date, optional
-            The time of file creation.
+            The time of file creation, if none uses current time.
         dimensions : str, optional
             Dimensional codes. Maximum length is 2.
         scaling_factors : str, optional
@@ -144,9 +168,18 @@ def set_header(self, mol_name, initials="", program="", time=None,
         comments : str, optional
             Additional comments.
         """
-        if time is None:
+        time_str = ""
+        if time is not None and type(time) is datetime.datetime:
+            for format_i in DATE_FORMATS:
+                try:
+                    time_str = time.strftime(format_i)
+                    break
+                except ValueError:
+                    time_str = time
+        # only fill with local time if nothing was provided via time
+        if len(time_str) == 0:
             time = datetime.datetime.now()
-        time_str = time.strftime(DATE_FORMAT)
+            time_str = time.strftime(DATE_FORMATS[0])
 
         self.lines[0] = str(mol_name)
         self.lines[1] = (
@@ -160,7 +193,6 @@ def set_header(self, mol_name, initials="", program="", time=None,
         )
         self.lines[2] = str(comments)
 
-
     def get_structure(self):
         """
         Get an :class:`AtomArray` from the MOL file.
@@ -178,7 +210,6 @@ def get_structure(self):
             raise InvalidFileError("File does not contain structure data")
         return read_structure_from_ctab(ctab_lines)
 
-
     def set_structure(self, atoms, default_bond_type=BondType.ANY):
         """
         Set the :class:`AtomArray` for the file.

src/biotite/structure/io/mol2/__init__.py

@@ -0,0 +1,17 @@
+# This source code is part of the Biotite package and is distributed
+# under the 3-Clause BSD License. Please see 'LICENSE.rst' for further
+# information.
+
+"""
+The MOL format is used to depict atom positions and bonds for small
+molecules.
+This subpackage is used for reading and writing an :class:`AtomArray` or
+an :class:`AtomArrayStack` for a file containing multiple models
+in this format.
+"""
+
+__name__ = "biotite.structure.io.mol2"
+__author__ = "Benjamin E. Mayer"
+
+from .file import *
+from .convert import *

src/biotite/structure/io/mol2/convert.py

@@ -0,0 +1,113 @@
+# This source code is part of the Biotite package and is distributed
+# under the 3-Clause BSD License. Please see 'LICENSE.rst' for further
+# information.
+
+__name__ = "biotite.structure.io.mol2"
+__author__ = "Benjamin E. Mayer"
+__all__ = [
+    "get_structure", "set_structure",
+    "get_charges", "set_charges",
+    "get_model_count"
+]
+
+
+def get_structure(mol2_file, model=None):
+    """
+    Get an :class:`AtomArray` from the MOL2 File.
+
+    Ths function is a thin wrapper around
+    :meth:`MOL2File.get_structure()`.
+
+    Parameters
+    ----------
+    mol2_file : MOL2File
+        The MOL2File.
+
+    Returns
+    -------
+    array : AtomArray, AtomArrayStack
+        Return an AtomArray or AtomArrayStack containing the structure or
+        structures depending on if file contains single or multiple models.
+        If something other then `NO_CHARGE` is set in the charge_type field
+        of the according mol2 file, the AtomArray or AtomArrayStack will
+        contain the charge field.
+    """
+    return mol2_file.get_structure(model)
+
+
+def set_structure(mol2_file, atoms):
+    """
+    Set the :class:`AtomArray` for the MOL2 File.
+
+    Ths function is a thin wrapper around
+    :meth:`MOL2File.set_structure(atoms)`.
+
+    Parameters
+    ----------
+    mol2_file : MOL2File
+        The XYZ File.
+    array : AtomArray
+        The array to be saved into this file.
+        Must have an associated :class:`BondList`.
+        If charge field set this is used for storage within the according
+        MOL2 charge column.
+    """
+    mol2_file.set_structure(atoms)
+
+
+def get_charges(mol2_file):
+    """
+    Get an ndarray containing the partial charges from the MOL2File
+
+    This function is a thin wrapper around
+    :meth:`MOL2File.get_charges()`.
+
+    Parameters
+    ----------
+    xyz_file : XYZFile
+        The XYZ File.
+
+    Returns
+    -------
+    array : AtomArray
+        This :class:`AtomArray` contains the optional ``charge``
+        annotation and has an associated :class:`BondList`.
+        All other annotation categories, except ``element`` are
+        empty.
+    """
+    return mol2_file.get_charges()
+
+
+def set_charges(mol2_file, charges):
+    """
+    Set the partial charges in the MOL2File to an ndarray
+    specified as parameter here.
+
+    Ths function is a thin wrapper around
+    :meth:`MOL2File.set_charges(charges)`.
+
+    Parameters
+    ----------
+    mol2_file: MOL2File
+        The MOL2File
+    charges: ndarray
+        A ndarray containing data with `float` type to be written as
+        partial charges.
+
+    """
+    return mol2_file.set_charges(charges)
+
+
+def get_model_count(mol2_file):
+    """
+    Get the number of models contained in the xyz file.
+
+    This function is a thin wrapper around
+    :meth:`MOL2File.get_model_count()`.
+
+    Returns
+    -------
+    model_count : int
+        The number of models.
+    """
+    return mol2_file.get_model_count()