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

{nerdd-module-0.2.5 → nerdd_module-0.2.6}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: nerdd-module
-Version: 0.2.5
+Version: 0.2.6
 Summary: Base package to create NERDD modules
-Home-page: https://github.com/molinfo-vienna/nerdd-module.git
+Home-page: https://github.com/molinfo-vienna/nerdd-module
 Maintainer: Steffen Hirte
 Maintainer-email: steffen.hirte@univie.ac.at
 License: BSD 3-Clause License
@@ -33,8 +33,11 @@ Requires-Dist: stringcase>=1.2.0
 Requires-Dist: decorator>=5.1.1
 Requires-Dist: importlib-resources>=5; python_version < "3.10"
 Requires-Dist: importlib-metadata>=4.6; python_version < "3.10"
-Requires-Dist: chembl_structure_pipeline>=1.0.0
 Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Provides-Extra: csp
+Requires-Dist: chembl_structure_pipeline>=1.0.0; extra == "csp"
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-sugar; extra == "test"

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

@@ -1,13 +1,13 @@
 from abc import ABC, abstractmethod
-from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple, Union
+from typing import Callable, Iterable, List, Tuple, Union
 
 import pandas as pd
-from rdkit.Chem import Mol, MolToSmiles
+from rdkit.Chem import Mol
 
 from .config import AutoConfiguration, Configuration
-from .io import DepthFirstExplorer, MoleculeEntry
+from .input import DepthFirstExplorer, MoleculeEntry
 from .preprocessing import Pipeline, Step, registry
-from .problem import Problem
+from .problem import Problem, UnknownProblem
 
 __all__ = ["AbstractModel"]
 
@@ -156,17 +156,20 @@ class AbstractModel(ABC):
         #    (and we assume that the order of the molecules is the same)
         if "mol_id" in df_predictions.columns:
             # check that mol_id contains only valid ids
