myopic-mces 1.0.0__tar.gz

myopic_mces-1.0.0/.github/workflows/workflow.yml

@@ -0,0 +1,35 @@
+name: Publish Python distributions to PyPI
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'pyproject.toml'
+
+jobs:
+  build-and-publish:
+    name: Build and publish Python distributions to PyPI
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write  # IMPORTANT: this permission is mandatory for trusted publishing
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v3
+
+      - name: Setup Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: "3.10"
+          cache: "pip"
+
+      - name: Install build/upload packages
+        run: |
+          python -m pip install --upgrade build twine
+
+      - name: Build
+        run: |
+          python -m build
+
+      - name: Publish package distributions to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

myopic_mces-1.0.0/.gitignore

@@ -0,0 +1,129 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/

myopic_mces-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 AlBi-HHU
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

myopic_mces-1.0.0/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.1
+Name: myopic_mces
+Version: 1.0.0
+Summary: A package for computation of the myopic MCES distance
+Project-URL: Homepage, https://github.com/AlBi-HHU/myopic-mces
+Project-URL: Bug Tracker, https://github.com/AlBi-HHU/myopic-mces/issues
+Project-URL: Publication, https://doi.org/10.1101/2023.03.27.534311
+License: MIT License
+        
+        Copyright (c) 2020 AlBi-HHU
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.6
+Requires-Dist: joblib>=1.2.0
+Requires-Dist: networkx>=3.0
+Requires-Dist: pulp>=2.7.0
+Requires-Dist: rdkit>=2022.09.5
+Requires-Dist: scipy>=1.10.1
+Description-Content-Type: text/markdown
+
+# Computation of myopic MCES distances
+
+Implementation of myopic MCES distance computation, see the preprint at [doi:10.1101/2023.03.27.534311](https://doi.org/10.1101/2023.03.27.534311) for details.
+
+## Usage
+
+Input and Output file are in csv format. Every line in the input-file is one comparison:
+
+input-file: `index,SMILES1,SMILES2`
+
+output-file: `index,time taken,myopic MCES distance,status (1 if exact distance, 2/4 if lower bound)`
+
+Run from the command line:
+```bash
+python myopic_mces.py input-file output-file
+```
+
+See [the PuLP documentation](https://coin-or.github.io/pulp/guides/how_to_configure_solvers.html) on how to configure ILP solvers. By default, the PuLP-provided COIN-OR solver will be used.
+
+## Optional Arguments
+
+General options
+```
+--threshold  int         Threshold for the comparison.
+                         Exact distance is only calculated if the distance is lower than the threshold.
+                         If set to -1 the exact disatnce is always calculated.
+
+--solver string          Solver used for solving the ILP. Examples:'CPLEX_CMD', 'GUROBI_CMD', 'GLPK_CMD'
+
+--num_jobs int           Number of jobs; instances to run in parallel.
+                         By default this is set to the number of (logical) CPU cores.
+```
+
+Options for the ILP solver
+```
+--solver_onethreaded    Limit ILP solver to one thread, likely resulting in faster
+                        performance with parallel computations (not available for all solvers).
+
+--solver_no_msg         Prevent solver from logging (not available for all solvers)
+
+```
+
+Experimental options for myopic MCES distance computation
+```
+--no_ilp_threshold           If set, do not add threshold as constraint to ILP,
+                             resulting in longer runtimes and potential violations of the triangle equation.
+
+--choose_bound_dynamically   If set, a potentially weaker but faster lower bound will be computed and used
+                             when this bound is already greater than the threshold. By default (without
+                             this option), always the strongest lower bound will be computed and used.
+```
+
+
+## Dependencies and installation
+
+Python packages required are:
+```
+rdkit(==2022.09.5)
+networkx(==3.0)
+pulp(==2.7.0)
+scipy(==1.10.1)
+joblib(==1.2.0)
+```
+Version numbers in braces correspond to an exemplary tested configuration (under Python version 3.11.0).
+The program can be run on any standard operating system, tested on Windows 10 64 bit and Arch-Linux@linux-6.2.7 64 bit.
+
+The recommended method of installation is via [conda](https://docs.conda.io/en/latest/miniconda.html) or [mamba](https://github.com/mamba-org/mamba):
+Download this repository, navigate to the download location and execute the following commands (replacing `conda` with `mamba` when using mamba):
+```bash
+conda env create -f conda_env.yml
+# to activate the created enironment:
+conda activate myopic_mces
+```
+
+A PyPI-package is also available, install via:
+```bash
+pip install myopic_mces
+```
+
+A typical installation time should not exceed 5 minutes, mostly depending on the internet connection speed to download all required packages.
+
+## Example data
+
+The example provided in [example/example_data.csv](example/example_data.csv) can be run with:
+
+```bash
+python myopic_mces.py example/example_data.csv example/example_data_out.csv
+```
+
+Alternatively, if the package was installed via pip:
+```bash
+myopic_mces example/example_data.csv example/example_data_out.csv
+```
+
+Typical runtime is about 10s on Windows 10 with all default options, running on 4 cores with 8GB RAM. Exemplary output is provided in [example/example_data_out.csv](example/example_data_out.csv).

myopic_mces-1.0.0/README.md

@@ -0,0 +1,95 @@
+# Computation of myopic MCES distances
+
+Implementation of myopic MCES distance computation, see the preprint at [doi:10.1101/2023.03.27.534311](https://doi.org/10.1101/2023.03.27.534311) for details.
+
+## Usage
+
+Input and Output file are in csv format. Every line in the input-file is one comparison:
+
+input-file: `index,SMILES1,SMILES2`
+
+output-file: `index,time taken,myopic MCES distance,status (1 if exact distance, 2/4 if lower bound)`
+
+Run from the command line:
+```bash
+python myopic_mces.py input-file output-file
+```
+
+See [the PuLP documentation](https://coin-or.github.io/pulp/guides/how_to_configure_solvers.html) on how to configure ILP solvers. By default, the PuLP-provided COIN-OR solver will be used.
+
+## Optional Arguments
+
+General options
+```
+--threshold  int         Threshold for the comparison.
+                         Exact distance is only calculated if the distance is lower than the threshold.
+                         If set to -1 the exact disatnce is always calculated.
+
+--solver string          Solver used for solving the ILP. Examples:'CPLEX_CMD', 'GUROBI_CMD', 'GLPK_CMD'
+
+--num_jobs int           Number of jobs; instances to run in parallel.
+                         By default this is set to the number of (logical) CPU cores.
+```
+
+Options for the ILP solver
+```
+--solver_onethreaded    Limit ILP solver to one thread, likely resulting in faster
+                        performance with parallel computations (not available for all solvers).
+
+--solver_no_msg         Prevent solver from logging (not available for all solvers)
+
+```
+
+Experimental options for myopic MCES distance computation
+```
+--no_ilp_threshold           If set, do not add threshold as constraint to ILP,
+                             resulting in longer runtimes and potential violations of the triangle equation.
+
+--choose_bound_dynamically   If set, a potentially weaker but faster lower bound will be computed and used
+                             when this bound is already greater than the threshold. By default (without
+                             this option), always the strongest lower bound will be computed and used.
+```
+
+
+## Dependencies and installation
+
+Python packages required are:
+```
+rdkit(==2022.09.5)
+networkx(==3.0)
+pulp(==2.7.0)
+scipy(==1.10.1)
+joblib(==1.2.0)
+```
+Version numbers in braces correspond to an exemplary tested configuration (under Python version 3.11.0).
+The program can be run on any standard operating system, tested on Windows 10 64 bit and Arch-Linux@linux-6.2.7 64 bit.
+
+The recommended method of installation is via [conda](https://docs.conda.io/en/latest/miniconda.html) or [mamba](https://github.com/mamba-org/mamba):
+Download this repository, navigate to the download location and execute the following commands (replacing `conda` with `mamba` when using mamba):
+```bash
+conda env create -f conda_env.yml
+# to activate the created enironment:
+conda activate myopic_mces
+```
+
+A PyPI-package is also available, install via:
+```bash
+pip install myopic_mces
+```
+
+A typical installation time should not exceed 5 minutes, mostly depending on the internet connection speed to download all required packages.
+
+## Example data
+
+The example provided in [example/example_data.csv](example/example_data.csv) can be run with:
+
+```bash
+python myopic_mces.py example/example_data.csv example/example_data_out.csv
+```
+
+Alternatively, if the package was installed via pip:
+```bash
+myopic_mces example/example_data.csv example/example_data_out.csv
+```
+
+Typical runtime is about 10s on Windows 10 with all default options, running on 4 cores with 8GB RAM. Exemplary output is provided in [example/example_data_out.csv](example/example_data_out.csv).

myopic_mces-1.0.0/conda_env.yml

@@ -0,0 +1,11 @@
+name: myopic_mces
+channels:
+  - conda-forge
+dependencies:
+  - rdkit
+  - networkx
+  - pulp
+  - scipy
+  - pip
+  - pip:
+      - joblib

myopic_mces-1.0.0/example/example_data.csv

@@ -0,0 +1,101 @@
+0,CCSC1=C(C=C(C(=C1)OC)CCN)OC,CS/C=C/C(=O)OC[C@H]1CCN2[C@@H]1CCC2
+1,CC(CCCN1C=C(C2=CC=CC=C21)C(=O)C3=CC=CC4=CC=CC=C43)O,COC1=C(C=C2C(=C1)CCN=C2CC3=CC=CC=C3)OCC4=CC=CC=C4
+2,CC1=C(C(=CC=C1)O)N,CC1=C(C=CC(=C1)O)N
+3,CCC(CCN1C=C(C2=CC=CC=C21)C(=O)C3=CC=CC4=CC=CC=C43)O,COC1=C(C=C2C(=C1)CCN=C2CC3=CC=CC=C3)OCC4=CC=CC=C4
+4,CC(C)C(C(=O)N)NC(=O)C1=NN(C2=CC=CC=C21)CC3CCCCC3,CC(C)CC1COCN2C(=CN=N2)CCC(C(=O)N1)CC3=CC=CC=C3
+5,CC(CCCN1C=C(C2=CC=CC=C21)C(=O)C3C(C3(C)C)(C)C)O,CC1CC(=CCC12COC(OC2)C3=CN=CC=C3)CCC=C(C)C
+6,C(C(C(=O)NCC(=O)NC(CC(=O)O)C(=O)O)N)C(=O)O,C(C1C(C(C(C(O1)OC2=C(NC(=O)NC2=O)N)O)O)O)O
+7,CC(CC1=CC2=C(C=C1)OC=C2)NC,CN(C)CC1CC2=CC=CC=C2C1=O
+8,C1=CC=C2C(=C1)C=CC=C2C(=O)C3=CN(C4=CC=CC=C43)CCCCCO,COC1=C(C=C2C(=C1)CCN=C2CC3=CC=CC=C3)OCC4=CC=CC=C4
+9,C1CN(CCC1N)C(=O)OCC2=CC=CC=C2,C1=CC(=CC=C1C=CC(=O)NCCCCN)O
+10,CC1=CC=CC=C1C(C2=CC=CC=C2)O,C1=CC=C(C=C1)COCC2=CC=CC=C2
+11,CN1C2=C(C=C(C=C2)Cl)C(=NC(C1=O)OC3C(C(C(C(O3)C(=O)O)O)O)O)C4=CC=CC=C4,CN(C)C1C2C(C3C(=C)C4=C(C=CC(=C4C(=C3C(=O)C2(C(=C(C1=O)C(=O)N)O)O)O)O)Cl)O
+12,CCCCCN1C=C(C2=CC=CC=C21)C(=O)OC3=CC=CC4=C3N=CC=C4,CN1C2=C3C(=CC1=O)C4=CC=CC=C4C(=O)C3=C(C=C2)NC5CCCCC5
+13,CC1=C(C=C[N+](=C1CS(=O)(=O)C2=NC3=CC=CC=C3N2)[O-])OCCCOC,CSCCC(C(=O)O)NC(=O)COC1=CC2=C(C=C1)N=C3CCCN3C2=O
+14,CC(C)C(C(=O)N)NC(=O)C1=NN(C2=CC=CC=C21)CC3=CC=C(C=C3)F,COC1=NC=CC(=N1)C2=C(N=CN2C3CCC(CC3)O)C4=CC=C(C=C4)F
+15,C1C(O1)CCCN2C=C(C3=CC=CC=C32)C(=O)C4=CC=CC5=CC=CC=C54,CC1=C(C(=C2C(=N1)C3=CC=CC=C3C2=O)C4=CC=C(C=C4)C(C)C)C(=O)C
+16,CC(C(=O)O)NC(=O)C(CC1=CC=C(C=C1)O)N,CC(C(=O)NC(CC1=CC=C(C=C1)O)C(=O)O)N
+17,C1=CC=C2C(=C1)C=CC=C2C(=O)C3=CN(C4=CC=CC=C43)CCCCC(=O)O,CCOC(=O)CC1=CC(=NC2=C1C3=CC=CC=C3C=C2)C4=CC=C(C=C4)OC
+18,CC(=NO)CC1=CC2=C(C=C1)OCO2,COC1=C(C=C2CCNC(=O)C2=C1)O
+19,CCC=CCC=CCC=CCC=CCC=CCC=CCCC(=O)NCC(=O)O,CC=C(C)C1C(C2C(CC(CC2C=C1C)C)C)C(=O)C3=CC(NC3=O)(C)OC
+20,CCCCCN1C=C(C2=CC=CC=C21)C(=O)NC3=CC=CC4=CC=CC=C43,C1CC(CN(C1)CC2=CC=CC=N2)C(=O)C3=C4C=CC=C5C4=C(CC5)C=C3
+21,CC1=CC=C(C2=CC=CC=C12)C(=O)C3=CN(C4=CC=CC=C43)CCCCC(=O)O,CC1=CC=C(O1)C(C2=CC=CC=C2C(=O)NCC3=CC=CC=C3)C4=CC=C(O4)C
+22,CNCCCC(C1=CN=CC=C1)O,C1CC1C(C2CC2)NC3=NCCO3
+23,CC(=C)C1=CC2=CC(=C(C=C2O1)O)C(=O)C,CC1=C(C(=C2C(=C1)C=CC=C2O)O)C(=O)C
+24,CC(C)N1C(=O)C2=CC=CC=C2N(S1(=O)=O)C,CC(=CC(=O)NS(=O)(=O)C1=CC=C(C=C1)N)C
+25,CC1=CC(=C(C=C1OC)CCNCC2=CC=CC=C2OC)OC,CN(CCC1=CC=C(C=C1)OC)CC2=CC(=C(C=C2)OC)OC
+26,C1C(C(C(C1=O)CC=CCCCC(=O)NC(CO)CO)C=CC(CCC2=CC=CC=C2)O)O,CC1C(CC=CCCC=CC(=O)OC1C(=CC(C)C(=O)CCCC2CC(=O)NC(=O)C2)C)O
+27,CCCCCC=CCC=CCC=CCC=CCCCC(=O)NC1=C(C=C(C=C1)O)C,CC1=CC=C(C=C1)C2(CCOC(C2)C(C)C)CCNCC3=CC=C(C=C3)OC(C)C
+28,CS(=O)(=O)N(CC1=CC=CO1)CC(CN2C3=CC=CC=C3C4=CC=CC=C42)O,COC1=C(C=C(C=C1)CCNC(=O)C2CSC3N2C(=O)C4=CC=CC=C34)OC
+29,CCCCCC(C)OC(=O)COC1=C2C(=C(C=C1)Cl)C=CC=N2,C[N+]1(CCC23C=CC(CC2OC4=C(C=CC(=C34)C1)OC)O)CCl
+30,C1CC(C(=O)C=C1)(C2=CC=CC=C2Cl)N,C1CC(=CC(=O)C1)NC2=CC=C(C=C2)Cl
+31,CC(CC1=C2CCOC2=CC=C1)N,CC(C(C=CC1=CC=CC=C1)O)N
+32,CCCCCN1C=C(C2=CC=CC=C21)C(=O)NC3=CC4=CC=CC=C4C=C3,C1CC(CN(C1)CC2=CC=CC=N2)C(=O)C3=C4C=CC=C5C4=C(CC5)C=C3
+33,CC1(CC2=C(O1)C(=CC=C2)O)C,CCOC(=O)CC1=CC=CC=C1
+34,CCC=CCC=CCC=CCC=CCC=CCCCCCC(=O)NCCO,CCCCCCCCCCCCCCCC(=O)N/C=C/C1=CC=C(C=C1)O
+35,CC(=O)N1CCCC(C1)N,C[N+](C)(C)CC(CC#N)O
+36,COC1=CC=C(C=C1)C=CC(=O)C2=C(C=CC(=C2)OC)OC,COC1=CC=C(C=C1)C=CC(=O)C2=C(C=C(C=C2)OC)OC
+37,CCCCCC=CC=C1C(CCC1=O)CC=CCCCC(=O)O,CCCCCC=CCC=CC=CC(=O)CC=CCCCC(=O)O
+38,CCCCCC(C=CC1C2CC(C1CC=CCCCC(=O)O)OO2)OO,CCCCCC(C=CC=CC=CC=CC(C(CCCC(=O)O)O)O)OO
+39,CCC(C(=O)C1=CC2=C(CCC2)C=C1)NCC,CCC(=O)C1CCC(C2=C(C1)N=C(C=C2)C)C
+40,CCCCCC=CCC(=O)C=CC=CCC=CCCCC(=O)O,CC(C=CCC=CCC=CCC=CCC=CCCCC(=O)O)O
+41,CC(C(=O)NC(CC1=CC=CC=C1)C(=O)N)NC(=O)C(CC2=CC=C(C=C2)O)N,CC(C)(CC(=O)N1CC2=C(CC1C(=O)NCC3=CC=CC=C3)N=CN2)CC(=O)O
+42,CC12CCC3C(=O)OC(CC3(C1C(=O)C(CC2C(=O)OC)O)C)C4=COC=C4,CC12CC(OC(=O)C1CC(C3(C2CC(C=C3C(=O)OC)O)C)O)C4=COC=C4
+43,CC1CCC(C2=C(CCC12)C)C=C(C)C(=O)O,CC1=C2CC(CCC2(CCC1)C)C(=C)C(=O)O
+44,C1=CC=C2C(=C1)C=CC=C2NC(=O)C3=NN(C4=CC=CC=C43)CCCCCF,C1C2CN(CC1C3=CC=C(C(=O)N3C2)C4=CN=CC=C4)CC5=CC=C(C=C5)F
+45,COC1=C(C2=C3C(CC4=CC(=C(C=C42)OC)O)NCCC3=C1)O,COC1=C(C=C2C(=C1)CC3C4=C2C(=C(C=C4CCN3)O)OC)O
+46,C1CC(=O)N(C1=O)OC(=O)CCCCCCC(=O)ON2C(=O)CCC2=O,CN1C(CC(C1=O)OC2C(C(C(C(O2)C(=O)O)O)O)O)C3=CN=CC=C3
+47,COC(=O)CCCC=CCC1C(CC(C1C=CC(CCC2=CC=CC=C2)O)O)O,CCC1CCCC(C(C(=O)C=CC2C3CC(CC3C=CC2C=CC(=O)O1)O)C)O
+48,CC(CCCN1C=C(C2=CC=CC=C21)C(=O)C3=CC=C(C=C3)O)O,CCOC1=CC=CC(=O)C2=C(N(C(=C12)C)C3=CC=C(C=C3)OC)C
+49,CON=C(CC1=CN=CC=C1)C2=C(C=C(C=C2)Cl)Cl,C1=CC=C(C=C1)CNC(=O)NC2=CC(=C(C=C2)Cl)Cl
+50,C1CN(CCC1N)CC2=CC=CC=C2,CC1=CC(=C(C=C1)N2CCCCC2)N
+51,CC1C=C(C(=O)C2(C1CC3C4(C2C(=O)C(=C(C4CC(=O)O3)C)OC)C)C)OC,CC12CCC(C(C1CCC=C2C(=O)OC)(C)CC(=O)C3=COC=C3)C(=O)OC
+52,CN(C)C1=CC=C(C=C1)C=CC(=O)C2=C(C=C(C=C2OC)OC)O,COC1=C(C=C2CN3CCC4=CC(=C(C=C4[C@@H]3CC2=C1)OC)O)O
+53,CC(C)N(CCC1=CNC2=C1C(=CC=C2)OC(=O)C)C(C)C,CCC1CN2CCC1CC2CNC(=O)COC3=CC=CC=C3
+54,CCCCCCCCC(=O)NC1CCOC1=O,CC(C)NC(=O)C1CCC(C1(C)C)(C)C(=O)O
+55,C1CC1N2C=C(C(=O)C3=CC(=C(C=C32)NCCN)F)C(=O)O,CC1C(=O)N2CCN(CC2C(=O)N1)C(=O)C3=CC(=CC=C3)F
+56,CCCCCCCCCCCCCCC(=O)NC1CCOC1=O,C1CCCCCC2(CCCCC1)OCC(O2)CN3CCOCC3
+57,CCC1=CC=CC2=C1NC3=C2C(=O)COC3(CC)CC(=O)OC,CC(=C)C(CC1=C(C2=CC=CC=C2N(C1=O)C)OC)OC(=O)C
+58,CCCCCC(C=CC1C(CC(C1CC=CCCCCO)O)O)O,CCC(C)C(CC1CC1CC2CC2CC(C(CC)C(=O)O)O)OC
+59,CC(C)C(C(=O)N)NC(=O)C1=NN(C2=CC=CC=C21)CCCC(C)O,CN1C2CCN(C2C(=O)NCC1CCC(=O)OC)CC3=CC=CC=N3
+60,C1=CC=C2C(=C1)C3=C(N2)C(=NC=C3)CCC(=O)O,CCC1=C2C(=CC(=N1)C(=O)O)C3=CC=CC=C3N2
+61,CCC1=CC=C(C2=CC=CC=C12)C(=O)C3=CN(C4=CC=CC=C43)CCCCC(=O)O,CC1=C(C=CC(=C1)C2=CC3=CC(=C(C=C3C(=N2)CC4=CC=CC=C4)OC)OC)OC
+62,CCC(C(=O)C1=CC=C(C=C1)C)NC,CCN(CC)C(=O)C1=CC(=CC=C1)C
+63,CCC=CCC=CCC=CCC=CCC=CCC#CCCC(=O)O,CCC(=O)C1(CCC2C1(CCC3=C4CCC(=O)C=C4CCC23)C)C
+64,CC(=O)CC(C1=CC=CO1)C2=C(C3=CC=CC=C3OC2=O)O,COC1=CC2=C(C=C1)C(=O)C(=CC3=CC(=C(C=C3)O)O)CO2
+65,COC1=CC(=CC(=C1O)OC)C=CCO,COC1=C(C=C(C=C1)CCC(=O)OC)O
+66,CC(CCCCN1C(=O)C2=C(N=CN2C)N(C1=O)C)OC(=O)C,C1CCC(CC1)C(=O)N2CCN3C(C2)C(=O)N(C3=O)CC(=O)N
+67,CC12CCC3C4(CCCC(C4CCC3(C1)CC2=O)(C)C(=O)O)C,CC12CCCC(C1CCC34C2CCC(C3)(C(=C)C4)O)(C)C(=O)O
+68,CCCCCN1C2=CC=CC=C2C(=N1)C(=O)NC(C(C)C)C(=O)N,CN1C2CCNC2C(=O)NCC1CCC(=O)NCC3=CC=CC=C3
+69,CC(C)(C)C(C(=O)OC)NC(=O)C1=NN(C2=CC=CC=C21)CCCCCF,COC1=C(C=C2C3CC(C(CN3CCC2=C1)N4CC(CC4=O)CF)N)OC
+70,CCCCCN1C2=CC=CC=C2C(=N1)C(=O)NC(C(=O)N)C(C)(C)C,CC1C2C(N(C(=O)NC2N(C(=O)N1)C(C)C)C(C)C)C3=CC=CC=C3
+71,CCCCCCCCCCCCCCCC(=O)OCC1(CC23CCC4C5=C(C=CC4(C2CCC1C3)C)OC=C5)O,CCCCC1CCCCC(CC2=CC(=C(C(CCCCC(CC3=CC(=C1C(=C3)O)O)C)CCCC)C(=C2)O)O)C
+72,CC(C)(C)OC(=O)NC(CC1=CN=CN1)C(=O)O,CCNC1=NC(=O)N(C=C1)C2CC(C(O2)CO)O
+73,C1CC(CCC1N2C(=NN=N2)CCCCOC3=CC4=C(C=C3)NC(=O)CC4)O,CCN(CCN1C(=NC2=C1C(=O)N(C(=O)N2C)C)CC3=CC=CC=C3)CCO
+74,CCCCCCCCCC(=O)NC1=CC(=CC=C1)[N+](=O)[O-],CCC1CN(CCC1CC(=O)NCC2=CC=CO2)C(=O)C
+75,CC(=O)N1CCC(CC1)N,C[N+](C)(C)CC(CC#N)O
+76,CCCCCC=CCC=CCC=CCC=CCCCC(=O)NCC(CC(=O)O)O,CC(=CC(=C)C(CC(CC(CC(CC=C)OC)OC)OC)OC)CC=C(C)[N+]#[C-]
+77,CCCCCC(C)(C=CC1C(CC(C1CC=CCCCC(=O)NCC)O)O)O,CCCC=CCC=CCCCCCCCC(=O)OC(CCC(=O)O)[N+](C)(C)C
+78,C1CC2C(C(CC1N2)OC(=O)C3=CC=CC=C3)C(=O)O,CN(CC1=CC=CC=C1)CC2=C(C(=O)C=C(O2)CO)O
+79,CNC1(CCCCC1=O)C2=CC=CC=C2OC,CCC(=O)NC1CCC2=C(C1)C(=CC=C2)OC
+80,CCOC(=O)C(C1CCCCN1)C2=CC=CC=C2,CCC(=O)C1(CCN(CC1)C)C2=CC(=CC=C2)O
+81,CN(CC1=CC=CC=C1)C2CCCNC2,CN1CCC2=CC=CC=C2C1CN(C)C
+82,C1=CC=C2C(=C1)C=C(C(=C2CC3=C(C(=CC4=CC=CC=C43)C(=O)O)O)O)C(=O)O,CC1=C(C(=O)C2=C(C1=O)C=CC=C2O)CC3=C(C(=O)C4=C(C3=O)C(=CC=C4)O)C
+83,CC1=CC=CC(=C1)C(=O)C(C)N2CCCC2,CC(C)CNC=C(C)C(=O)C1=CC=CC=C1
+84,CN1CCN(CC1)C2=NC3=C(C=CC(=C3)OC)OC4=C2C=C(C=C4)Cl,CC1=CC(=C(N1C2=C(N(N(C2=O)C3=CC=CC=C3)C)C)C)C(=O)CCl
+85,CCC1=C(C=C(C(=C1)C(=O)C)O)OCCCCCC(C)(C)C2=NNN=N2,CCC1CN(CCC1CC(=O)NCCNC(=O)C)C(=O)C2=CN=CC=C2
+86,CCCCCCC=CCCCCCC(=O)CC(=O)NC1CCOC1=O,CC12CCCC(=C)C1CC3C(C2)OC(=O)C3CN(C)CC(OC)OC
+87,COC1=CC=CC=C1CNCCC2=CC(=C(C=C2OC)Cl)OC,C[N+]1(CCC23C=CC(CC2OC4=C(C=CC(=C34)C1)OC)O)CCl
+88,C1CC1CNC(=O)CCCC=CCC2C(CC(C2C=CC(COC3=CC=CC=C3)O)O)O,CC(C)C1=CC23CCC4C(C2CC1C5C3C(=O)N(C5=O)CCO)(CCCC4(C)C(=O)O)C
+89,C1=CC=C(C=C1)CCCCCCNC(=O)OC2=CC=CC(=C2)C3=CC(=CC=C3)C(=O)N,C1CCN2CCCC(C2C1)CNC(=O)C3=CC=CC(=C3)C4=CC5=CC=CC=C5OC4=O
+90,C1=CC2=C(C(=C1)O)NC(=CC2=O)C(=O)O,C1=CC2=C(C=C1O)C(=O)C=C(N2)C(=O)O
+91,CC1(C(C1(C)C)C(=O)C2=CN(C3=CC=CC=C32)CCCCCO)C,CC1=NC(=C(C=C1)OC(=O)C23CC4CC(C2)CC(C4)C3)C(C)(C)C
+92,CCCCCC=CCC=CCC=CC=CC(=O)CCCC(=O)O,CCCCCC=CCC(=O)C=CC=CCC=CCCCC(=O)O
+93,C1C(C(C(C1O)C=CC(CCC2=CC=CC=C2)O)CC=CCCCC(=O)NC(CO)CO)O,CC12CCC3C(C1CCC(C2CC(=O)NCC4=CC=CC=C4OC)O)(COC(O3)COC)C
+94,CC1(C(=O)C2=C(O1)C(=CC=C2)O)C,COC1=C(C=C(C=C1)C=CC=O)O
+95,C#CCOC1=CC=CC=C1CCCCCC(=O)O,CC1=C2CC(CCC2(C=CC1=O)C)C(=C)C(=O)O
+96,CN(CCC(=NO)C(=O)C1=CN=CC=C1)N=O,CCC(C1=CN=C2C(=N1)C(=O)N(C(=O)N2)C)O
+97,CC1CN(CCN1C)C(=O)C2=CN(C3=C2C=CC=C3OC)CC4CCCCC4,CC(C)C(C(=O)NCC1CCCN2C1CCCC2)N3CC4=CC=CC=C4C3=O
+98,CCCCCC(C=CC=CCCCCCCCCCC(=O)O)OO,CCCCCCC(CC=CCCCCCCCC(=O)O)OC(=O)C
+99,COC1=CC=CC(=C1)C(=S)N,C1=CC=C(C=C1)CC(=S)NO
+100,CC1=CC2C(CC1)(C3(C(C(C(C34CO4)O2)O)OC(=O)C)C)COC(=O)C,C[C@@H]1C[C@H]2[C@@H]([C@@H](C[C@@](C(=O)C[C@@H]1O)(C)O)OC(=O)C(=C)C)C(=C)C(=O)O2

myopic_mces-1.0.0/example/example_data_out.csv

@@ -0,0 +1,101 @@
+0,0.8935220241546631,10,2
+1,1.7779769897460938,10,2
+2,0.7666854858398438,2.0,1
+3,1.886087417602539,10,2
+4,1.1720013618469238,10,2
+5,1.3709580898284912,10,2
+6,0.6033799648284912,13.0,4
+7,0.8473553657531738,10.0,1
+8,1.1307294368743896,10,2
+9,0.2676382064819336,10.0,1
+10,0.3690464496612549,2.0,1
+11,0.02732396125793457,15.0,4
+12,0.8388707637786865,10,2
+13,0.017572879791259766,18.0,4
+14,0.027521848678588867,17.0,4
+15,1.2031121253967285,10,2
+16,0.24315237998962402,2.0,1
+17,1.3124303817749023,10,2
+18,0.24808931350708008,8.0,1
+19,0.026569604873657227,14.0,4
+20,1.1287765502929688,10,2
+21,0.03397989273071289,11.5,4
+22,0.2266993522644043,10,2
+23,0.2823958396911621,8.5,1
+24,0.23221635818481445,8.0,1
+25,0.5202853679656982,6.0,1
+26,1.5058989524841309,10,2
+27,0.03613901138305664,13.5,4
+28,0.0243985652923584,18.5,4
+29,0.021234989166259766,12.0,4
+30,0.19841241836547852,4.0,1
+31,0.259920597076416,6.0,1
+32,1.565441608428955,10,2
+33,0.17687010765075684,8.0,1
+34,1.1181747913360596,10,2
+35,0.12376904487609863,8.0,1
+36,0.41043567657470703,2.0,1
+37,0.7481114864349365,6.0,1
+38,1.110314130783081,10.0,1
+39,0.5891437530517578,10,2
+40,0.6584610939025879,6.0,1
+41,0.029075145721435547,12.5,4
+42,0.8252356052398682,4.0,1
+43,0.4747192859649658,6.0,1
+44,0.03524971008300781,12.0,4
+45,0.46724486351013184,4.0,1
+46,0.0179443359375,16.0,4
+47,1.5226995944976807,10,2
+48,0.5487077236175537,10,2
+49,0.29987573623657227,10,2
+50,0.23734402656555176,4.0,1
+51,0.9015848636627197,10,2
+52,0.4507875442504883,10,2
+53,0.4521918296813965,10,2
+54,0.3387339115142822,8.0,1
+55,0.32390570640563965,10,2
+56,0.46780920028686523,10,2
+57,0.3915855884552002,10,2
+58,0.6075198650360107,10,2
+59,0.018615245819091797,12.5,4
+60,0.28983640670776367,2.0,1
+61,0.03423500061035156,12.0,4
+62,0.21294283866882324,6.0,1
+63,0.025656938552856445,13.0,4
+64,0.4521300792694092,10,2
+65,0.18150854110717773,6.0,1
+66,0.0157473087310791,13.0,4
+67,0.7337052822113037,4.0,1
+68,0.5009119510650635,10,2
+69,0.03911733627319336,11.0,4
+70,0.44536709785461426,10,2
+71,0.06927871704101562,12.5,4
+72,0.26279354095458984,10,2
+73,0.02523326873779297,25.5,4
+74,0.015688657760620117,15.5,4
+75,0.1666100025177002,10.0,1
+76,0.0304563045501709,16.0,4
+77,0.7685189247131348,10,2
+78,0.3359997272491455,10,2
+79,0.2607276439666748,8.0,1
+80,0.37820887565612793,10.0,1
+81,0.28598618507385254,6.0,1
+82,0.03360486030578613,11.0,4
+83,0.2871870994567871,6.0,1
+84,0.02286696434020996,15.5,4
+85,0.02148747444152832,21.0,4
+86,0.02533125877380371,13.0,4
+87,0.41715145111083984,10,2
+88,0.040938615798950195,17.0,4
+89,1.3361961841583252,10,2
+90,0.2315044403076172,2.0,1
+91,0.5691916942596436,10,2
+92,0.5627284049987793,4.0,1
+93,0.03430485725402832,12.0,4
+94,0.1643238067626953,6.0,1
+95,0.31859779357910156,10,2
+96,0.00754857063293457,17.5,4
+97,0.6105747222900391,10,2
+98,0.40708208084106445,8.0,1
+99,0.14671039581298828,6.0,1
+100,0.49617958068847656,10,2

myopic_mces-1.0.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+[project]
+name = "myopic_mces"
+version = "1.0.0"
+description = "A package for computation of the myopic MCES distance"
+readme = "README.md"
+license = {file = "LICENSE"}
+requires-python = ">=3.6"
+classifiers = [
+            "Programming Language :: Python :: 3",
+            "License :: OSI Approved :: MIT License",
+            "Operating System :: OS Independent",
+]
+dependencies = [
+             "rdkit >= 2022.09.5",
+             "networkx >= 3.0",
+             "pulp >= 2.7.0",
+             "scipy >= 1.10.1",
+             "joblib >= 1.2.0",
+]
+[project.scripts]
+myopic_mces = "myopic_mces.myopic_mces:main"
+[project.urls]
+"Homepage" = "https://github.com/AlBi-HHU/myopic-mces"
+"Bug Tracker" = "https://github.com/AlBi-HHU/myopic-mces/issues"
+"Publication" = "https://doi.org/10.1101/2023.03.27.534311"

myopic_mces-1.0.0/src/myopic_mces/MCES_ILP.py

@@ -0,0 +1,161 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Oct  5 17:17:41 2020
+
+@author: seipp
+"""
+import pulp
+import networkx as nx
+
+def MCES_ILP(G1,G2,threshold,solver,solver_options={},no_ilp_threshold=False):
+    """
+     Calculates the exact distance between two molecules using an ILP
+
+     Parameters
+     ----------
+     G1 : networkx.classes.graph.Graph
+         Graph representing the first molecule.
+     G2 : networkx.classes.graph.Graph
+         Graph representing the second molecule.
+     threshold : int
+         Threshold for the comparison. Exact distance is only calculated if the distance is lower than the threshold.
+     solver: string
+         ILP-solver used for solving MCES. Example:GUROBI_CMD
+     solver_options: dict
+         additional options to pass to solvers. Example: threads=1, msg=False for better multi-threaded performance
+     no_ilp_threshold: bool
+         if true, always return exact distance even if it is below the threshold (slower)
+
+     Returns:
+     -------
+     float
+         Distance between the molecules
+     int
+         Type of Distance:
+             1 : Exact Distance
+             2 : Lower bound (If the exact distance is above the threshold)
+
+    """
+
+    ILP=pulp.LpProblem("MCES", pulp.LpMinimize)
+
+    #Variables for nodepairs
+    nodepairs=[]
+    for i in G1.nodes:
+        for j in G2.nodes:
+            if G1.nodes[i]["atom"]==G2.nodes[j]["atom"]:
+                nodepairs.append(tuple([i,j]))
+    y=pulp.LpVariable.dicts('nodepairs', nodepairs,
+                            lowBound = 0,
+                            upBound = 1,
+                            cat = pulp.LpInteger)
+    #variables for edgepairs and weight
+    edgepairs=[]
+    w={}
+    for i in G1.edges:
+        for j in G2.edges:
+            if (G1.nodes[i[0]]["atom"]==G2.nodes[j[0]]["atom"] and G1.nodes[i[1]]["atom"]==G2.nodes[j[1]]["atom"]) or (G1.nodes[i[1]]["atom"]==G2.nodes[j[0]]["atom"] and G1.nodes[i[0]]["atom"]==G2.nodes[j[1]]["atom"]):
+                edgepairs.append(tuple([i,j]))
+                w[tuple([i,j])]=max(G1[i[0]][i[1]]["weight"],G2[j[0]][j[1]]["weight"])-min(G1[i[0]][i[1]]["weight"],G2[j[0]][j[1]]["weight"])
+
+    #variables for not mapping an edge
+    for i in G1.edges:
+        edgepairs.append(tuple([i,-1]))
+        w[tuple([i,-1])]=G1[i[0]][i[1]]["weight"]
+    for j in G2.edges:
+        edgepairs.append(tuple([-1,j]))
+        w[tuple([-1,j])]=G2[j[0]][j[1]]["weight"]
+    c=pulp.LpVariable.dicts('edgepairs', edgepairs,
+                            lowBound = 0,
+                            upBound = 1,
+                            cat = pulp.LpInteger)
+
+
+    #objective function
+    ILP += pulp.lpSum([ w[i]*c[i] for i in edgepairs])
+
+
+
+
+    #Every node in G1 can only be mapped to at most one in G2
+    for i in G1.nodes:
+        h=[]
+        for j in G2.nodes:
+            if G1.nodes[i]["atom"]==G2.nodes[j]["atom"]:
+                h.append(tuple([i,j]))
+        ILP+=pulp.lpSum([y[k] for k in h])<=1
+
+    #Every node in G1 can only be mapped to at most one in G1
+    for i in G2.nodes:
+        h=[]
+        for j in G1.nodes:
+            if G1.nodes[j]["atom"]==G2.nodes[i]["atom"]:
+                h.append(tuple([j,i]))
+        ILP+=pulp.lpSum([y[k] for k in h])<=1
+
+    #Every edge in G1 has to be mapped to an edge in G2 or the variable for not mapping has to be 1
+    for i in G1.edges:
+        ls=[]
+        rs=[]
+        for j in G2.edges:
+            if (G1.nodes[i[0]]["atom"]==G2.nodes[j[0]]["atom"] and G1.nodes[i[1]]["atom"]==G2.nodes[j[1]]["atom"]) or (G1.nodes[i[1]]["atom"]==G2.nodes[j[0]]["atom"] and G1.nodes[i[0]]["atom"]==G2.nodes[j[1]]["atom"]):
+                ls.append(tuple([i,j]))
+        ILP+=pulp.lpSum([c[k] for k in ls])+c[tuple([i,-1])]==1
+
+    #Every edge in G2 has to be mapped to an edge in G1 or the variable for not mapping has to be 1
+    for i in G2.edges:
+        ls=[]
+        rs=[]
+        for j in G1.edges:
+            if (G1.nodes[j[0]]["atom"]==G2.nodes[i[0]]["atom"] and G1.nodes[j[1]]["atom"]==G2.nodes[i[1]]["atom"]) or (G1.nodes[j[1]]["atom"]==G2.nodes[i[0]]["atom"] and G1.nodes[j[0]]["atom"]==G2.nodes[i[1]]["atom"]):
+                ls.append(tuple([j,i]))
+        ILP+=pulp.lpSum([c[k] for k in ls])+c[tuple([-1,i])]==1
+
+    #The mapping of the edges has to match the mapping of the nodes
+    for i in G1.nodes:
+        for j in G2.edges:
+            ls=[]
+            for k in G1.neighbors(i):
+                if tuple([tuple([i,k]),j]) in c:
+                    ls.append(tuple([tuple([i,k]),j]))
+                else:
+                    if  tuple([tuple([k,i]),j]) in c:
+                        ls.append(tuple([tuple([k,i]),j]))
+            rs=[]
+            if G1.nodes[i]["atom"]==G2.nodes[j[0]]["atom"]:
+                rs.append(tuple([i,j[0]]))
+            if G1.nodes[i]["atom"]==G2.nodes[j[1]]["atom"]:
+                rs.append(tuple([i,j[1]]))
+            ILP+=pulp.lpSum([c[k] for k in ls])<=pulp.lpSum([y[k] for k in rs])
+
+
+    for i in G2.nodes:
+        for j in G1.edges:
+            ls=[]
+            for k in G2.neighbors(i):
+                if tuple([j,tuple([i,k])]) in c:
+                    ls.append(tuple([j,tuple([i,k])]))
+                else:
+                    if tuple([j,tuple([k,i])]) in c:
+                        ls.append(tuple([j,tuple([k,i])]))
+            rs=[]
+            if G2.nodes[i]["atom"]==G1.nodes[j[0]]["atom"]:
+                rs.append(tuple([j[0],i]))
+            if G2.nodes[i]["atom"]==G1.nodes[j[1]]["atom"]:
+                rs.append(tuple([j[1],i]))
+            ILP+=pulp.lpSum([c[k] for k in ls])<=pulp.lpSum(y[k] for k in rs)
+
+    #constraint for the threshold
+    if threshold!=-1 and not no_ilp_threshold:
+        ILP +=pulp.lpSum([ w[i]*c[i] for i in edgepairs])<=threshold
+
+    #solve the ILP
+    if solver=="default":
+        ILP.solve()
+    else:
+        sol=pulp.getSolver(solver, **solver_options)
+        ILP.solve(sol)
+    if ILP.status==1:
+        return float(ILP.objective.value()),1
+    else:
+        return threshold,2

myopic_mces-1.0.0/src/myopic_mces/filter_MCES.py

@@ -0,0 +1,254 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Sat Oct 17 17:59:05 2020
+
+@author: seipp
+"""
+
+import networkx as nx
+
+def filter1(G1,G2):
+    """
+     Finds a lower bound for the distance based on degree
+
+     Parameters
+     ----------
+     G1 : networkx.classes.graph.Graph
+         Graph representing the first molecule.
+     G2 : networkx.classes.graph.Graph
+         Graph representing the second molecule.
+
+     Returns:
+     -------
+     float
+         Lower bound for the distance between the molecules
+
+    """
+    #Find all occuring atom types and partition by type
+    atom_types1=[]
+    for i in G1.nodes:
+        if G1.nodes[i]["atom"] not in atom_types1:
+            atom_types1.append(G1.nodes[i]["atom"])
+    type_map1={}
+    for i in atom_types1:
+        type_map1[i]=list(filter(lambda x: i==G1.nodes[x]["atom"],G1.nodes))
+
+    atom_types2=[]
+    for i in G2.nodes:
+        if G2.nodes[i]["atom"] not in atom_types2:
+            atom_types2.append(G2.nodes[i]["atom"])
+    type_map2={}
+    for i in atom_types2:
+        type_map2[i]=list(filter(lambda x: i==G2.nodes[x]["atom"],G2.nodes))
+
+    #calculate lower bound
+    difference=0
+    #Every atom type is done seperately
+    for i in atom_types1:
+        if i in atom_types2:
+            #number of nodes that can be mapped
+            n=min(len(type_map1[i]),len(type_map2[i]))
+            #sort by degree
+            degreelist1=sorted(type_map1[i],key=lambda x:sum([G1[x][j]["weight"] for j in G1.neighbors(x)]),reverse=True)
+            degreelist2=sorted(type_map2[i],key=lambda x:sum([G2[x][j]["weight"] for j in G2.neighbors(x)]),reverse=True)
+            #map in order of sorted lists
+            for j in range(n):
+                deg1=sum([G1[degreelist1[j]][k]["weight"] for k in G1.neighbors(degreelist1[j])])
+                deg2=sum([G2[degreelist2[j]][k]["weight"] for k in G2.neighbors(degreelist2[j])])
+                difference+= abs(deg1-deg2)
+            #nodes that are not mapped
+            if len(degreelist1)>n:
+                for j in range(n,len(degreelist1)):
+                    difference+=sum([G1[degreelist1[j]][k]["weight"] for k in G1.neighbors(degreelist1[j])])
+            if len(degreelist2)>n:
+                for j in range(n,len(degreelist2)):
+                    difference+=sum([G2[degreelist2[j]][k]["weight"] for k in G2.neighbors(degreelist2[j])])
+        #atom type only in one of the graphs
+        else:
+            for j in type_map1[i]:
+                difference+=sum([G1[j][k]["weight"] for k in G1.neighbors(j)])
+    for i in atom_types2:
+        if i not in atom_types1:
+            for j in type_map2[i]:
+                difference+=sum([G2[j][k]["weight"] for k in G2.neighbors(j)])
+    return difference/2
+
+def get_cost(G1,G2,i,j):
+    """
+     Calculates the cost for mapping node i to j based on neighborhood
+
+     Parameters
+     ----------
+     G1 : networkx.classes.graph.Graph
+         Graph representing the first molecule.
+     G2 : networkx.classes.graph.Graph
+         Graph representing the second molecule.
+     i : int
+         Node of G1
+     j : int
+         Node of G2
+
+     Returns:
+     -------
+     float
+         Cost of mapping i to j
+
+    """
+    #Find all occuring atom types in neighborhood
+    atom_types1=[]
+    for k in G1.neighbors(i):
+        if G1.nodes[k]["atom"] not in atom_types1:
+            atom_types1.append(G1.nodes[k]["atom"])
+    type_map1={}
+    for k in atom_types1:
+        type_map1[k]=list(filter(lambda x: k==G1.nodes[x]["atom"],G1.neighbors(i)))
+
+
+    atom_types2=[]
+    for k in G2.neighbors(j):
+        if G2.nodes[k]["atom"] not in atom_types2:
+            atom_types2.append(G2.nodes[k]["atom"])
+    type_map2={}
+    for k in atom_types2:
+        type_map2[k]=list(filter(lambda x: k==G2.nodes[x]["atom"],G2.neighbors(j)))
+
+    #calculate cost
+    difference=0.
+    #Every atom type is handled seperately
+    for k in atom_types1:
+        if k in atom_types2:
+            n=min(len(type_map1[k]),len(type_map2[k]))
+            #sort by incident edges by weight
+            edgelist1=sorted(type_map1[k],key=lambda x:G1[i][x]["weight"],reverse=True)
+            edgelist2=sorted(type_map2[k],key=lambda x:G2[j][x]["weight"],reverse=True)
+            #map in order of sorted lists
+            for l in range(n):
+                difference+=(max(G1[i][edgelist1[l]]["weight"],G2[j][edgelist2[l]]["weight"])-min(G1[i][edgelist1[l]]["weight"],G2[j][edgelist2[l]]["weight"]))/2
+            #cost for not mapped edges
+            if len(edgelist1)>n:
+                for l in range(n,len(edgelist1)):
+                    difference+=G1[i][edgelist1[l]]["weight"]/2
+            if len(edgelist2)>n:
+                for l in range(n,len(edgelist2)):
+                    difference+=G2[j][edgelist2[l]]["weight"]/2
+        else:
+            for l in type_map1[k]:
+                difference+=G1[i][l]["weight"]/2
+    for k in atom_types2:
+        if k not in atom_types1:
+            for l in type_map2[k]:
+                difference+=G2[j][l]["weight"]/2
+    return difference
+
+def filter2(G1,G2):
+    """
+     Finds a lower bound for the distance based on neighborhood
+
+     Parameters
+     ----------
+     G1 : networkx.classes.graph.Graph
+         Graph representing the first molecule.
+     G2 : networkx.classes.graph.Graph
+         Graph representing the second molecule.
+
+     Returns:
+     -------
+     float
+         Lower bound for the distance between the molecules
+
+    """
+    # Find all occuring atom types
+    atom_types1=[]
+    for i in G1.nodes:
+        if G1.nodes[i]["atom"] not in atom_types1:
+            atom_types1.append(G1.nodes[i]["atom"])
+
+    atom_types2=[]
+    for i in G2.nodes:
+        if G2.nodes[i]["atom"] not in atom_types2:
+            atom_types2.append(G2.nodes[i]["atom"])
+
+    atom_types=atom_types1
+
+    for i in atom_types2:
+        if i not in atom_types:
+            atom_types.append(i)
+    #calculate distance
+    res=0
+    #handle every atom type seperately
+    for i in atom_types:
+        #filter by atom type
+        nodes1=list(filter(lambda x: i==G1.nodes[x]["atom"],G1.nodes))
+        nodes2=list(filter(lambda x: i==G2.nodes[x]["atom"],G2.nodes))
+        #Create new graph for and solve minimum weight full matching
+        G=nx.Graph()
+        #Add node for every node of type i in G1 and G2
+        for j in nodes1:
+            G.add_node(tuple([1,j]))
+        for j in nodes2:
+            G.add_node(tuple([2,j]))
+        #Add edges between all nodes of G1 and G2
+        for j in nodes1:
+            for k in nodes2:
+                if G1.nodes[j]["atom"]==G2.nodes[k]["atom"]:
+                    G.add_edge(tuple([1,j]),tuple([2,k]),weight=get_cost(G1,G2,j,k))
+        #Add nodes if one graph has more nodes of type i than the other
+        if len(nodes1)<len(nodes2):
+            diff=len(nodes2)-len(nodes1)
+            for j in range(1,diff+1):
+                G.add_node(tuple([1,-j]))
+                for k in nodes2:
+                    G.add_edge(tuple([1,-j]),tuple([2,k]),weight=sum([G2[l][k]["weight"] for l in G2.neighbors(k)])/2)
+        if len(nodes2)<len(nodes1):
+            diff=len(nodes1)-len(nodes2)
+            for j in range(1,diff+1):
+                G.add_node(tuple([2,-j]))
+                for k in nodes1:
+                    G.add_edge(tuple([1,k]),tuple([2,-j]),weight=sum([G1[l][k]["weight"] for l in G1.neighbors(k)])/2)
+        #Solve minimum weight full matching
+        h=nx.bipartite.minimum_weight_full_matching(G)
+        #Add weight of the matching
+        for k in h:
+            if k[0]==1:
+                res=res+G[k][h[k]]["weight"]
+
+    return res
+
+def apply_filter(G1,G2,threshold,always_stronger_bound=True):
+    """
+     Finds a lower bound for the distance
+
+     Parameters
+     ----------
+     G1 : networkx.classes.graph.Graph
+         Graph representing the first molecule.
+     G2 : networkx.classes.graph.Graph
+         Graph representing the second molecule.
+     threshold : int
+         Threshold for the comparison. We want to find a lower bound that is higher than the threshold
+     always_stronger_bound : bool
+         if true, always compute and use the second stronger bound
+
+
+
+     Returns:
+     -------
+     float
+         Lower bound for the distance between the molecules
+     int
+         Which lower bound was chosen: 2 - depending on threshold, 4 - second lower bound
+
+    """
+    if always_stronger_bound:
+        d=filter2(G1,G2)
+        return d, 4
+    else:
+        #calculate first lower bound
+        d=filter1(G1,G2)
+        #if below threshold calculate second lower bound
+        if d<=threshold:
+            d=filter2(G1,G2)
+            if d<=threshold:
+                return d, 2
+
+        return d, 2

myopic_mces-1.0.0/src/myopic_mces/graph.py

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Oct  5 17:18:56 2020
+
+@author: seipp
+"""
+from rdkit import Chem
+import networkx as nx
+
+def construct_graph(s):
+    """ 
+    Converts a SMILE into a graph
+     
+    Parameters
+    ----------
+    s : str 
+        Smile of the molecule
+        
+    Returns:
+    -------
+    networkx.classes.graph.Graph
+        Graph that represents the molecule.
+        The bond types are represented as edge weights.
+        The atom types are represented as atom attributes of the nodes.
+    """
+    #read the smile
+    m = Chem.MolFromSmiles(s)
+    # convert the molecule into a graph
+    # The bond and atom types are converted to node/edge attributes
+    G=nx.Graph()
+    for atom in m.GetAtoms():
+        G.add_node(atom.GetIdx(),atom=atom.GetSymbol())
+    for bond in m.GetBonds():
+        G.add_edge(bond.GetBeginAtom().GetIdx(),bond.GetEndAtom().GetIdx(),weight=bond.GetBondTypeAsDouble())
+    return G

myopic_mces-1.0.0/src/myopic_mces/myopic_mces.py

@@ -0,0 +1,133 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Oct  5 17:16:05 2020
+@author: seipp
+"""
+import time
+import pulp
+import networkx as nx
+from joblib import Parallel, delayed
+import multiprocessing
+import argparse
+from myopic_mces.graph import construct_graph
+from myopic_mces.MCES_ILP import MCES_ILP
+from myopic_mces.filter_MCES import apply_filter
+
+def MCES(ind, s1, s2, threshold, solver, solver_options={}, no_ilp_threshold=False, always_stronger_bound=True):
+    """
+    Calculates the distance between two molecules
+
+    Parameters
+    ----------
+    ind : int
+        index
+    s1 : str
+        SMILES of the first molecule
+    s2 : str
+        SMILES of the second molecule
+    threshold : int
+        Threshold for the comparison. Exact distance is only calculated if the distance is lower than the threshold.
+        If set to -1 the exact disatnce is always calculated.
+    solver: string
+        ILP-solver used for solving MCES. Example:CPLEX_CMD
+    solver_options: dict
+        additional options to pass to solvers. Example: threads=1 for better multi-threaded performance
+    no_ilp_threshold: bool
+        if true, always return exact distance even if it is below the threshold (slower)
+    always_stronger_bound: bool
+        if true, always compute and use the second stronger bound
+
+    Returns:
+    -------
+    int
+        index
+    float
+        Distance between the molecules
+    float
+        Time taken for the calculation
+    int
+        Type of Distance:
+            1 : Exact Distance
+            2 : Lower bound (if the exact distance is above the threshold; bound chosen dynamically)
+            4 : Lower bound (second lower bound was used)
+
+    """
+    start = time.time()
+    # construct graph for both smiles.
+    G1 = construct_graph(s1)
+    G2 = construct_graph(s2)
+    # filter out if distance is above the threshold
+    if threshold == -1:
+        res = MCES_ILP(G1, G2, threshold, solver, solver_options=solver_options, no_ilp_threshold=no_ilp_threshold)
+        end = time.time()
+        total_time = str(end-start)
+        return ind, res[0], total_time, res[1]
+    d, filter_id = apply_filter(G1, G2, threshold, always_stronger_bound=always_stronger_bound)
+    if d > threshold:
+        end = time.time()
+        total_time = str(end-start)
+        return ind, d, total_time, filter_id
+    # calculate MCES
+    res = MCES_ILP(G1, G2, threshold, solver, solver_options=solver_options, no_ilp_threshold=no_ilp_threshold)
+    end = time.time()
+    total_time = str(end-start)
+    return ind, res[0], total_time, res[1]
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "input", help="input file in the format: id,smiles1,smiles2")
+    parser.add_argument("output", help="output file")
+    parser.add_argument("--threshold", type=int, default=10,
+                        action="store", help="threshold for the distance")
+    parser.add_argument("--no_ilp_threshold", action="store_true",
+                        help="(experimental) if set, do not add threshold as constraint to ILP, "
+                        "resulting in longer runtimes and potential violations of the triangle equation")
+    parser.add_argument("--choose_bound_dynamically", action="store_true",
+                        help="if this is set, compute and use potentially weaker but faster lower bound if "
+                        "already greater than the threshold. Otherwise (default), the strongest lower bound "
+                        "is always computed and used")
+    parser.add_argument("--solver", type=str, default="default",
+                        action="store", help="Solver for the ILP. example:CPLEX_CMD")
+    parser.add_argument("--solver_onethreaded", action="store_true",
+                        help="limit ILP solver to one thread, resulting in faster "
+                        "performance with parallel computations (not available for all solvers)")
+    parser.add_argument("--solver_no_msg", action="store_true",
+                        help="prevent solver from logging (not available for all solvers)")
+    parser.add_argument("--num_jobs", type=int, help="Number of jobs; instances to run in parallel. "
+                        "By default this is set to the number of (logical) CPU cores.")
+    args = parser.parse_args()
+
+    threshold = args.threshold
+
+    num_jobs = multiprocessing.cpu_count() if args.num_jobs is None else args.num_jobs
+    additional_mces_options = dict(no_ilp_threshold=args.no_ilp_threshold, solver_options=dict(),
+                                   always_stronger_bound=not args.choose_bound_dynamically)
+    if args.solver_onethreaded:
+        additional_mces_options['solver_options']['threads'] = 1
+    if args.solver_no_msg:
+        additional_mces_options['solver_options']['msg'] = False
+    F = args.input
+    F2 = args.output
+    f = open(F, "r")
+    solver = args.solver
+
+    inputs = []
+    for line in f:
+        args = line.split(",")
+        inputs.append(tuple([args[0], args[1], args[2]]))
+    f.close()
+
+    if num_jobs > 1:
+        results = Parallel(n_jobs=num_jobs, verbose=5)(
+            delayed(MCES)(i[0], i[1], i[2], threshold, solver, **additional_mces_options) for i in inputs)
+    else:
+        results = [MCES(i[0], i[1], i[2], threshold, solver, **additional_mces_options) for i in inputs]
+
+    out = open(F2, "w")
+    for i in results:
+        out.write(i[0]+","+i[2]+","+str(i[1])+","+str(i[3])+"\n")
+    out.close()
+
+if __name__ == '__main__':
+    main()