nerdd-module 0.3.3__tar.gz → 0.3.7__tar.gz

nerdd_module-0.3.7/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.1
+Name: nerdd-module
+Version: 0.3.7
+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>
+License: BSD 3-Clause License
+        
+        Copyright (c) 2023 - present, The Computational Drug Discovery and Design Group (COMP3D)
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        1. Redistributions of source code must retain the above copyright notice, this
+           list of conditions and the following disclaimer.
+        
+        2. Redistributions in binary form must reproduce the above copyright notice,
+           this list of conditions and the following disclaimer in the documentation
+           and/or other materials provided with the distribution.
+        
+        3. Neither the name of the copyright holder nor the names of its
+           contributors may be used to endorse or promote products derived from
+           this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+Project-URL: Repository, https://github.com/molinfo-vienna/nerdd-module
+Keywords: science,research,development,nerdd
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development
+Classifier: Topic :: Scientific/Engineering
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.2.1
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: filetype~=1.2.0
+Requires-Dist: rich-click>=1.7.1
+Requires-Dist: stringcase>=1.2.0
+Requires-Dist: decorator>=5.1.1
+Requires-Dist: importlib-resources>=5; python_version < "3.9"
+Requires-Dist: importlib-metadata>=4.6; python_version < "3.10"
+Provides-Extra: dev
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: pandas-stubs; extra == "dev"
+Requires-Dist: types-PyYAML; extra == "dev"
+Requires-Dist: types-decorator; extra == "dev"
+Requires-Dist: types-setuptools; extra == "dev"
+Provides-Extra: rdkit
+Requires-Dist: rdkit>=2022.3.3; extra == "rdkit"
+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"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"
+Requires-Dist: pytest-bdd; extra == "test"
+Requires-Dist: pytest-mock; extra == "test"
+Requires-Dist: pytest-watcher; extra == "test"
+Requires-Dist: hypothesis; extra == "test"
+Requires-Dist: hypothesis-rdkit; extra == "test"
+Provides-Extra: docs
+Requires-Dist: mkdocs; extra == "docs"
+Requires-Dist: mkdocs-material; extra == "docs"
+Requires-Dist: mkdocstrings; extra == "docs"
+
+# NERDD Module
+
+This package provides the basis to implement molecular prediction modules in the
+NERDD ecosystem.
+
+## Installation
+
+``` bash
+pip install -U nerdd-module
+```
+
+
+## Contribute
+
+1. Fork and clone the code
+2. Install test dependencies with ` pip install -e .[test,dev,csp]` 
+3. Run tests via `pytest` or `pytest-watch` (short: `ptw`)
+4. Build docs via ` pip install -e .[docs]`  and ` mkdocs serve` 

nerdd_module-0.3.7/README.md

@@ -0,0 +1,18 @@
+# NERDD Module
+
+This package provides the basis to implement molecular prediction modules in the
+NERDD ecosystem.
+
+## Installation
+
+``` bash
+pip install -U nerdd-module
+```
+
+
+## Contribute
+
+1. Fork and clone the code
+2. Install test dependencies with ` pip install -e .[test,dev,csp]` 
+3. Run tests via `pytest` or `pytest-watch` (short: `ptw`)
+4. Build docs via ` pip install -e .[docs]`  and ` mkdocs serve` 

{nerdd_module-0.3.3 → nerdd_module-0.3.7}/nerdd_module/__init__.py

@@ -1,7 +1,5 @@
 from .cli import *
-from .input import ReaderRegistry
 from .model import *
-from .output import WriterRegistry
 from .polyfills import get_entry_points
 from .problem import *
 from .version import *

{nerdd_module-0.3.3 → nerdd_module-0.3.7}/nerdd_module/cli.py

@@ -1,11 +1,13 @@
 import logging
-import os
 import sys
+from typing import Any, Callable
 
 import rich_click as click
 from decorator import decorator
 from stringcase import spinalcase  # type: ignore
 
+from .model import Model
+
 __all__ = ["auto_cli"]
 
 input_description = """{description}
@@ -19,74 +21,70 @@ Note that input formats shouldn't be mixed.
 """
 
 
-def infer_click_type(param):
+def infer_click_type(param: dict) -> click.ParamType:
     if "choices" in param:
         choices = [c["value"] for c in param["choices"]]
         return click.Choice(choices)
 
     type_map = {
-        "float": float,
-        "int": int,
-        "str": str,
-        "bool": bool,
+        "float": click.FLOAT,
+        "int": click.INT,
+        "str": click.STRING,
+        "bool": click.BOOL,
     }
 