-            assert set(df_predictions.mol_id).issubset(
-                set(df_valid_subset.mol_id)
-            ), f"The mol_id column contains invalid ids: {set(df_predictions.mol_id).difference(set(df_valid_subset.mol_id))}."
+            assert set(df_predictions.mol_id).issubset(set(df_valid_subset.mol_id)), (
+                f"The mol_id column contains invalid ids: "
+                f"{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:
             # check that molecule names contain only valid ids
             names = df_predictions.mol.apply(lambda mol: int(mol.GetProp("_Name")))
-            assert set(names).issubset(
-                set(df_preprocess.mol_id)
-            ), f"The mol_id column contains invalid ids: {set(df_predictions.mol_id).difference(set(df_valid_subset.mol_id))}."
+            assert set(names).issubset(set(df_preprocess.mol_id)), (
+                f"The mol_id column contains invalid ids: "
+                f"{set(df_predictions.mol_id).difference(set(df_valid_subset.mol_id))}."
+            )
 
             # use mol_id as index
             df_predictions.set_index(
@@ -184,6 +187,8 @@ class AbstractModel(ABC):
                 df_valid_subset.index.astype("int64"), inplace=True
             )
 
+        # TODO: check derivative_id or atom_id
+
         # add column that indicates whether a molecule was missing
         missing_mol_ids = set(df_preprocess.mol_id).difference(df_predictions.index)
         df_preprocess["missing"] = df_preprocess.mol_id.isin(missing_mol_ids)
@@ -212,7 +217,7 @@ class AbstractModel(ABC):
         else:
             df_result["errors"] = df_result.preprocessing_errors
         df_result["errors"] = df_result.errors + df_result.missing.map(
-            lambda x: ["!1"] if x else []
+            lambda x: [UnknownProblem()] if x else []
         )
         df_result.drop(columns=["missing", "preprocessing_errors"], inplace=True)
 

{nerdd-module-0.2.5 → nerdd_module-0.2.6}/nerdd_module/cli.py

@@ -4,7 +4,7 @@ import sys
 
 import rich_click as click
 from decorator import decorator
-from nerdd_module.io import WriterRegistry
+from nerdd_module.output import WriterRegistry
 from stringcase import spinalcase
 
 __all__ = ["auto_cli"]

nerdd_module-0.2.6/nerdd_module/config/default_configuration.py

@@ -0,0 +1,41 @@
+from stringcase import snakecase
+
+from ..polyfills import version
+from .configuration import Configuration
+
+__all__ = ["DefaultConfiguration"]
+
+
+class DefaultConfiguration(Configuration):
+    def __init__(self, nerdd_module):
+        super().__init__()
+
+        # generate a name from the module name
+        class_name = nerdd_module.__class__.__name__
+        if class_name.endswith("Model"):
+            # remove the "Model" suffix
+            # e.g. SkinDoctorModel -> SkinDoctor
+            class_name = class_name[: -len("Model")]
+
+        # convert the class name to snake case
+        # e.g. SkinDoctor -> skin_doctor
+        name = snakecase(class_name)
+
+        # append version to the configuration
+        try:
+            module = nerdd_module.__module__
+            root_module = module.split(".", 1)[0]
+            version_ = version(root_module)
+        except ModuleNotFoundError:
+            pass
+
+        self.config = dict(
+            name=name,
+            version=version_,
+            task="molecular_property_prediction",
+            job_parameters=[],
+            result_properties=[],
+        )
+
+    def _get_dict(self):
+        return self.config

{nerdd-module-0.2.5 → nerdd_module-0.2.6}/nerdd_module/config/merged_configuration.py

@@ -9,6 +9,8 @@ class MergedConfiguration(Configuration):
 
         self.config = dict()
 
+        # merge all configurations starting from the first one
+        # --> last configuration has the highest priority
         for c in configs:
             self.config.update(c._get_dict())
 

{nerdd-module-0.2.5/nerdd_module/io → nerdd_module-0.2.6/nerdd_module/input}/__init__.py

@@ -1,4 +1,3 @@
-from .csv_writer import *
 from .depth_first_explorer import *
 from .file_reader import *
 from .gzip_reader import *
@@ -8,10 +7,7 @@ from .mol_reader import *
 from .reader import *
 from .reader_registry import *
 from .sdf_reader import *
-from .sdf_writer import *
 from .smiles_reader import *
 from .string_reader import *
 from .tar_reader import *
-from .writer import *
-from .writer_registry import *
 from .zip_reader import *

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

@@ -1,6 +1,5 @@
-import os
 from pathlib import Path
-from typing import Generator
+from typing import Generator, Tuple
 
 from .reader import MoleculeEntry, Reader
 from .reader_registry import register_reader
@@ -24,7 +23,7 @@ class FileReader(Reader):
             path = Path(filename)
         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:
@@ -33,7 +32,9 @@ class FileReader(Reader):
                 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 is None or 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"
@@ -41,7 +42,7 @@ class FileReader(Reader):
         with open(path, "rb") as f:
             for entry in explore(f):
                 if len(entry.source) == 1 and entry.source[0] == "raw_input":
-                    source = tuple()
+                    source: Tuple[str, ...] = tuple()
                 else:
                     source = entry.source
                 yield entry._replace(source=tuple([filename, *source]))

{nerdd-module-0.2.5/nerdd_module/io → nerdd_module-0.2.6/nerdd_module/input}/reader_registry.py

@@ -10,21 +10,25 @@ __all__ = ["ReaderRegistry", "register_reader"]
 @lru_cache(maxsize=1)
 class ReaderRegistry:
     def __init__(self):
-        self._factories : List[Tuple[Type[Reader], Tuple[str, ...], Dict[str, str]]] = []
+        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]
+        args = tuple(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}
+        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):
+    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()])
+        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]:
@@ -40,14 +44,14 @@ def register_reader(*args, **kwargs):
         ReaderRegistry().register(cls, *args, **kwargs)
         return cls
 
-    # Case 1: first argument is a class 
-    # --> decorator is used without arguments 
+    # 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")
@@ -56,4 +60,5 @@ def register_reader(*args, **kwargs):
     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.6/nerdd_module/output/__init__.py

@@ -0,0 +1 @@
+from .writer_registry import *

{nerdd-module-0.2.5 → nerdd_module-0.2.6}/nerdd_module/polyfills/__init__.py

@@ -1,2 +1,3 @@
 from .files import *
 from .get_entry_points import *
+from .version import *

{nerdd-module-0.2.5/nerdd_module → nerdd_module-0.2.6/nerdd_module/polyfills}/version.py

@@ -1,10 +1,8 @@
 import sys
 
