Implement Alternative Inputs (computational-metabolomics#15)

* Return metabolite ID with msn annotation results

* Rewrite MSn method for limiting connectivity to fragment edges only

* Add option for use of smiles without non-structural isomeric information

* Update tests

* Correct return type hints

* Implement SQLITE3 annotate_msn results database

* Add msn option to ResultsDb

* Re-structure results db tables

* Update add_ms to add ms information to the queries table

* Add function to insert entries into the results and substructures tables

* Add function to get structure frequencies and/or SMILEs

* Update user-facing functions for compatibility with ResultsDb

* Remove text-based output and return substructure smiles from build functions in addition to final structures

* Update build unit tests for ResultsDb

* Add CSV output for build functions

* Check if ResultsDb output matches reference files

* Check ResultsDb CSV files line by line vs reference

* Implement simple bond dissociation energy calculations

* Add integer MS integer IDs and implement calculate_frequencies to more efficiently calculate structure frequencies

* Re-format get_bond_enthalpies

* Use integer IDs for results DB

* Add retain_substructures option

* Make filter_hmdbid_substructures a filtered version of the hmdbid_substructures table

* Implement the substructure network generation algorithm in SQLite instead of networkx

* Add get_substructure_network function to convert SQLite3 substructure network to a networkx graph

* Implement get_single_edge to get substructure edge weights without the generation of a substructure network

* Add integer substructure key

* Update unit tests

* Add parse_ms_data function to convert user provided raw data into a list required for building

* Implement msp parsing, update existing tests and spread functions across additional files

* Add unit testing and documentation for parse.py

* Amend connectivity database unit tests so that they fail in case of the generation of an empty DB

* Amend results docstrings

* Update docstrings of user-facing build functions

* Only test isomorphism database on non-windows systems

Author: jackgisby

metaboblend/algorithms.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Copyright © 2019-2020 Ralf Weber
+#
+# This file is part of MetaboBlend.
+#
+# MetaboBlend is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# MetaboBlend 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 MetaboBlend.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+import numpy
+
+
+def find_path(mass_list, sum_matrix, n, mass, max_subset_length, path=[]):
+    """
+    Recursive solution for backtracking through the dynamic programming boolean matrix. All possible subsets are found
+
+    :param mass_list: A list of masses from which to identify subsets.
+
+    :param mass: The target mass of the sum of the substructures.
+
+    :param sum_matrix: The dynamic programming boolean matrix.
+
+    :param n: The size of mass_list.
+
+    :param max_subset_length: The maximum length of subsets to return. Allows the recursive backtracking algorithm to
+        terminate early in many cases, significantly improving runtime.
+
+    :param path: List for keeping track of the current subset.
+
+    :return: Generates of lists containing the masses of valid subsets.
+    """
+
+    # base case - the path has generated a correct solution
+    if mass == 0:
+        yield sorted(path)
+        return
+
+    # stop running when we overshoot the mass
+    elif mass < 0:
+        return
+
+    # can we sum up to the target value using the remaining masses? recursive call
+    elif sum_matrix[n][mass]:
+        yield from find_path(mass_list, sum_matrix, n - 1, mass, max_subset_length, path)
+
+        if len(path) < max_subset_length:
+            path.append(mass_list[n-1])
+
+            yield from find_path(mass_list, sum_matrix, n - 1, mass - mass_list[n - 1], max_subset_length, path)
+            path.pop()
+
+
+def subset_sum(mass_list, mass, max_subset_length=3):
+    """
+    Dynamic programming implementation of subset sum. Note that, whilst this algorithm is pseudo-polynomial, the
+    backtracking algorithm for obtaining all possible subsets has exponential complexity and so remains unsuitable
+    for large input values.  This does, however, tend to perform a lot better than non-sum_matrix implementations, as
+    we're no longer doing sums multiple times and we've cut down the operations performed during the exponential portion
+    of the method.
+
+    :param mass_list: A list of masses from which to identify subsets.
+
+    :param mass: The target mass of the sum of the substructures.
+
+    :param max_subset_length: The maximum length of subsets to return. Allows the recursive backtracking algorithm to
+        terminate early in many cases, significantly improving runtime.
+
+    :return: Generates of lists containing the masses of valid subsets.
+    """
+
+    n = len(mass_list)
+
+    # initialise dynamic programming array
+    sum_matrix = numpy.ndarray([n + 1, mass + 1], bool)
+
+    # subsets can always equal 0
+    for i in range(n+1):
+        sum_matrix[i][0] = True
+
+    # empty subsets do not have non-zero sums
+    for i in range(mass):
+        sum_matrix[0][i + 1] = False
+
+    # fill in the remaining boolean matrix
+    for i in range(n):
+        for j in range(mass+1):
+            if j >= mass_list[i]:
+                sum_matrix[i + 1][j] = sum_matrix[i][j] or sum_matrix[i][j - mass_list[i]]
+            else:
+                sum_matrix[i + 1][j] = sum_matrix[i][j]
+
+    # backtrack through the matrix recursively to obtain all solutions
+    return find_path(mass_list, sum_matrix, n, mass, max_subset_length)

metaboblend/auxiliary.py

@@ -20,8 +20,8 @@
 #
 
 import itertools
-import networkx as nx
 import pylab as plt
+import networkx as nx
 
 
 def calculate_complete_multipartite_graphs(max_atoms_available, max_n_substructures):