nerdd-module 0.3.28__tar.gz → 0.3.30__tar.gz

{nerdd_module-0.3.28 → nerdd_module-0.3.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nerdd-module
-Version: 0.3.28
+Version: 0.3.30
 Summary: Base package to create NERDD modules
 Author-email: Steffen Hirte <steffen.hirte@univie.ac.at>
 Maintainer-email: Steffen Hirte <steffen.hirte@univie.ac.at>

{nerdd_module-0.3.28 → nerdd_module-0.3.30}/nerdd_module/cli.py

@@ -67,8 +67,8 @@ def auto_cli(f: Callable[..., Model], *args: Any, **kwargs: Any) -> None:
 
     # compose footer with examples
     examples = []
-    if hasattr(model, "get_config"):
-        example_smiles = model.get_config().example_smiles
+    if hasattr(model, "config"):
+        example_smiles = model.config.example_smiles
         if example_smiles is not None:
             examples.append(example_smiles)
 

{nerdd_module-0.3.28 → nerdd_module-0.3.30}/nerdd_module/model/enforce_schema_step.py

@@ -1,7 +1,7 @@
 import logging
 from typing import Iterator
 
-from ..config import Configuration
+from ..config import Module
 from ..steps import Step
 
 __all__ = ["EnforceSchemaStep"]
@@ -10,11 +10,9 @@ logger = logging.getLogger(__name__)
 
 
 class EnforceSchemaStep(Step):
-    def __init__(self, config: Configuration, output_format: str) -> None:
+    def __init__(self, config: Module, output_format: str) -> None:
         super().__init__()
-        self._property_names = [
-            p.name for p in config.get_dict().get_visible_properties(output_format)
-        ]
+        self._property_names = [p.name for p in config.get_visible_properties(output_format)]
 
         # check that properties are unique
         if len(self._property_names) != len(set(self._property_names)):
@@ -22,7 +20,7 @@ class EnforceSchemaStep(Step):
                 x for x in self._property_names if self._property_names.count(x) > 1
             }
             logger.warning(
-                f"Duplicate properties in result_properties: " f"{', '.join(duplicate_properties)}"
+                f"Duplicate properties in result_properties: {', '.join(duplicate_properties)}"
             )
 
     def _run(self, source: Iterator[dict]) -> Iterator[dict]:

{nerdd_module-0.3.28 → nerdd_module-0.3.30}/nerdd_module/model/simple_model.py

@@ -1,4 +1,5 @@
 from abc import abstractmethod
+from functools import cached_property
 from typing import Any, Iterable, List, Optional, Tuple, Union
 
 from rdkit.Chem import Mol
@@ -61,8 +62,8 @@ class SimpleModel(Model):
     def _get_postprocessing_steps(self, output_format: Optional[str], **kwargs: Any) -> List[Step]:
         output_format = output_format or "pandas"
         return [
-            EnforceSchemaStep(self._get_config(), output_format),
-            ConvertRepresentationsStep(self.get_config(), output_format, **kwargs),
+            EnforceSchemaStep(self.config, output_format),
+            ConvertRepresentationsStep(self.config, output_format, **kwargs),
             WriteOutputStep(output_format, **kwargs),
         ]
 
@@ -187,23 +188,24 @@ class SimpleModel(Model):
 
         return MergedConfiguration(*configs)
 
-    def get_config(self) -> Module:
+    @cached_property
+    def config(self) -> Module:
         return self._get_config().get_dict()
 
     def _get_batch_size(self) -> int:
         default = super()._get_batch_size()
-        return self.get_config().batch_size or default
+        return self.config.batch_size or default
 
     def _get_name(self) -> str:
         default = super()._get_name()
-        return self.get_config().name or default
+        return self.config.name or default
 
     def _get_description(self) -> str:
         default = super()._get_description()
-        return self.get_config().description or default
+        return self.config.description or default
 
     def _get_job_parameters(self) -> List[JobParameter]:
-        return super()._get_job_parameters() + self.get_config().job_parameters
+        return super()._get_job_parameters() + self.config.job_parameters
 
 
 class CustomPreprocessingStep(PreprocessingStep):

nerdd_module-0.3.30/nerdd_module/tests/representations.py

