nerdd-module 0.2.3__tar.gz → 0.2.5__tar.gz

{nerdd-module-0.2.3 → nerdd-module-0.2.5}/PKG-INFO

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

{nerdd-module-0.2.3 → nerdd-module-0.2.5}/nerdd_module/abstract_model.py

@@ -158,7 +158,7 @@ class AbstractModel(ABC):
             # check that mol_id contains only valid ids
             assert set(df_predictions.mol_id).issubset(
                 set(df_valid_subset.mol_id)
-            ), "The mol_id column must only contain valid ids!"
+            ), f"The mol_id column contains invalid ids: {set(df_predictions.mol_id).difference(set(df_valid_subset.mol_id))}."
             # use mol_id as index
             df_predictions.set_index("mol_id", drop=True, inplace=True)
         elif "mol" in df_predictions.columns:
@@ -166,7 +166,7 @@ class AbstractModel(ABC):
             names = df_predictions.mol.apply(lambda mol: int(mol.GetProp("_Name")))
             assert set(names).issubset(
                 set(df_preprocess.mol_id)
-            ), "The molecule names must only contain valid ids!"
+            ), f"The mol_id column contains invalid ids: {set(df_predictions.mol_id).difference(set(df_valid_subset.mol_id))}."
 
             # use mol_id as index
             df_predictions.set_index(

{nerdd-module-0.2.3 → nerdd-module-0.2.5}/nerdd_module/io/csv_writer.py

@@ -26,5 +26,5 @@ class CsvWriter(Writer):
         for entry in chain([first_entry], entry_iter):
             for key, value in entry.items():
                 if isinstance(value, Mol):
-                    entry[key] = MolToSmiles(value)
+                    entry[key] = MolToSmiles(value, canonical=False)
             writer.writerow(entry)

{nerdd-module-0.2.3 → nerdd-module-0.2.5}/nerdd_module/io/file_reader.py

@@ -8,24 +8,34 @@ from .reader_registry import register_reader
 __all__ = ["FileReader"]
 
 
-@register_reader
+@register_reader("data_dir")
 class FileReader(Reader):
-    def __init__(self, data_dir="."):
+    def __init__(self, data_dir=None):
         super().__init__()
-        self.data_dir = Path(data_dir)
+        self.data_dir = data_dir
+        if self.data_dir is not None:
+            self.data_dir = Path(self.data_dir)
 
     def read(self, filename, explore) -> Generator[MoleculeEntry, None, None]:
         assert isinstance(filename, str), "input must be a string"
 
+        # convert filename to path
         try:
             path = Path(filename)
-
-            if not path.is_absolute():
-                path = self.data_dir / path
         except:
             raise ValueError("input must be a valid path")
+        
+        # convert to absolute path
+        if not path.is_absolute():
+            if self.data_dir is not None:
+                path = self.data_dir / path
+            else:
+                path = Path(".") / path
+
+        # check that the file is within the data_dir
+        assert self.data_dir is None or self.data_dir in path.parents, "input must be a relative path"
 
-        assert self.data_dir in path.parents, "input must be a relative path"
+        # check that the file exists
         assert path.exists(), "input must be a valid file"
 
         with open(path, "rb") as f:

nerdd-module-0.2.5/nerdd_module/io/reader_registry.py

@@ -0,0 +1,59 @@
+from functools import lru_cache
+from typing import Dict, Generator, List, Tuple, Type
+
+from .reader import Reader
+
+__all__ = ["ReaderRegistry", "register_reader"]
+
+
+# lru_cache makes the registry a singleton
+@lru_cache(maxsize=1)
+class ReaderRegistry:
+    def __init__(self):
+        self._factories : List[Tuple[Type[Reader], Tuple[str, ...], Dict[str, str]]] = []
+        self._config = {}
+
+    def _create_reader(self, ReaderClass: Type[Reader], *args, **kwargs) -> Reader:
+        # translate all args
+        args = [self._config.get(arg, None) for arg in args]
+        # translate all kwargs
+        kwargs = {k: self._config.get(v, None) for k, v in kwargs.items() if v in self._config}
+
+        return ReaderClass(*args, **kwargs)
+
+    def register(self, ReaderClass: Type[Reader], *args :str , **kwargs:str):
+        assert issubclass(ReaderClass, Reader)
+        assert all([isinstance(arg, str) for arg in args])
+        assert all([isinstance(k, str) and isinstance(v, str) for k, v in kwargs.items()])
+        self._factories.append((ReaderClass, args, kwargs))
+
+    def readers(self) -> Generator[Reader, None, None]:
+        for reader, args, kwargs in self._factories:
+            yield self._create_reader(reader, *args, **kwargs)
+
+    def __iter__(self):
+        return iter(self.readers())
+
+
+def register_reader(*args, **kwargs):
+    def wrapper(cls, *args, **kwargs):
+        ReaderRegistry().register(cls, *args, **kwargs)
+        return cls
+
+    # Case 1: first argument is a class 
+    # --> decorator is used without arguments 
+    # @register_reader
+    # class F:
+    #     ...
+    if len(args) > 0 and isinstance(args[0], type):
+        return wrapper(args[0], *args[1:], **kwargs)
+    
+    # Case 2: first argument is a not a class
+    # --> decorator is used with arguments
+    # @register_reader("blah")
+    # class F:
+    #     ...
+    def inner(cls):
+        assert isinstance(cls, type), "Decorator must be used with a class"
+        return wrapper(cls, *args, **kwargs)
+    return inner

{nerdd-module-0.2.3 → nerdd-module-0.2.5}/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.3 → nerdd-module-0.2.5}/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.5/nerdd_module/tests/__init__.py

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

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