+__all__ = ["version"]
+
 if sys.version_info < (3, 10):
     from importlib_metadata import version
 else:
     from importlib.metadata import version
-
-__all__ = ["__version__"]
-
-__version__ = version(__package__)

{nerdd-module-0.2.5 → nerdd_module-0.2.6}/nerdd_module/preprocessing/__init__.py

@@ -4,6 +4,7 @@ from .empty_pipeline import *
 from .filter_by_element import *
 from .filter_by_weight import *
 from .pipeline import *
-from ..problem import *
 from .registry import *
+from .remove_stereochemistry import *
+from .sanitize import *
 from .step import *

{nerdd-module-0.2.5 → nerdd_module-0.2.6}/nerdd_module/preprocessing/check_valid_smiles.py

@@ -1,8 +1,8 @@
-from typing import List, Tuple
+from typing import List, Optional, Tuple
 
 from rdkit.Chem import Mol, MolFromSmiles, MolToSmiles
 
-from ..problem import Problem
+from ..problem import InvalidSmiles, Problem
 from .step import Step
 
 __all__ = ["CheckValidSmiles"]
@@ -14,15 +14,13 @@ class CheckValidSmiles(Step):
     def __init__(self):
         super().__init__()
 
-    def _run(self, mol: Mol) -> Tuple[Mol, List[Problem]]:
+    def _run(self, mol: Mol) -> Tuple[Optional[Mol], List[Problem]]:
         errors = []
 
         smi = MolToSmiles(mol, True)
         check_mol = MolFromSmiles(smi)
         if check_mol is None:
-            errors.append(
-                Problem("invalid_smiles", "Cannot convert molecule to SMILES")
-            )
+            errors.append(InvalidSmiles())
             mol = None
 
         return mol, errors

{nerdd-module-0.2.5 → nerdd_module-0.2.6}/nerdd_module/preprocessing/chembl_structure_pipeline.py

@@ -1,5 +1,5 @@
 import warnings
-from typing import List, Tuple
+from typing import List, Optional, Tuple
 
 from rdkit.Chem import Mol
 from rdkit.rdBase import BlockLogs
@@ -41,7 +41,7 @@ class StandardizeWithCsp(Step):
         if import_error is not None:
             raise import_error
 
-    def _run(self, mol: Mol) -> Tuple[Mol, List[Problem]]:
+    def _run(self, mol: Mol) -> Tuple[Optional[Mol], List[Problem]]:
         errors = []
 
         # chembl structure pipeline cannot handle molecules with 3D coordinates
@@ -65,7 +65,7 @@ class GetParentMol(Step):
         if import_error is not None:
             raise import_error
 
-    def _run(self, mol: Mol) -> Tuple[Mol, List[Problem]]:
+    def _run(self, mol: Mol) -> Tuple[Optional[Mol], List[Problem]]:
         errors = []
 
         # chembl structure pipeline cannot handle molecules with 3D coordinates

{nerdd-module-0.2.5 → nerdd_module-0.2.6}/nerdd_module/preprocessing/filter_by_element.py

@@ -1,4 +1,4 @@
-from typing import Iterable, List, Tuple
+from typing import Iterable, List, Optional, Tuple
 
 from rdkit.Chem import Mol
 
@@ -14,7 +14,7 @@ class FilterByElement(Step):
         self.allowed_elements = set(allowed_elements)
         self.remove_invalid_molecules = remove_invalid_molecules
 
-    def _run(self, mol: Mol) -> Tuple[Mol, List[Problem]]:
+    def _run(self, mol: Mol) -> Tuple[Optional[Mol], List[Problem]]:
         errors = []
         result_mol = mol
 

{nerdd-module-0.2.5 → nerdd_module-0.2.6}/nerdd_module/preprocessing/filter_by_weight.py

@@ -1,4 +1,4 @@
-from typing import List, Tuple
+from typing import List, Optional, Tuple
 
 from rdkit.Chem import Mol
 from rdkit.Chem.Descriptors import MolWt
@@ -14,7 +14,7 @@ class FilterByWeight(Step):
         self.max_weight = max_weight
         self.remove_invalid_molecules = remove_invalid_molecules
 