-    return type_map[param.get("type")]
+    if "type" not in param:
+        raise ValueError(f"Parameter {param['name']} does not have a type")
+
+    t = param["type"]
+
+    if t not in type_map:
+        raise ValueError(f"Unknown type {t} for parameter {param['name']}")
+
+    return type_map[t]
 
 
 @decorator
-def auto_cli(f, *args, **kwargs):
+def auto_cli(f: Callable[..., Model], *args: Any, **kwargs: Any) -> None:
     # infer the command name
-    command_name = os.path.basename(sys.argv[0])
+    # command_name = os.path.basename(sys.argv[0])
 
     # get the model
     model = f()
 
-    config = model.get_config()
-
     # compose cli description
-    description = config.get("description", "")
-
     input_format_list = "\n".join([f"* {fmt}" for fmt in ["smiles", "sdf", "inchi"]])
 
     help_text = input_description.format(
-        description=description, input_format_list=input_format_list
+        description=model.description, input_format_list=input_format_list
     )
 
     output_format_list = ["sdf", "csv"]
 
     # compose footer with examples
-    examples = []
-    if "example_smiles" in config:
-        examples.append(config["example_smiles"])
-
-    if len(examples) > 0:
-        footer = "Examples:\n"
-        for example in examples:
-            footer += f'* {command_name} "{example}"\n'
-    else:
-        footer = ""
+    # TODO: add examples
+    # examples = []
+    # if "example_smiles" in config:
+    #     examples.append(config["example_smiles"])
+
+    # if len(examples) > 0:
+    #     footer = "Examples:\n"
+    #     for example in examples:
+    #         footer += f'* {command_name} "{example}"\n'
+    # else:
+    #     footer = ""
+    footer = ""
 
-    # show_default=True: default values are shown in the help text
-    # show_metavars_column=False: the column types are not in a separate column
-    # append_metavars_help=True: the column types are shown below the help text
-    @click.command(context_settings={"show_default": True}, help=help_text)
-    @click.rich_config(
-        help_config=click.RichHelpConfiguration(
-            use_markdown=True,
-            show_metavars_column=False,
-            append_metavars_help=True,
-            footer_text=footer,
-        )
-    )
-    @click.argument("input", type=click.Path(), nargs=-1, required=True)
+    #
+    # Define the CLI entry point
+    #
     def main(
-        input,
+        input: Any,
         format: str,
         output: click.Path,
         log_level: str,
-        **kwargs,
-    ):
+        **kwargs: Any,
+    ) -> None:
         logging.basicConfig(level=log_level.upper())
 
         # write results
@@ -99,10 +97,15 @@ def auto_cli(f, *args, **kwargs):
 
         model.predict(input, output_format=format, output_file=output_handle, **kwargs)
 
+    #
+    # Add required input parameter
+    #
+    main = click.argument("input", type=click.Path(), nargs=-1, required=True)(main)
+
     #
     # Add job parameters
     #
