nerdd-module 0.3.12__tar.gz → 0.3.13__tar.gz

{nerdd_module-0.3.12 → nerdd_module-0.3.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nerdd-module
-Version: 0.3.12
+Version: 0.3.13
 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>
@@ -62,14 +62,14 @@ Requires-Dist: importlib-resources>=5; python_version < "3.9"
 Requires-Dist: importlib-metadata>=4.6; python_version < "3.10"
 Requires-Dist: typing_extensions>=4.0.1; python_version < "3.8"
 Provides-Extra: dev
-Requires-Dist: mypy==1.13.0; extra == "dev"
+Requires-Dist: mypy>=1; extra == "dev"
 Requires-Dist: ruff==0.7.1; extra == "dev"
 Requires-Dist: pandas-stubs; extra == "dev"
 Requires-Dist: rdkit-stubs; extra == "dev"
 Requires-Dist: types-PyYAML; extra == "dev"
 Requires-Dist: types-decorator; extra == "dev"
 Requires-Dist: types-setuptools; extra == "dev"
-Requires-Dist: pre-commit==3.5.0; extra == "dev"
+Requires-Dist: pre-commit>=2; extra == "dev"
 Provides-Extra: rdkit
 Requires-Dist: rdkit>=2022.3.3; extra == "rdkit"
 Provides-Extra: csp
@@ -79,7 +79,7 @@ Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-sugar; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
 Requires-Dist: pytest-asyncio; extra == "test"
-Requires-Dist: pytest-bdd==7.3.0; extra == "test"
+Requires-Dist: pytest-bdd<8; extra == "test"
 Requires-Dist: pytest-mock; extra == "test"
 Requires-Dist: pytest-watcher; extra == "test"
 Requires-Dist: hypothesis; extra == "test"

{nerdd_module-0.3.12 → nerdd_module-0.3.13}/nerdd_module/__init__.py

@@ -1,4 +1,5 @@
 from .cli import *
+from .converters import *
 from .model import *
 from .output import *
 from .polyfills import get_entry_points

{nerdd_module-0.3.12 → nerdd_module-0.3.13}/nerdd_module/config/models.py

@@ -77,6 +77,8 @@ class ResultProperty(BaseModel):
     level: Level = "molecule"
     formats: Union[FormatSpec, IncludeExcludeFormatSpec, None] = None
     representation: Optional[str] = None
+    image_width: Optional[int] = None
+    image_height: Optional[int] = None
 
     def is_visible(self, output_format: str) -> bool:
         formats = self.formats

nerdd_module-0.3.13/nerdd_module/converters/__init__.py

@@ -0,0 +1,7 @@
+from .converter import *
+from .converter_config import *
+from .identity_converter import *
+from .mol_converter import *
+from .mol_to_image_converter import *
+from .problem_list_converter import *
+from .void_converter import *

nerdd_module-0.3.13/nerdd_module/converters/converter.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import logging
+from abc import ABC, abstractmethod
+from typing import Any, Callable, Dict, Tuple, Union
+
+from ..config import ResultProperty
+from ..util import call_with_mappings
+from .converter_config import ALL, ALL_TYPE
+
+__all__ = ["Converter"]
+
+
+logger = logging.getLogger(__name__)
+
+
+_factories: Dict[
+    Tuple[Union[str, ALL_TYPE], Union[str, ALL_TYPE]], Callable[[dict], Converter]
+] = {}
+
+
+class Converter(ABC):
+    # a special symbol to indicate that a property should be hidden
+    HIDE = object()
+
+    def __init__(self, result_property: ResultProperty, output_format: str, **kwargs: Any) -> None:
+        super().__init__()
+        self.property = result_property
+        self.output_format = output_format
+
+    @classmethod
+    def __init_subclass__(
+        cls,
+        is_abstract: bool = False,
+        **kwargs: Any,
+    ) -> None:
+        super().__init_subclass__(**kwargs)
+
+        if hasattr(cls, "config"):
+            data_types = cls.config["data_types"]
+            output_formats = cls.config["output_formats"]
+        else:
+            data_types = None
+            output_formats = None
+
+        if not is_abstract:
+            if isinstance(data_types, str) or data_types is ALL:
+                data_types_list = [data_types]
+            else:
+                data_types_list = data_types
+
+            if isinstance(output_formats, str) or output_formats is ALL:
+                output_formats_list = [output_formats]
+            else:
+                output_formats_list = output_formats
+
+            for output_format in output_formats_list:
+                for data_type in data_types_list:
+                    logger.debug(f"Registering converter {cls} for {data_type} -> {output_format}")
+                    _factories[(data_type, output_format)] = cls
+
+    @abstractmethod
+    def _convert(self, input: Any, context: dict) -> Any:
+        pass
+
+    def convert(self, input: Any, context: dict) -> Any:
+        return self._convert(input, context)
+
+    @classmethod
+    def get_converter(
+        cls,
+        result_property: ResultProperty,
+        output_format: str,
+        return_default: bool = True,
+        **kwargs: Any,
+    ) -> Converter:
+        data_type = result_property.type
+        if (data_type, output_format) not in _factories:
+            ConverterFunc = None
+            if return_default:
+                if (data_type, ALL) in _factories:
+                    ConverterFunc = _factories[(data_type, ALL)]
+                elif (ALL, output_format) in _factories:
+                    ConverterFunc = _factories[(ALL, output_format)]
+                elif (ALL, ALL) in _factories:
+                    ConverterFunc = _factories[(ALL, ALL)]
+
+            if ConverterFunc is None:
+                raise ValueError(
+                    f"Unknown data type '{data_type}' or output format '{output_format}'"
+                )
+        else:
+            ConverterFunc = _factories[(data_type, output_format)]
+
+        # kwargs will be passed to the constructor of the converter
+        # --> add data_type and output_format to the kwargs
+        kwargs["result_property"] = result_property
+        kwargs["output_format"] = output_format
+
+        return call_with_mappings(ConverterFunc, kwargs)

nerdd_module-0.3.13/nerdd_module/converters/converter_config.py

@@ -0,0 +1,15 @@
+from typing import List, Optional, Union
+
+from ..polyfills import Literal, TypedDict
+
+__all__ = ["ConverterConfig", "ALL", "ALL_TYPE"]
+
+
+# a special symbol to indicate that all data types / output formats are considered
+ALL_TYPE = Literal["ALL"]
+ALL: ALL_TYPE = "ALL"
+
+
+class ConverterConfig(TypedDict):
+    data_types: Optional[Union[str, List[str], ALL_TYPE]]
+    output_formats: Optional[Union[str, List[str], ALL_TYPE]]

nerdd_module-0.3.13/nerdd_module/converters/identity_converter.py

@@ -0,0 +1,23 @@
+from typing import Any
+
+from .converter import Converter
+from .converter_config import ALL, ConverterConfig
+
+__all__ = ["IdentityConverter", "primitive_data_types"]
+
+primitive_data_types = [
+    "int",
+    "float",
+    "string",
+    "bool",
+]
+
+
+class IdentityConverter(Converter):
+    def _convert(self, input: Any, context: dict) -> Any:
+        return input
+
+    config = ConverterConfig(
+        data_types=primitive_data_types,
+        output_formats=ALL,
+    )

nerdd_module-0.3.13/nerdd_module/converters/mol_converter.py

@@ -0,0 +1,41 @@
+from typing import Any
+
+from rdkit.Chem import MolToInchi, MolToSmiles
+
+from ..config import ResultProperty
+from .converter import Converter
+from .converter_config import ALL, ConverterConfig
+
+__all__ = ["MolConverter"]
+
+
+class MolConverter(Converter):
+    def __init__(self, result_property: ResultProperty, output_format: str, **kwargs: Any) -> None:
+        super().__init__(result_property, output_format, **kwargs)
+
+        if output_format == "sdf" and result_property.name == "input_mol":
+            # in an SDF, the main molecule (input_mol) can be a Mol object
+            self._serialize = lambda x: x
+        elif output_format in ["pandas", "record_list", "iterator"]:
+            self._serialize = lambda mol: mol
+        else:
+            representation = result_property.representation or "smiles"
+            if representation == "inchi":
+                self._serialize = MolToInchi
+            elif representation == "smiles":
+                self._serialize = MolToSmiles
+            else:
+                raise ValueError(f"Unsupported representation: {representation}")
+
+    def _convert(self, input: Any, context: dict) -> Any:
+        try:
+            representation = self._serialize(input)
+        except:  # noqa: E722 (allow bare except, because RDKit is unpredictable)
+            representation = None
+
+        return representation
+
+    config = ConverterConfig(
+        data_types="mol",
+        output_formats=ALL,
+    )

nerdd_module-0.3.13/nerdd_module/converters/mol_to_image_converter.py

@@ -0,0 +1,62 @@
+from typing import Any
+from xml.dom import minidom
+
+from rdkit.Chem import Mol
+from rdkit.Chem.Draw import MolDraw2DSVG
+
+from .converter import Converter
+from .converter_config import ConverterConfig
+
+__all__ = ["MolToImageConverter"]
+
+default_width = 400
+default_height = 300
+
+
+class MolToImageConverter(Converter):
+    def _convert(self, input: Any, context: dict) -> Any:
+        width = self.property.image_width
+        height = self.property.image_height
+
+        if width is None:
+            width = default_width
+        if height is None:
+            height = default_height
+
+        mol = input
+        if mol is None:
+            return None
+
+        assert isinstance(mol, Mol), f"Expected RDKit Mol object, but got {type(mol)}"
+
+        svg = MolDraw2DSVG(width, height)
+
+        # remove background
+        opts = svg.drawOptions()
+        opts.clearBackground = False
+
+        # add highlight circles around atoms during drawing
+        # (we will remove them later in post processing)
+        atoms = range(mol.GetNumAtoms())
+        colors = [[(0.8, 1, 1)]] * mol.GetNumAtoms()
+        radii = [0.5] * mol.GetNumAtoms()
+        atom_highlight = dict(zip(atoms, colors))
+        atom_radii = dict(zip(atoms, radii))
+        svg.DrawMoleculeWithHighlights(mol, "", atom_highlight, {}, atom_radii, [])
+        svg.FinishDrawing()
+
+        # post process SVG
+        xml = svg.GetDrawingText()
+        tree = minidom.parseString(xml)
+        root = tree.getElementsByTagName("svg")[0]
+
+        # make highlight circles invisible
+        for ellipse in root.getElementsByTagName("ellipse"):
+            ellipse.setAttribute("style", "opacity:0")
+
+        xml = tree.toxml()
+
+        return xml
+
+    # TODO: move to nerdd-link
+    config = ConverterConfig(data_types="mol", output_formats="json")

nerdd_module-0.3.13/nerdd_module/converters/problem_list_converter.py

@@ -0,0 +1,21 @@
+from typing import Any, List, cast
+
+from ..problem import Problem
+from .converter import Converter
+from .converter_config import ALL, ConverterConfig
+
+__all__ = ["ProblemListConverter"]
+
+
+class ProblemListConverter(Converter):
+    def _convert(self, input: Any, context: dict) -> Any:
+        if self.output_format in ["pandas", "iterator", "record_list"]:
+            return input
+        else:
+            problem_list: List[Problem] = cast(List[Problem], input)
+            return "; ".join([f"{problem.type}: {problem.message}" for problem in problem_list])
+
+    config = ConverterConfig(
+        data_types="problem_list",
+        output_formats=ALL,
+    )

nerdd_module-0.3.13/nerdd_module/converters/void_converter.py

@@ -0,0 +1,17 @@
+from typing import Any
+
+from .converter import Converter
+from .converter_config import ALL, ConverterConfig
+
+__all__ = ["VoidConverter"]
+
+
+class VoidConverter(Converter):
+    def _convert(self, input: Any, context: dict) -> Any:
+        return Converter.HIDE
+
+    # by default, all data types will be hidden for all output formats
+    config = ConverterConfig(
+        data_types=ALL,
+        output_formats=ALL,
+    )

{nerdd_module-0.3.12 → nerdd_module-0.3.13}/nerdd_module/input/depth_first_explorer.py

@@ -107,7 +107,7 @@ class DepthFirstExplorer(Explorer):
             except Exception:
                 pass
 
-            # clean up tree
+            # clean up stack
             while len(self._state_stack) > depth:
                 self._state_stack.pop()
             generator = None
@@ -115,12 +115,11 @@ class DepthFirstExplorer(Explorer):
         if generator is None:
             if best_reader is None:
                 generator = self._read(InvalidInputReader(), input)
-                sample = []
             else:
                 generator = self._read(best_reader, input)
-                sample = list(islice(generator, self._num_test_entries))
+            sample = []
         else:
-            if best_mode is not None and best_mode != "guess":
+            if best_mode == "builtin":
                 parent["first_guess"].append(best_reader)
 
         yield from sample

{nerdd_module-0.3.12 → nerdd_module-0.3.13}/nerdd_module/input/file_reader.py

@@ -16,11 +16,16 @@ class FileReader(Reader):
             self.data_dir = Path(self.data_dir)
 
     def read(self, filename: Any, explore: ExploreCallable) -> Iterator[MoleculeEntry]:
-        assert isinstance(filename, str), "input must be a string"
+        assert isinstance(filename, (str, bytes)), "input must be a string or bytes"
+
+        if isinstance(filename, bytes):
+            filename_str = filename.decode("utf-8")
+        else:
+            filename_str = filename
 
         # convert filename to path
         try:
-            path = Path(filename)
+            path = Path(filename_str)
         except TypeError as e:
             raise ValueError("input must be a valid path") from e
 
@@ -45,7 +50,7 @@ class FileReader(Reader):
                     source: Tuple[str, ...] = tuple()
                 else:
                     source = entry.source
-                yield entry._replace(source=(filename, *source))
+                yield entry._replace(source=(filename_str, *source))
 
     def __repr__(self) -> str:
         return f"FileReader(data_dir={self.data_dir})"

nerdd_module-0.3.13/nerdd_module/model/convert_representations_step.py

@@ -0,0 +1,24 @@
+from typing import Any, List
+
+from ..config import ResultProperty
+from ..converters import Converter
+from ..steps import MapStep
+
+__all__ = ["ConvertRepresentationsStep"]
+
+
+class ConvertRepresentationsStep(MapStep):
+    def __init__(
+        self, result_properties: List[ResultProperty], output_format: str, **kwargs: Any
+    ) -> None:
+        super().__init__()
+        self._converter_map = {
+            p.name: Converter.get_converter(p, output_format, **kwargs) for p in result_properties
+        }
+
+    def _process(self, record: dict) -> dict:
+        result = {
+            k: self._converter_map[k].convert(input=v, context=record) for k, v in record.items()
+        }
+
+        return {k: v for k, v in result.items() if v is not Converter.HIDE}

{nerdd_module-0.3.12 → nerdd_module-0.3.13}/nerdd_module/model/simple_model.py

@@ -113,22 +113,26 @@ class SimpleModel(Model):
         task_based_property = []
         if task == "atom_property_prediction":
             task_based_property = [
-                {"name": "atom_id", "type": "integer"},
+                {"name": "atom_id", "type": "int"},
             ]
         elif task == "derivative_property_prediction":
             task_based_property = [
-                {"name": "derivative_id", "type": "integer"},
+                {"name": "derivative_id", "type": "int"},
             ]
 
         default_properties_start = [
-            {"name": "mol_id", "type": "integer"},
+            {"name": "mol_id", "type": "int"},
             *task_based_property,
-            {"name": "input_text", "type": "string"},
-            {"name": "input_type", "type": "string"},
-            {"name": "source", "type": "string"},
-            {"name": "name", "type": "string"},
-            {"name": "input_mol", "type": "mol"},
-            {"name": "preprocessed_mol", "type": "mol"},
+            {"name": "input_text", "visible_name": "Input text", "type": "string"},
+            {"name": "input_type", "visible_name": "Input type", "type": "string"},
+            {"name": "source", "visible_name": "Source", "type": "string"},
+            {"name": "name", "visible_name": "Name", "type": "string"},
+            {"name": "input_mol", "visible_name": "Input SMILES", "type": "mol"},
+            {
+                "name": "preprocessed_mol",
+                "visible_name": "Preprocessed SMILES",
+                "type": "mol",
+            },
         ]
 
         default_properties_end = [

{nerdd_module-0.3.12 → nerdd_module-0.3.13}/nerdd_module/preprocessing/chembl_structure_pipeline.py

@@ -14,17 +14,23 @@ warnings.filterwarnings(
     module="rdkit.Chem.MolStandardize",
 )
 
+# We check if chembl_structure_pipeline is installed. Since importing this library already logs
+# messages, we suppress them using RDKit's BlockLogs. We would like to use
+#   with BlockLogs(): ...
+# but this does not work with old versions of RDKit. Therefore, we create an instance of
+# BlockLogs that will suppress log messages as long as it exists. When it is deleted (in the
+# "finally" block), logs are enabled again.
+block_logs = BlockLogs()
 try:
-    # importing chembl_structure_pipeline already logs messages
-    # --> suppress them temporarily
-    with BlockLogs():
-        from chembl_structure_pipeline import get_parent_mol, standardize_mol
+    from chembl_structure_pipeline import get_parent_mol, standardize_mol
 
     import_error = None
 except ImportError as e:
     # raise ImportError later when using this class
     # --> this allows to use the rest of the package without chembl_structure_pipeline
     import_error = e
+finally:
+    del block_logs
 
 __all__ = ["GetParentMolWithCsp", "StandardizeWithCsp"]
 

{nerdd_module-0.3.12 → nerdd_module-0.3.13}/nerdd_module/tests/__init__.py

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

nerdd_module-0.3.13/nerdd_module/tests/files.py

@@ -0,0 +1,74 @@
+from tempfile import NamedTemporaryFile
+
+import numpy as np
+from pytest_bdd import given, parsers
+
+from .representations import representations_from_molecules
+
+
+@given(
+    parsers.parse("a file containing the molecules in {input_type} format"),
+    target_fixture="files",
+)
+def representation_file(molecules, input_type):
+    representations = representations_from_molecules(molecules, input_type)
+
+    with NamedTemporaryFile("w", delete=False) as f:
+        for representation in representations:
+            if representation is None:
+                f.write("None")
+            else:
+                f.write(representation)
+            if input_type in ["smiles", "inchi"]:
+                f.write("\n")
+            elif input_type == "mol_block":
+                f.write("\n$$$$\n")
+        f.flush()
+        return [f.name]
+
+
+@given(
+    parsers.parse(
+        "a list of {num_files:d} files containing the representations in {input_type} format",
+    ),
+    target_fixture="files",
+)
+def representation_files(molecules, input_type, num_files):
+    representations = representations_from_molecules(molecules, input_type)
+
+    # choose num_files-1 numbers to split the representations into num_files parts
+    # the while loop makes sure that each part contains at least one valid molecule
+    while True:
+        split_indices = np.random.choice(
+            len(representations), size=num_files - 1, replace=False
+        )
+        split_indices = np.sort(split_indices)
+
+        # split the representations
+        split_representations = np.split(representations, split_indices)
+
+        # check if each part contains at least one valid molecule
+        if all(
+            any(representation is not None for representation in split_representation)
+            for split_representation in split_representations
+        ):
+            break
+
+    # write the representations to files
+    representations_files = []
+
+    for _, split_representation in enumerate(split_representations):
+        with NamedTemporaryFile("w", delete=False) as f:
+            for representation in split_representation:
+                if representation is None:
+                    f.write("None")
+                else:
+                    f.write(representation)
+                if input_type in ["smiles", "inchi"]:
+                    f.write("\n")
+                elif input_type == "mol_block":
+                    f.write("\n$$$$\n")
+            f.flush()
+            representations_files.append(f.name)
+
+    return representations_files

{nerdd_module-0.3.12 → nerdd_module-0.3.13}/nerdd_module/tests/predictions.py

@@ -20,28 +20,30 @@ def mol_weight_model(version):
 
 
 @when(
-    parsers.parse("the mol weight model (version '{version}') generates predictions for the molecule representations"),
+    parsers.parse(
+        "the mol weight model (version '{version}') generates predictions for the molecule representations"
+    ),
     target_fixture="predictions",
 )
-def predictions_mol_weight_model(representations, version, input_type, multiplier):
+def predictions_mol_weight_model(representations, version, multiplier):
     model = MolWeightModel(version=version)
     return model.predict(
         representations,
-        input_type=input_type,
         multiplier=multiplier,
         output_format="record_list",
     )
 
 
 @when(
-    parsers.parse("the atomic mass model (version '{version}') generates predictions for the molecule representations"),
+    parsers.parse(
+        "the atomic mass model (version '{version}') generates predictions for the molecule representations"
+    ),
     target_fixture="predictions",
 )
-def predictions_atomic_mass_model(representations, version, input_type, multiplier):
+def predictions_atomic_mass_model(representations, version, multiplier):
     model = AtomicMassModel(version=version)
     return model.predict(
         representations,
-        input_type=input_type,
         multiplier=multiplier,
         output_format="record_list",
     )

{nerdd_module-0.3.12 → nerdd_module-0.3.13}/nerdd_module/tests/representations.py

@@ -24,10 +24,12 @@ def representations_from_input(input):
 
 
 @given(
-    parsers.parse("the representations of the molecules"),
+    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":
@@ -46,10 +48,14 @@ def representations_from_molecules(molecules, input_type):
 
 
 @given(
-    parsers.parse("a list of {num:d} random molecules, where {num_none:d} entries are None"),
+    parsers.re(
+        r"a list of (?P<num>\d+) random molecules(?:, where (?P<num_none>\d+) entries are None)?"
+    ),
     target_fixture="molecules",
 )
-def molecules(num, num_none, random_seed=0):
+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)
@@ -69,8 +75,3 @@ def molecules(num, num_none, random_seed=0):
         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.3.12 → nerdd_module-0.3.13}/nerdd_module.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nerdd-module
-Version: 0.3.12
+Version: 0.3.13
 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>
@@ -62,14 +62,14 @@ Requires-Dist: importlib-resources>=5; python_version < "3.9"
 Requires-Dist: importlib-metadata>=4.6; python_version < "3.10"
 Requires-Dist: typing_extensions>=4.0.1; python_version < "3.8"
 Provides-Extra: dev
-Requires-Dist: mypy==1.13.0; extra == "dev"
+Requires-Dist: mypy>=1; extra == "dev"
 Requires-Dist: ruff==0.7.1; extra == "dev"
 Requires-Dist: pandas-stubs; extra == "dev"
 Requires-Dist: rdkit-stubs; extra == "dev"
 Requires-Dist: types-PyYAML; extra == "dev"
 Requires-Dist: types-decorator; extra == "dev"
 Requires-Dist: types-setuptools; extra == "dev"
-Requires-Dist: pre-commit==3.5.0; extra == "dev"
+Requires-Dist: pre-commit>=2; extra == "dev"
 Provides-Extra: rdkit
 Requires-Dist: rdkit>=2022.3.3; extra == "rdkit"
 Provides-Extra: csp
@@ -79,7 +79,7 @@ Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-sugar; extra == "test"
 Requires-Dist: pytest-cov; extra == "test"
 Requires-Dist: pytest-asyncio; extra == "test"
-Requires-Dist: pytest-bdd==7.3.0; extra == "test"
+Requires-Dist: pytest-bdd<8; extra == "test"
 Requires-Dist: pytest-mock; extra == "test"
 Requires-Dist: pytest-watcher; extra == "test"
 Requires-Dist: hypothesis; extra == "test"

{nerdd_module-0.3.12 → nerdd_module-0.3.13}/nerdd_module.egg-info/SOURCES.txt

@@ -22,7 +22,12 @@ nerdd_module/config/search_yaml_configuration.py
 nerdd_module/config/yaml_configuration.py
 nerdd_module/converters/__init__.py
 nerdd_module/converters/converter.py
+nerdd_module/converters/converter_config.py
 nerdd_module/converters/identity_converter.py
+nerdd_module/converters/mol_converter.py
+nerdd_module/converters/mol_to_image_converter.py
+nerdd_module/converters/problem_list_converter.py
+nerdd_module/converters/void_converter.py
 nerdd_module/input/__init__.py
 nerdd_module/input/depth_first_explorer.py
 nerdd_module/input/explorer.py
@@ -76,6 +81,7 @@ nerdd_module/steps/output_step.py
 nerdd_module/steps/step.py
 nerdd_module/tests/__init__.py
 nerdd_module/tests/checks.py
+nerdd_module/tests/files.py
 nerdd_module/tests/predictions.py
 nerdd_module/tests/representations.py
 nerdd_module/tests/models/AtomicMassModel.py

{nerdd_module-0.3.12 → nerdd_module-0.3.13}/nerdd_module.egg-info/requires.txt

@@ -19,14 +19,14 @@ importlib-resources>=5
 chembl_structure_pipeline>=1.0.0
 
 [dev]
-mypy==1.13.0
+mypy>=1
 ruff==0.7.1
 pandas-stubs
 rdkit-stubs
 types-PyYAML
 types-decorator
 types-setuptools
-pre-commit==3.5.0
+pre-commit>=2
 
 [docs]
 mkdocs
@@ -41,7 +41,7 @@ pytest
 pytest-sugar
 pytest-cov
 pytest-asyncio
-pytest-bdd==7.3.0
+pytest-bdd<8
 pytest-mock
 pytest-watcher
 hypothesis

{nerdd_module-0.3.12 → nerdd_module-0.3.13}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nerdd-module"
-version = "0.3.12"
+version = "0.3.13"
 description = "Base package to create NERDD modules"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -50,14 +50,14 @@ classifiers = [
 
 [project.optional-dependencies]
 dev = [
-    "mypy==1.13.0",
+    "mypy>=1",
     "ruff==0.7.1",
     "pandas-stubs",
     "rdkit-stubs",
     "types-PyYAML",
     "types-decorator",
     "types-setuptools",
-    "pre-commit==3.5.0",
+    "pre-commit>=2",
 ]
 rdkit = [
     # Some old RDKit versions are not recognized by setuptools. For that reason,
@@ -78,7 +78,7 @@ test = [
     "pytest-sugar",
     "pytest-cov",
     "pytest-asyncio",
-    "pytest-bdd==7.3.0",
+    "pytest-bdd<8",
     "pytest-mock",
     "pytest-watcher",
     "hypothesis",

nerdd_module-0.3.12/nerdd_module/converters/__init__.py

@@ -1,2 +0,0 @@
-from .converter import *
-from .identity_converter import *

nerdd_module-0.3.12/nerdd_module/converters/converter.py

@@ -1,62 +0,0 @@
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from functools import partial
-from typing import Any, Callable, Dict, Optional, Tuple
-
-from ..util import call_with_mappings
-
-__all__ = ["Converter"]
-
-
-_factories: Dict[Tuple[Optional[str], Optional[str]], Callable[[dict], Converter]] = {}
-
-
-class Converter(ABC):
-    def __init__(self) -> None:
-        super().__init__()
-
-    @classmethod
-    def __init_subclass__(
-        cls,
-        output_format: Optional[str] = None,
-        data_type: Optional[str] = None,
-        is_abstract: bool = False,
-        **kwargs: Any,
-    ) -> None:
-        super().__init_subclass__(**kwargs)
-        if not is_abstract:
-            _factories[(data_type, output_format)] = partial(call_with_mappings, cls)
-
-    @abstractmethod
-    def _convert(self, input: Any, context: dict, **kwargs: Any) -> Any:
-        pass
-
-    def convert(self, input: Any, context: dict, **kwargs: Any) -> Any:
-        return self._convert(input, context, **kwargs)
-
-    @classmethod
-    def get_converter(
-        cls,
-        data_type: str,
-        output_format: str,
-        return_default: bool = True,
-        **kwargs: Any,
-    ) -> Converter:
-        if (data_type, output_format) not in _factories:
-            default = None
-            if return_default:
-                if (data_type, None) in _factories:
-                    default = _factories[(data_type, None)]
-                elif (None, output_format) in _factories:
-                    default = _factories[(None, output_format)]
-                elif (None, None) in _factories:
-                    default = _factories[(None, None)]
-
-            if default is None:
-                raise ValueError(
-                    f"Unknown data type '{data_type}' or output format '{output_format}'"
-                )
-            return default(kwargs)
-
-        return _factories[(data_type, output_format)](kwargs)

nerdd_module-0.3.12/nerdd_module/converters/identity_converter.py

@@ -1,8 +0,0 @@
-from typing import Any
-
-from .converter import Converter
-
-
-class IdentityConverter(Converter, data_type=None, output_format=None):
-    def _convert(self, input: Any, context: dict, **kwargs: Any) -> dict:
-        return input

nerdd_module-0.3.12/nerdd_module/model/convert_representations_step.py

@@ -1,20 +0,0 @@
-from typing import Any
-
-from ..converters import Converter
-from ..steps import MapStep
-
-__all__ = ["ConvertRepresentationsStep"]
-
-
-class ConvertRepresentationsStep(MapStep):
-    def __init__(self, result_properties: list, output_format: str, **kwargs: Any) -> None:
-        super().__init__()
-        self._converter_map = {
-            p.name: Converter.get_converter(p.type, output_format, property=p, **kwargs)
-            for p in result_properties
-        }
-
-    def _process(self, record: dict) -> dict:
-        return {
-            k: self._converter_map[k].convert(input=v, context=record) for k, v in record.items()
-        }