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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nerdd-module
-Version: 0.2.4
+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.4 → 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.4 → 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.4 → 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.4 → nerdd-module-0.2.5}/nerdd_module/tests/checks.py

@@ -1,4 +1,5 @@
 import json
+from ast import literal_eval
 
 import numpy as np
 import pandas as pd
@@ -39,14 +40,17 @@ def check_column_range(subset, column_name, low, high):
 
 
 @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]
+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 = float(expected_value)
-    except ValueError:
+        expected_value = literal_eval(expected_value)
+    except:
         pass
 
     if expected_value == "(none)":
@@ -132,3 +136,39 @@ def check_column_length(subset, column_name, 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.4 → nerdd-module-0.2.5}/nerdd_module/tests/representations.py

@@ -45,7 +45,7 @@ def representations_from_molecules(molecules, input_type):
     ),
     target_fixture="molecules",
 )
-def molecules(num, num_none, random_seed):
+def molecules(num, num_none, random_seed=0):
     result = None
 
     # pytest-bdd and hypothesis don't play well together (yet)

{nerdd-module-0.2.4 → 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.4
+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.4 → nerdd-module-0.2.5}/nerdd_module.egg-info/SOURCES.txt

@@ -68,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.4 → 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.4",
+    version="0.2.5",
     maintainer="Steffen Hirte",
     maintainer_email="steffen.hirte@univie.ac.at",
     packages=find_packages(),

{nerdd-module-0.2.4 → 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.4 → 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.4/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

nerdd-module-0.2.4/tests/steps/molecules.py

@@ -1,54 +0,0 @@
-import numpy as np
-from hypothesis import given as hgiven
-from hypothesis import settings
-from hypothesis import strategies as st
-from hypothesis_rdkit import mols
-from pytest_bdd import given, parsers
-from rdkit.Chem import MolToInchi, MolToMolBlock, MolToSmiles
-
-
-@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):
-    result = None
-
-    @hgiven(st.lists(mols(), min_size=num, max_size=num, unique_by=MolToSmiles))
-    @settings(max_examples=1, deadline=None)
-    def generate(mols):
-        nonlocal result
-        # ensure that all molecules are valid
-        result = mols
-
-    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 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