-    for param in config.get("job_parameters", []):
+    for param in model.job_parameters:
         # convert parameter name to spinal case (e.g. "max_confs" -> "max-confs")
         param_name = spinalcase(param["name"])
         main = click.option(
@@ -132,10 +135,26 @@ def auto_cli(f, *args, **kwargs):
     main = click.option(
         "--log-level",
         default="warning",
-        type=click.Choice(
-            ["debug", "info", "warning", "error", "critical"], case_sensitive=False
-        ),
+        type=click.Choice(["debug", "info", "warning", "error", "critical"], case_sensitive=False),
         help="The logging level.",
     )(main)
 
+    #
+    # Create Rich command
+    #
+
+    # show_metavars_column=False: the column types are not in a separate column
+    # append_metavars_help=True: the column types are shown below the help text
+    main = click.rich_config(
+        help_config=click.RichHelpConfiguration(
+            use_markdown=True,
+            show_metavars_column=False,
+            append_metavars_help=True,
+            footer_text=footer,
+        )
+    )(main)
+
+    # show_default=True: default values are shown in the help text
+    main = click.command(context_settings={"show_default": True}, help=help_text)(main)
+
     return main()

{nerdd_module-0.3.3 → nerdd_module-0.3.7}/nerdd_module/config/configuration.py

@@ -5,15 +5,34 @@ from typing import List
 __all__ = ["Configuration"]
 
 
-def get_property_columns_of_type(config, t) -> List[dict]:
+def get_property_columns_of_type(config: dict, t: str) -> List[dict]:
     return [c for c in config["result_properties"] if c.get("level", "molecule") == t]
 
 
+def is_visible(result_property: dict, output_format: str) -> bool:
+    formats = result_property.get("formats", {})
+
+    if isinstance(formats, list):
+        return output_format in formats
+    elif isinstance(formats, dict):
+        include = formats.get("include", "*")
+        exclude = formats.get("exclude", [])
+        assert include == "*" or isinstance(
+            include, list
+        ), f"Expected include to be a list or '*', got {include}"
+        assert isinstance(exclude, list), f"Expected exclude to be a list, got {exclude}"
+        return (include == "*" or output_format in include) and output_format not in exclude
+    else:
+        raise ValueError(
+            f"Invalid formats declaration {formats} in result property " f"{result_property}"
+        )
+
+
 class Configuration(ABC):
-    def __init__(self):
+    def __init__(self) -> None:
         pass
 
-    @lru_cache
+    @lru_cache(1)
     def get_dict(self) -> dict:
         config = self._get_dict()
 
@@ -22,9 +41,7 @@ class Configuration(ABC):
 
         # check that a module can only predict atom or derivative properties, not both
         num_atom_properties = len(get_property_columns_of_type(config, "atom"))
-        num_derivative_properties = len(
-            get_property_columns_of_type(config, "derivative")
-        )
+        num_derivative_properties = len(get_property_columns_of_type(config, "derivative"))
         assert (
             num_atom_properties == 0 or num_derivative_properties == 0
         ), "A module can only predict atom or derivative properties, not both."
@@ -39,13 +56,13 @@ class Configuration(ABC):
         return self.get_dict() == {}
 
     def molecular_property_columns(self) -> List[dict]:
-        return get_property_columns_of_type(self, "molecule")
+        return get_property_columns_of_type(self.get_dict(), "molecule")
 
     def atom_property_columns(self) -> List[dict]:
-        return get_property_columns_of_type(self, "atom")
+        return get_property_columns_of_type(self.get_dict(), "atom")
 
     def derivative_property_columns(self) -> List[dict]:
-        return get_property_columns_of_type(self, "derivative")
+        return get_property_columns_of_type(self.get_dict(), "derivative")
 
     def get_task(self) -> str:
         # if task is specified in the config, use that
@@ -64,8 +81,10 @@ class Configuration(ABC):
         else:
             return "molecular_property_prediction"
 
-    def __getitem__(self, key):
-        return self.get_dict()[key]
+    def get_visible_properties(self, output_format: str) -> List[dict]:
+        return [
+            p for p in self.get_dict().get("result_properties", []) if is_visible(p, output_format)
+        ]
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"{self.__class__.__name__}({self._get_dict()})"

{nerdd_module-0.3.3 → nerdd_module-0.3.7}/nerdd_module/config/default_configuration.py

@@ -1,3 +1,5 @@
+from typing import Any
+
 from stringcase import snakecase  # type: ignore
 
 from ..polyfills import version
@@ -7,7 +9,7 @@ __all__ = ["DefaultConfiguration"]
 
 
 class DefaultConfiguration(DictConfiguration):
-    def __init__(self, nerdd_module):
+    def __init__(self, nerdd_module: Any) -> None:
         # generate a name from the module name
         class_name = nerdd_module.__class__.__name__
         if class_name.endswith("Model"):

{nerdd_module-0.3.3 → nerdd_module-0.3.7}/nerdd_module/config/merged_configuration.py

@@ -6,7 +6,7 @@ from .dict_configuration import DictConfiguration
 __all__ = ["MergedConfiguration"]
 
 
-def merge(*args):
+def merge(*args: dict) -> dict:
     assert len(args) > 0
 
     first_entry = args[0]

{nerdd_module-0.3.3 → nerdd_module-0.3.7}/nerdd_module/config/package_configuration.py

@@ -11,7 +11,7 @@ logger = logging.getLogger(__name__)
 
 
 class PackageConfiguration(Configuration):
-    def __init__(self, package):
+    def __init__(self, package: str) -> None:
         super().__init__()
 
         # get the resource directory
@@ -20,17 +20,16 @@ class PackageConfiguration(Configuration):
         except ModuleNotFoundError:
             root_dir = None
 
-        if root_dir is None:
-            self.config = DictConfiguration({})
-        else:
+        self.config: Configuration = DictConfiguration({})
+        if root_dir is not None:
             # navigate to the config file
             config_file = root_dir / "nerdd.yml"
 
-            if config_file is not None and config_file.exists():
+            if config_file is not None and config_file.is_file():
                 logger.info(f"Found configuration file in package: {config_file}")
-                self.config = YamlConfiguration(config_file, base_path=root_dir)
+                self.config = YamlConfiguration(config_file.open(), base_path=root_dir)
             else:
                 self.config = DictConfiguration({})
 
-    def _get_dict(self):
+    def _get_dict(self) -> dict:
         return self.config.get_dict()

{nerdd_module-0.3.3 → nerdd_module-0.3.7}/nerdd_module/config/search_yaml_configuration.py

@@ -1,7 +1,6 @@
 import logging
 import os
-import sys
-from typing import Any, Optional
+from typing import Optional
 
 from .configuration import Configuration
 from .dict_configuration import DictConfiguration
@@ -32,9 +31,7 @@ class SearchYamlConfiguration(DictConfiguration):
                 leaf = os.path.dirname(leaf)
 
             if default_config_file is not None:
-                logger.info(
-                    f"Found configuration file in project directory: {default_config_file}"
-                )
+                logger.info(f"Found configuration file in project directory: {default_config_file}")
                 config = YamlConfiguration(default_config_file, base_path)
 
         super().__init__(config.get_dict())

nerdd_module-0.3.7/nerdd_module/config/yaml_configuration.py

@@ -0,0 +1,90 @@
+import base64
+import os
+from pathlib import Path
+from typing import IO, Any, Union
+
+import filetype  # type: ignore
+import yaml
+from typing_extensions import Protocol
+
+from ..polyfills import PathLikeStr, Traversable, as_file
+from .configuration import Configuration
+
+__all__ = ["YamlConfiguration"]
+
+
+class CustomLoaderLike(Protocol):
+    base_path: Union[str, PathLikeStr, Traversable]
+
+    def construct_scalar(self, node: yaml.ScalarNode) -> str: ...
+
+
+def image_constructor(loader: CustomLoaderLike, node: yaml.Node) -> str:
+    assert isinstance(node, yaml.ScalarNode)
+
+    base_path = loader.base_path
+    if isinstance(base_path, Traversable):
+        pass
+    else:
+        base_path = Path(base_path)
+
+    # obtain the actual file path from the scalar string node
+    filepath = loader.construct_scalar(node)
+
+    p = base_path / filepath
+
+    assert p.is_file(), f"File {p} does not exist"
+
+    # load the image from the provided logo path and convert it to base64
+    with as_file(p) as path:
+        with open(path, "rb") as f:
+            encoded = base64.b64encode(f.read()).decode("ascii")
+
+            # determine the file type from the file extension
+            kind = filetype.guess(f)
+            assert kind is not None
+
+            return f"data:{kind.mime};base64,{encoded}"
+
+
+class YamlConfiguration(Configuration):
+    def __init__(
+        self,
+        path_or_handle: Union[str, PathLikeStr, IO[str]],
+        base_path: Union[str, PathLikeStr, Traversable, None] = None,
+    ) -> None:
+        super().__init__()
+
+        if isinstance(path_or_handle, str):
+            path_or_handle = Path(path_or_handle)
+
+        if base_path is None:
+            assert isinstance(path_or_handle, Path) and os.path.isfile(
+                path_or_handle
+            ), f"File {path_or_handle} does not exist"
+            base_path = os.path.dirname(path_or_handle)
+
+        handle: IO[str]
+        if isinstance(path_or_handle, Path):
+            handle = path_or_handle.open()
+        elif hasattr(path_or_handle, "__fspath__"):
+            handle = open(path_or_handle)
+        else:
+            handle = path_or_handle
+
+        # we want to parse and process special tags (e.g. !image) in yaml files
+        # when loading a file with !image, the specified path should be relative to
+        # the yaml file itself
+        # --> need a custom loader that knows the path to the yaml file
+        class CustomLoader(yaml.SafeLoader, CustomLoaderLike):
+            def __init__(self, *args: Any, **kwargs: Any) -> None:
+                super().__init__(*args, **kwargs)
+                assert base_path is not None, "base_path is None"
+                self.base_path = base_path
+
+        yaml.add_constructor("!image", image_constructor, CustomLoader)
+
+        self.yaml = yaml.load(handle, Loader=CustomLoader)
+
+    def _get_dict(self) -> dict:
+        return self.yaml["module"]

nerdd_module-0.3.7/nerdd_module/converters/__init__.py

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

nerdd_module-0.3.7/nerdd_module/converters/converter.py

@@ -0,0 +1,62 @@
+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.7/nerdd_module/converters/identity_converter.py

@@ -0,0 +1,8 @@
+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.3 → nerdd_module-0.3.7}/nerdd_module/input/__init__.py

@@ -6,7 +6,6 @@ from .inchi_reader import *
 from .list_reader import *
 from .mol_reader import *
 from .reader import *
-from .reader_registry import *
 from .sdf_reader import *
 from .smiles_reader import *
 from .string_reader import *