-    def _run(self, mol: Mol) -> Tuple[Mol, List[Problem]]:
+    def _run(self, mol: Mol) -> Tuple[Optional[Mol], List[Problem]]:
         errors = []
 
         weight = MolWt(mol)
@@ -25,9 +25,11 @@ class FilterByWeight(Step):
                 result_mol = mol
             errors.append(
                 Problem(
-                    "invalid_weight",
-                    f"Molecular weight {weight:.2f} out of range "
-                    f"[{self.min_weight}, {self.max_weight}]",
+                    type="invalid_weight",
+                    message=(
+                        f"Molecular weight {weight:.2f} out of range "
+                        f"[{self.min_weight}, {self.max_weight}]"
+                    ),
                 )
             )
         else:

nerdd_module-0.2.6/nerdd_module/preprocessing/sanitize.py

@@ -0,0 +1,18 @@
+from rdkit.Chem import SanitizeMol
+
+from .step import Step
+
+__all__ = ["Sanitize"]
+
+
+class Sanitize(Step):
+    def __init__(self):
+        super().__init__()
+
+    def _run(self, mol):
+        errors = []
+
+        # sanitize molecule
+        SanitizeMol(mol)
+
+        return mol, errors

{nerdd-module-0.2.5 → nerdd_module-0.2.6}/nerdd_module/preprocessing/step.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import List, Tuple
+from typing import List, Optional, Tuple
 
 from rdkit.Chem import Mol
 
@@ -12,14 +12,14 @@ class Step(ABC):
     def __init__(self):
         pass
 
-    def run(self, mol: Mol) -> Tuple[Mol, List[Problem]]:
+    def run(self, mol: Mol) -> Tuple[Optional[Mol], List[Problem]]:
         """
         Runs the step on a molecule.
         """
         return self._run(mol)
 
     @abstractmethod
-    def _run(self, mol: Mol) -> Tuple[Mol, List[Problem]]:
+    def _run(self, mol: Mol) -> Tuple[Optional[Mol], List[Problem]]:
         """
         Runs the step on a molecule.
         """

nerdd_module-0.2.6/nerdd_module/problem.py

@@ -0,0 +1,13 @@
+from typing import NamedTuple
+
+__all__ = ["Problem", "InvalidSmiles", "UnknownProblem"]
+
+
+class Problem(NamedTuple):
+    type: str
+    message: str
+
+
+InvalidSmiles = lambda: Problem(type="invalid_smiles", message="Invalid SMILES string")
+
+UnknownProblem = lambda: Problem(type="unknown", message="Unknown error occurred")

{nerdd-module-0.2.5 → nerdd_module-0.2.6}/nerdd_module/tests/checks.py

@@ -138,9 +138,15 @@ def check_column_length(subset, column_name, 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):
+@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:
@@ -161,14 +167,18 @@ def check_conditional_column_value(subset, condition_column_name, condition_valu
         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}"
+    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"
+        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}"
+            value == expected_value
+        ).all(), f"Column {column_name} is assigned to {value} != {expected_value}"

nerdd_module-0.2.6/nerdd_module/version.py

@@ -0,0 +1,5 @@
+from .polyfills import version
+
+__all__ = ["__version__"]
+
+__version__ = version(__package__)

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

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: nerdd-module
-Version: 0.2.5
+Version: 0.2.6
 Summary: Base package to create NERDD modules
-Home-page: https://github.com/molinfo-vienna/nerdd-module.git
+Home-page: https://github.com/molinfo-vienna/nerdd-module
 Maintainer: Steffen Hirte
 Maintainer-email: steffen.hirte@univie.ac.at
 License: BSD 3-Clause License
@@ -33,8 +33,11 @@ Requires-Dist: stringcase>=1.2.0
 Requires-Dist: decorator>=5.1.1
 Requires-Dist: importlib-resources>=5; python_version < "3.10"
 Requires-Dist: importlib-metadata>=4.6; python_version < "3.10"
-Requires-Dist: chembl_structure_pipeline>=1.0.0
 Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Provides-Extra: csp
+Requires-Dist: chembl_structure_pipeline>=1.0.0; extra == "csp"
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-sugar; extra == "test"

{nerdd-module-0.2.5 → nerdd_module-0.2.6}/nerdd_module.egg-info/SOURCES.txt