@@ -0,0 +1,174 @@
+import json
+from ast import literal_eval
+
+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(subset, column_name, expected_value):
+    if len(subset) == 0:
+        return
+
+    value = subset[column_name].iloc[0]
+
+    # expected value is always provided as string
+    # try to convert to float if possible
+    try:
+        expected_value = literal_eval(expected_value)
+    except:
+        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"
+
+
+@then(parsers.parse("when '{condition_column_name}' is '{condition_value}' " 
+                    "the value in column '{column_name}' should be '{expected_value}'"))
+def check_conditional_column_value(subset, condition_column_name, condition_value, column_name, expected_value):
+    # expected value is always provided as string
+    # try to convert to float if possible
+    try:
+        expected_value = literal_eval(expected_value)
+    except:
+        pass
+
+    # same for condition value
+    try:
+        condition_value = literal_eval(condition_value)
+    except:
+        pass
+
+    # condition value can be (none) to indicate None
+    if condition_value == "(none)":
+        subset = subset[pd.isnull(subset[condition_column_name])]
+    else:
+        subset = subset[subset[condition_column_name] == condition_value]
+
+    value = subset[column_name]
+    assert len(value) > 0, f"No rows found for condition {condition_column_name} == {condition_value}"
+
+    # expected value can be (none) to indicate None
+    if expected_value == "(none)":
+        # if expected_value is the magic string "(none)", we expect None
+        assert pd.isnull(value).all(), 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).all()
+        ), f"Column {column_name} is assigned to {value} != {expected_value}"

nerdd-module-0.2.5/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.3/tests/steps/molecules.py → nerdd-module-0.2.5/nerdd_module/tests/representations.py

@@ -1,10 +1,42 @@
 import numpy as np
 from hypothesis import given as hgiven
-from hypothesis import settings
+from hypothesis import seed, settings
 from hypothesis import strategies as st
-from hypothesis_rdkit import mols
+from hypothesis_rdkit import mols, smiles
 from pytest_bdd import given, parsers
-from rdkit.Chem import MolToInchi, MolToMolBlock, MolToSmiles
+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(
@@ -13,15 +45,17 @@ from rdkit.Chem import MolToInchi, MolToMolBlock, MolToSmiles
     ),
     target_fixture="molecules",
 )
-def molecules(num, num_none):
+def molecules(num, num_none, random_seed=0):
     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)
-    def generate(mols):
+    @seed(random_seed)
+    def generate(ms):
         nonlocal result
-        # ensure that all molecules are valid
-        result = mols
+        result = ms
 
     generate()
 
@@ -33,22 +67,6 @@ def molecules(num, num_none):
     return result
 
 
-@given(
-    parsers.parse("the representations of the molecules as {input_type}"),
-    target_fixture="representations",
-)
-def representations(molecules, input_type):
-    if input_type == "smiles":
-        converter = MolToSmiles
-    elif input_type == "mol_block":
-        converter = MolToMolBlock
-    elif input_type == "inchi":
-        converter = MolToInchi
-    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("the input type is '{input_type}'"), target_fixture="input_type")
+def input_type(input_type):
+    return input_type

{nerdd-module-0.2.3 → nerdd-module-0.2.5}/nerdd_module.egg-info/PKG-INFO

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

{nerdd-module-0.2.3 → nerdd-module-0.2.5}/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
@@ -64,6 +68,5 @@ tests/models/MolWeightModelWithExplicitMols.py
 tests/models/__init__.py
 tests/steps/__init__.py
 tests/steps/checks.py
-tests/steps/molecules.py
 tests/steps/predictors.py
 tests/steps/preprocessing.py

{nerdd-module-0.2.3 → nerdd-module-0.2.5}/setup.py

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

{nerdd-module-0.2.3 → nerdd-module-0.2.5}/tests/conftest.py

@@ -4,4 +4,4 @@
 # from .steps import *
 #
 # instead, we use pytest_plugins to make this work
-pytest_plugins = ["tests.steps"]
+pytest_plugins = ["tests.steps", "nerdd_module.tests"]

{nerdd-module-0.2.3 → nerdd-module-0.2.5}/tests/steps/__init__.py

@@ -1,4 +1,3 @@
 from .checks import *
-from .molecules import *
 from .predictors import *
 from .preprocessing import *

nerdd-module-0.2.3/nerdd_module/io/reader_registry.py

@@ -1,30 +0,0 @@
-from functools import lru_cache
-from typing import Generator, Type
-
-from .reader import Reader
-
-__all__ = ["ReaderRegistry", "register_reader"]
-
-
-# lru_cache makes the registry a singleton
-@lru_cache(maxsize=1)
-class ReaderRegistry:
-    def __init__(self):
-        self._factories = []
-
-    def register(self, ReaderClass: Type[Reader], *args, **kwargs):
-        assert issubclass(ReaderClass, Reader)
-        self._factories.append(lambda: ReaderClass(*args, **kwargs))
-
-    def readers(self) -> Generator[Reader, None, None]:
-        for reader in self._factories:
-            yield reader()
-
-    def __iter__(self):
-        return iter(map(lambda f: f(), self._factories))
-
-
-def register_reader(clazz, *args, **kwargs):
-    # TODO: implement both decorator modes
-    ReaderRegistry().register(clazz, *args, **kwargs)
-    return clazz