nerdd-module 0.2.1__tar.gz → 0.2.4__tar.gz

{nerdd-module-0.2.1 → nerdd-module-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nerdd-module
-Version: 0.2.1
+Version: 0.2.4
 Summary: Base package to create NERDD modules
 Home-page: https://github.com/molinfo-vienna/nerdd-module.git
 Maintainer: Steffen Hirte

{nerdd-module-0.2.1 → nerdd-module-0.2.4}/nerdd_module/io/file_reader.py

@@ -18,14 +18,17 @@ class FileReader(Reader):
         assert isinstance(filename, str), "input must be a string"
 
         try:
-            path = Path(filename).absolute()
+            path = Path(filename)
+
+            if not path.is_absolute():
+                path = self.data_dir / path
         except:
             raise ValueError("input must be a valid path")
 
-        assert path.is_relative_to(self.data_dir), "input must be a relative path"
+        assert self.data_dir in path.parents, "input must be a relative path"
         assert path.exists(), "input must be a valid file"
 
-        with open(filename, "rb") as f:
+        with open(path, "rb") as f:
             for entry in explore(f):
                 if len(entry.source) == 1 and entry.source[0] == "raw_input":
                     source = tuple()

{nerdd-module-0.2.1 → nerdd-module-0.2.4}/nerdd_module/polyfills/get_entry_points.py

@@ -6,7 +6,10 @@ try:
     from importlib.metadata import entry_points
 
     def get_entry_points(group):
-        return entry_points(group=group)
+        try:
+            return entry_points(group=group)
+        except TypeError:
+            return entry_points().get(group, [])
 
 except ImportError:
     import pkg_resources

{nerdd-module-0.2.1 → nerdd-module-0.2.4}/nerdd_module/preprocessing/chembl_structure_pipeline.py

@@ -1,3 +1,4 @@
+import warnings
 from typing import List, Tuple
 
 from rdkit.Chem import Mol
@@ -11,6 +12,13 @@ from .pipeline import Pipeline
 from .remove_stereochemistry import RemoveStereochemistry
 from .step import Step
 
+# before importing chembl_structure_pipeline, we need to suppress RDKit warnings
+warnings.filterwarnings(
+    "ignore",
+    category=DeprecationWarning,
+    module="rdkit.Chem.MolStandardize",
+)
+
 try:
     # importing chembl_structure_pipeline already logs messages
     # --> suppress them temporarily

nerdd-module-0.2.4/nerdd_module/tests/__init__.py

@@ -0,0 +1,3 @@
+from .checks import *
+from .predictions import *
+from .representations import *

nerdd-module-0.2.4/nerdd_module/tests/checks.py

@@ -0,0 +1,134 @@
+import json
+
+import numpy as np
+import pandas as pd
+from pytest_bdd import parsers, then
+
+
+@then(parsers.parse("The result should contain the columns:\n{column_names}"))
+def check_result_columns(predictions, column_names):
+    column_names = column_names.strip()
+    for c in column_names.split("\n"):
+        assert (
+            c in predictions.columns
+        ), f"Column {c} not in predictions {predictions.columns.tolist()}"
+
+
+@then(
+    parsers.parse(
+        "the value in column '{column_name}' should be between {low} and {high}"
+    )
+)
+def check_column_range(subset, column_name, low, high):
+    if low == "infinity":
+        low = np.inf
+    elif low == "-infinity":
+        low = -np.inf
+    else:
+        low = float(low)
+
+    if high == "infinity":
+        high = np.inf
+    elif high == "-infinity":
+        high = -np.inf
+    else:
+        high = float(high)
+
+    assert (low <= subset[column_name]).all()
+    assert (subset[column_name] <= high).all()
+
+
+@then(parsers.parse("the value in column '{column_name}' should be '{expected_value}'"))
+def check_column_value(predictions, column_name, expected_value):
+    value = predictions[column_name].iloc[0]
+
+    # expected value is always provided as string
+    # try to convert to float if possible
+    try:
+        expected_value = float(expected_value)
+    except ValueError:
+        pass
+
+    if expected_value == "(none)":
+        # if expected_value is the magic string "(none)", we expect None
+        assert pd.isnull(value), f"Column {column_name} is assigned to {value} != None"
+    else:
+        # otherwise, we expect the value to be equal to the expected value
+        assert (
+            value == expected_value
+        ), f"Column {column_name} is assigned to {value} != {expected_value}"
+
+
+@then(
+    parsers.parse(
+        "the value in column '{column_name}' should be a subset of {superset}"
+    )
+)
+def check_column_subset(subset, column_name, superset):
+    superset = set(json.loads(superset))
+
+    assert all(
+        set(value).issubset(superset) for value in subset[column_name]
+    ), f"Column {column_name} contains value not in {superset}"
+
+
+@then(parsers.parse("the value in column '{column_name}' should be one of {superset}"))
+def check_column_membership(subset, column_name, superset):
+    superset = json.loads(superset)
+
+    assert isinstance(
+        superset, list
+    ), f"Expected a list for superset, got {type(superset)}"
+
+    assert (
+        subset[column_name].isin(superset).all()
+    ), f"Column {column_name} contains value not in {superset}"
+
+
+@then(parsers.parse("the value in column '{column_name}' should be a png image"))
+def check_png_image(subset, column_name):
+    if len(subset) == 0:
+        return
+
+    assert (
+        subset[column_name].str.startswith('<img src="data:image/png;base64,')
+    ).all(), f"Column {column_name} does not contain a PNG image"
+
+
+@then(
+    parsers.parse("the value in column '{column_name}' should contain only '{value}'")
+)
+def check_column_membership_single(predictions, column_name, value):
+    if value == "(none)":
+        assert all(
+            pd.isnull(predictions[column_name])
+        ), f"Column {column_name} must be none"
+    else:
+        assert all(
+            value in values for values in predictions[column_name]
+        ), f"Column {column_name} contains value {value}"
+
+
+@then(
+    parsers.parse(
+        "the value in column '{column_name}' should have type '{expected_type}'"
+    )
+)
+def check_column_type(subset, column_name, expected_type):
+    expected_type = eval(expected_type)
+
+    assert (
+        subset[column_name].map(lambda x: isinstance(x, expected_type)).all()
+    ), f"Column {column_name} has unexpected type"
+
+
+@then(
+    parsers.parse(
+        "the value in column '{column_name}' should have length greater than {length}"
+    )
+)
+def check_column_length(subset, column_name, length):
+    length = int(length)
+    assert (
+        subset[column_name].map(lambda x: len(x) > length)
+    ).all(), f"Column {column_name} has unexpected length"

nerdd-module-0.2.4/nerdd_module/tests/predictions.py

@@ -0,0 +1,30 @@
+import pandas as pd
+from pytest_bdd import parsers, then, when
+
+
+@when(
+    parsers.parse("the model generates predictions for the molecule representations"),
+    target_fixture="predictions",
+)
+def predictions(
+    representations,
+    model,
+    input_type,
+):
+    return model.predict(
+        representations,
+    )
+
+
+@when(
+    "The subset of the result where the input was not None is considered",
+    target_fixture="subset",
+)
+def subset_without_none(predictions):
+    # remove None entries
+    return predictions[predictions.preprocessed_mol.notnull()]
+
+
+@then("the result should be a pandas DataFrame")
+def check_result(predictions):
+    assert isinstance(predictions, pd.DataFrame)

nerdd-module-0.2.4/nerdd_module/tests/representations.py

@@ -0,0 +1,72 @@
+import numpy as np
+from hypothesis import given as hgiven
+from hypothesis import seed, settings
+from hypothesis import strategies as st
+from hypothesis_rdkit import mols, smiles
+from pytest_bdd import given, parsers
+from rdkit.Chem import MolFromSmiles, MolToMolBlock, MolToSmiles
+
+
+@given(parsers.parse("a random seed set to {seed:d}"), target_fixture="random_seed")
+def random_seed(seed):
+    return seed
+
+
+@given(
+    parsers.parse("an input molecule specified by '{input}'"),
+    target_fixture="representations",
+)
+def representations_from_input(input):
+    return [input]
+
+
+@given(
+    parsers.parse("the representations of the molecules"),
+    target_fixture="representations",
+)
+def representations_from_molecules(molecules, input_type):
+    if input_type == "smiles":
+        converter = MolToSmiles
+    elif input_type == "mol_block":
+        converter = MolToMolBlock
+    elif input_type == "rdkit_mol":
+        converter = lambda mol: mol
+    else:
+        raise ValueError(f"Unknown input_type: {input_type}")
+
+    result = [converter(mol) if mol is not None else None for mol in molecules]
+
+    return result
+
+
+@given(
+    parsers.parse(
+        "a list of {num:d} random molecules, where {num_none:d} entries are None"
+    ),
+    target_fixture="molecules",
+)
+def molecules(num, num_none, random_seed):
+    result = None
+
+    # pytest-bdd and hypothesis don't play well together (yet)
+    # --> use this workaround to generate random molecules
+    @hgiven(st.lists(mols(), min_size=num, max_size=num, unique_by=MolToSmiles))
+    @settings(max_examples=1, deadline=None)
+    @seed(random_seed)
+    def generate(ms):
+        nonlocal result
+        result = ms
+
+    generate()
+
+    # replace random entries with None
+    indices = np.random.choice(num, num_none, replace=False)
+    for i in indices:
+        result[i] = None
+
+    return result
+
+
+@given(parsers.parse("the input type is '{input_type}'"), target_fixture="input_type")
+def input_type(input_type):
+    return input_type

{nerdd-module-0.2.1 → nerdd-module-0.2.4}/nerdd_module.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nerdd-module
-Version: 0.2.1
+Version: 0.2.4
 Summary: Base package to create NERDD modules
 Home-page: https://github.com/molinfo-vienna/nerdd-module.git
 Maintainer: Steffen Hirte

{nerdd-module-0.2.1 → nerdd-module-0.2.4}/nerdd_module.egg-info/SOURCES.txt

@@ -51,6 +51,10 @@ nerdd_module/preprocessing/pipeline.py
 nerdd_module/preprocessing/registry.py
 nerdd_module/preprocessing/remove_stereochemistry.py
 nerdd_module/preprocessing/step.py
+nerdd_module/tests/__init__.py
+nerdd_module/tests/checks.py
+nerdd_module/tests/predictions.py
+nerdd_module/tests/representations.py
 tests/__init__.py
 tests/conftest.py
 tests/test_atom_property_prediction.py

{nerdd-module-0.2.1 → nerdd-module-0.2.4}/setup.py

@@ -16,7 +16,7 @@ rdkit_requirement = ["rdkit>=2022.3.3"] if not rdkit_installed else []
 
 setup(
     name="nerdd-module",
-    version="0.2.1",
+    version="0.2.4",
     maintainer="Steffen Hirte",
     maintainer_email="steffen.hirte@univie.ac.at",
     packages=find_packages(),