@@ -19,28 +19,30 @@ nerdd_module/config/dict_configuration.py
 nerdd_module/config/merged_configuration.py
 nerdd_module/config/package_configuration.py
 nerdd_module/config/yaml_configuration.py
-nerdd_module/io/__init__.py
-nerdd_module/io/csv_writer.py
-nerdd_module/io/depth_first_explorer.py
-nerdd_module/io/explorer.py
-nerdd_module/io/file_reader.py
-nerdd_module/io/gzip_reader.py
-nerdd_module/io/inchi_reader.py
-nerdd_module/io/list_reader.py
-nerdd_module/io/mol_reader.py
-nerdd_module/io/reader.py
-nerdd_module/io/reader_registry.py
-nerdd_module/io/sdf_reader.py
-nerdd_module/io/sdf_writer.py
-nerdd_module/io/smiles_reader.py
-nerdd_module/io/string_reader.py
-nerdd_module/io/tar_reader.py
-nerdd_module/io/writer.py
-nerdd_module/io/writer_registry.py
-nerdd_module/io/zip_reader.py
+nerdd_module/input/__init__.py
+nerdd_module/input/depth_first_explorer.py
+nerdd_module/input/explorer.py
+nerdd_module/input/file_reader.py
+nerdd_module/input/gzip_reader.py
+nerdd_module/input/inchi_reader.py
+nerdd_module/input/list_reader.py
+nerdd_module/input/mol_reader.py
+nerdd_module/input/reader.py
+nerdd_module/input/reader_registry.py
+nerdd_module/input/sdf_reader.py
+nerdd_module/input/smiles_reader.py
+nerdd_module/input/string_reader.py
+nerdd_module/input/tar_reader.py
+nerdd_module/input/zip_reader.py
+nerdd_module/output/__init__.py
+nerdd_module/output/csv_writer.py
+nerdd_module/output/sdf_writer.py
+nerdd_module/output/writer.py
+nerdd_module/output/writer_registry.py
 nerdd_module/polyfills/__init__.py
 nerdd_module/polyfills/files.py
 nerdd_module/polyfills/get_entry_points.py
+nerdd_module/polyfills/version.py
 nerdd_module/preprocessing/__init__.py
 nerdd_module/preprocessing/check_valid_smiles.py
 nerdd_module/preprocessing/chembl_structure_pipeline.py
@@ -50,6 +52,7 @@ nerdd_module/preprocessing/filter_by_weight.py
 nerdd_module/preprocessing/pipeline.py
 nerdd_module/preprocessing/registry.py
 nerdd_module/preprocessing/remove_stereochemistry.py
+nerdd_module/preprocessing/sanitize.py
 nerdd_module/preprocessing/step.py
 nerdd_module/tests/__init__.py
 nerdd_module/tests/checks.py

{nerdd-module-0.2.5 → nerdd_module-0.2.6}/nerdd_module.egg-info/requires.txt

@@ -5,13 +5,17 @@ filetype~=1.2.0
 rich-click>=1.7.1
 stringcase>=1.2.0
 decorator>=5.1.1
-chembl_structure_pipeline>=1.0.0
 
 [:python_version < "3.10"]
 importlib-resources>=5
 importlib-metadata>=4.6
 
+[csp]
+chembl_structure_pipeline>=1.0.0
+
 [dev]
+black
+isort
 
 [docs]
 mkdocs

{nerdd-module-0.2.5 → nerdd_module-0.2.6}/setup.py