@@ -0,0 +1,129 @@
+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
+from pytest_bdd import given, parsers
+from rdkit.Chem import MolToInchi, MolToMolBlock, MolToSmiles
+from ..polyfills import BlockLogs
+from rdkit.Chem.rdMolDescriptors import CalcExactMolWt
+import re
+from functools import reduce
+
+
+@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 in {input_type} format"),
+    target_fixture="representations",
+)
+def representations_from_molecules(molecules, input_type):
+    input_type = input_type.lower()
+
+    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}")
+
+    with BlockLogs():
+        result = [converter(mol) if mol is not None else None for mol in molecules]
+
+    return result
+
+
+@given(
+    parsers.re(
+        r"a list of (?P<num>\d+) random molecules(?:, where(?P<conditions>[\s\S]*))?"
+    ),
+    target_fixture="molecules",
+)
+def molecules(num, conditions, random_seed=0):
+    num = int(num)
+
+    filters = []
+    maps = []
+
+    if conditions is not None:
+        def filter_weight(min_weight, max_weight):
+            min_weight = float(min_weight)
+            max_weight = float(max_weight)
+            return lambda mol: (min_weight <= CalcExactMolWt(mol) <= max_weight)
+
+        def map_to_none(num_none):
+            num_none = int(num_none)
+
+            # draw indices of molecules that should be set to None
+            indices = np.random.choice(num, num_none, replace=False)
+
+            return lambda ms: [m if i not in indices else None for i, m in enumerate(ms)]
+
+        expressions = [
+            # filters are functions that return True if the molecule should be kept
+            ("filter", r"each mol has a weight between (?P<min_weight>\d+) and (?P<max_weight>\d+)", filter_weight),
+            # maps are functions that modify the molecule
+            ("map", r"(?P<num_none>\d+) entries are None", map_to_none)
+        ]
+
+        conditions_list = [c for c in conditions.split("\n") if c.strip() != ""]
+
+        for condition in conditions_list:
+            for kind, expression, f in expressions:
+                # conditions might be a markdown list (starting with a star character)
+                expression = r"\s*(\*\s*)?" + expression + r"\s*"
+
+                match = re.match(expression, condition)
+                if match:
+                    params = match.groupdict()
+                    break
+            
+            assert match is not None, f"Could not parse condition: {condition}"
+
+            if kind == "filter":
+                filters.append(f(**params))
+            elif kind == "map":
+                maps.append(f(**params))
+            else:
+                raise ValueError(f"Unknown kind: {kind}")
+
+    filter_func = lambda mol: all(f(mol) for f in filters)
+    map_func = lambda ms: reduce(lambda ms, f: f(ms), maps, ms)
+
+    result = None
+
+    # pytest-bdd and hypothesis don't play well together (yet)
+    # --> use this workaround to generate random molecules
+    @hgiven(st.lists(mols().filter(filter_func), 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()
+
+    # apply maps
+    result = map_func(result)
+
+    for m in result:
+        if m is None:
+            continue
+        m.SetProp("_Name", "mol")
+
+    return result

{nerdd_module-0.3.28 → nerdd_module-0.3.30}/nerdd_module/util/call_with_mappings.py

@@ -23,7 +23,7 @@ def call_with_mappings(
     # copy config
     config = config.copy()
 
-    # we check what arguments the constructor of the writer class can take
+    # check what arguments the class or function can take
     spec = inspect.getfullargspec(class_or_function)
     parameter_names = [a for a in spec.args if a != "self"]
     accept_any_args = spec.varargs is not None

{nerdd_module-0.3.28 → nerdd_module-0.3.30}/nerdd_module.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nerdd-module
-Version: 0.3.28
+Version: 0.3.30
 Summary: Base package to create NERDD modules
 Author-email: Steffen Hirte <steffen.hirte@univie.ac.at>
 Maintainer-email: Steffen Hirte <steffen.hirte@univie.ac.at>

{nerdd_module-0.3.28 → nerdd_module-0.3.30}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nerdd-module"
-version = "0.3.28"
+version = "0.3.30"
 description = "Base package to create NERDD modules"
 readme = "README.md"
 license = { file = "LICENSE" }

nerdd_module-0.3.28/nerdd_module/tests/representations.py

@@ -1,81 +0,0 @@
-import numpy as np
-from hypothesis import given as hgiven
-from hypothesis import seed, settings
-from hypothesis import strategies as st
-# TODO: remove "type: ignore" later
-from hypothesis_rdkit import mols  # type: ignore
-from pytest_bdd import given, parsers
-from rdkit.Chem import MolToInchi, MolToMolBlock, MolToSmiles
-from ..polyfills import BlockLogs
-
-
-@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 in {input_type} format"),
-    target_fixture="representations",
-)
-def representations_from_molecules(molecules, input_type):
-    input_type = input_type.lower()
-
-    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}")
-
-    with BlockLogs():
-        result = [converter(mol) if mol is not None else None for mol in molecules]
-
-    return result
-
-
-@given(
-    parsers.re(
-        r"a list of (?P<num>\d+) random molecules(?:, where (?P<num_none>\d+) entries are None)?"
-    ),
-    target_fixture="molecules",
-)
-def molecules_with_none(num, num_none=None, random_seed=0):
-    num = int(num)
-    num_none = int(num_none) if num_none is not None else 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)
-    @seed(random_seed)
-    def generate(ms):
-        nonlocal result
-        result = ms
-
-    generate()
-
-    for m in result:
-        if m is None:
-            continue
-        m.SetProp("_Name", "mol")
-
-    # replace random entries with None
-    indices = np.random.choice(num, num_none, replace=False)
-    for i in indices:
-        result[i] = None
-
-    return result