@@ -16,11 +16,11 @@ rdkit_requirement = ["rdkit>=2022.3.3"] if not rdkit_installed else []
 
 setup(
     name="nerdd-module",
-    version="0.2.5",
+    version="0.2.6",
     maintainer="Steffen Hirte",
     maintainer_email="steffen.hirte@univie.ac.at",
     packages=find_packages(),
-    url="https://github.com/molinfo-vienna/nerdd-module.git",
+    url="https://github.com/molinfo-vienna/nerdd-module",
     description="Base package to create NERDD modules",
     license="BSD 3-Clause License",
     long_description=open("README.md").read(),
@@ -36,12 +36,19 @@ setup(
         # install importlib-resources and importlib-metadata for old Python versions
         "importlib-resources>=5; python_version<'3.10'",
         "importlib-metadata>=4.6; python_version<'3.10'",
-        # note: version 1.0.0 of chembl_structure_pipeline is not available on pypi,
-        # but it could potentially be installed from github
-        "chembl_structure_pipeline>=1.0.0",
     ],
     extras_require={
-        "dev": [],
+        "dev": [
+            "black",
+            "isort",
+        ],
+        "csp": [
+            # note: version 1.0.0 of chembl_structure_pipeline is not available on pypi
+            # BUT: maybe it was already installed in the current environment manually
+            # other note: chembl_structure_pipeline *always* installs a recent version
+            #   of rdkit
+            "chembl_structure_pipeline>=1.0.0"
+        ],
         "test": [
             "pytest",
             "pytest-sugar",

{nerdd-module-0.2.5 → nerdd_module-0.2.6}/tests/models/MolWeightModel.py

@@ -1,20 +1,17 @@
 import pandas as pd
 from nerdd_module import AbstractModel
+from nerdd_module.preprocessing import Sanitize
 from rdkit.Chem.Descriptors import MolWt
 
 __all__ = ["MolWeightModel"]
 
 
 class MolWeightModel(AbstractModel):
-    def __init__(self, preprocessing_pipeline="chembl_structure_pipeline", **kwargs):
+    def __init__(self, preprocessing_pipeline=[Sanitize()], **kwargs):
         super().__init__(preprocessing_pipeline, **kwargs)
 
     def _predict_mols(self, mols, multiplier):
-        return pd.DataFrame(
-            {
-                "weight": [MolWt(m) * multiplier for m in mols],
-            }
-        )
+        return pd.DataFrame({"weight": [MolWt(m) * multiplier for m in mols]})
 
     def _get_config(self):
         return {

{nerdd-module-0.2.5 → nerdd_module-0.2.6}/tests/models/MolWeightModelWithExplicitMolIds.py

@@ -1,12 +1,13 @@
 import pandas as pd
 from nerdd_module import AbstractModel
+from nerdd_module.preprocessing import Sanitize
 from rdkit.Chem.Descriptors import MolWt
 
 __all__ = ["MolWeightModelWithExplicitMolIds"]
 
 
 class MolWeightModelWithExplicitMolIds(AbstractModel):
-    def __init__(self, preprocessing_pipeline="chembl_structure_pipeline", **kwargs):
+    def __init__(self, preprocessing_pipeline=[Sanitize()], **kwargs):
         super().__init__(preprocessing_pipeline, **kwargs)
 
     def _predict_mols(self, mols, multiplier):

{nerdd-module-0.2.5 → nerdd_module-0.2.6}/tests/models/MolWeightModelWithExplicitMols.py

@@ -1,20 +1,18 @@
 import pandas as pd
 from nerdd_module import AbstractModel
+from nerdd_module.preprocessing import Sanitize
 from rdkit.Chem.Descriptors import MolWt
 
 __all__ = ["MolWeightModelWithExplicitMols"]
 
 
 class MolWeightModelWithExplicitMols(AbstractModel):
-    def __init__(self, preprocessing_pipeline="chembl_structure_pipeline", **kwargs):
+    def __init__(self, preprocessing_pipeline=[Sanitize()], **kwargs):
         super().__init__(preprocessing_pipeline, **kwargs)
 
     def _predict_mols(self, mols, multiplier):
         return pd.DataFrame(
-            {
-                "mol": mols,
-                "weight": [MolWt(m) * multiplier for m in mols],
-            }
+            {"mol": mols, "weight": [MolWt(m) * multiplier for m in mols]}
         )
 
     def _get_config(self):

nerdd-module-0.2.5/nerdd_module/config/default_configuration.py

@@ -1,17 +0,0 @@
-from .configuration import Configuration
-
-__all__ = ["DefaultConfiguration"]
-
-
-class DefaultConfiguration(Configuration):
-    def __init__(self, nerdd_module):
-        super().__init__()
-
-        self.config = dict(
-            task="molecular_property_prediction",
-            job_parameters=[],
-            result_properties=[],
-        )
-
-    def _get_dict(self):
-        return self.config

nerdd-module-0.2.5/nerdd_module/problem.py

@@ -1,8 +0,0 @@
-from typing import NamedTuple
-
-__all__ = ["Problem"]
-
-
-class Problem(NamedTuple):
-    type: str
-    message: str