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

nerdd_module-0.3.6/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.1
+Name: nerdd-module
+Version: 0.3.6
+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.6/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.2.6 → nerdd_module-0.3.6}/nerdd_module/__init__.py

@@ -1,10 +1,8 @@
-from .abstract_model import *
 from .cli import *
-from .config import *
+from .model import *
+from .polyfills import get_entry_points
 from .problem import *
 from .version import *
-from .polyfills import get_entry_points
-
 
 for entry_point in get_entry_points("nerdd-module.plugins"):
     entry_point.load()

{nerdd_module-0.2.6 → nerdd_module-0.3.6}/nerdd_module/cli.py

@@ -1,11 +1,12 @@
 import logging
-import os
 import sys
+from typing import Any, Callable
 
 import rich_click as click
 from decorator import decorator
-from nerdd_module.output import WriterRegistry
-from stringcase import spinalcase
+from stringcase import spinalcase  # type: ignore
+
+from .model import Model
 
 __all__ = ["auto_cli"]
 
@@ -14,100 +15,97 @@ input_description = """{description}
 INPUT molecules are provided as file paths or strings. The following formats are 
 supported:
 
-{format_list}
+{input_format_list}
 
 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().get_dict()
-
     # compose cli description
-    description = config.get("description", "")
-
-    format_list = "\n".join([f"* {fmt}" for fmt in ["smiles", "sdf", "inchi"]])
+    input_format_list = "\n".join([f"* {fmt}" for fmt in ["smiles", "sdf", "inchi"]])
 
     help_text = input_description.format(
-        description=description, format_list=format_list
+        description=model.description, input_format_list=input_format_list
     )
 
-    # compose footer with examples
-    examples = []
-    if "example_smiles" in config:
-        examples.append(config["example_smiles"])
+    output_format_list = ["sdf", "csv"]
 
-    if len(examples) > 0:
-        footer = "Examples:\n"
-        for example in examples:
-            footer += f'* {command_name} "{example}"\n'
-    else:
-        footer = ""
+    # compose footer with examples
+    # 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())
 
-        df_result = model.predict(input, **kwargs)
-
         # write results
-        assert format in WriterRegistry().supported_formats
-        writer = WriterRegistry().get_writer(format)
+        assert format in output_format_list, f"Unknown output format: {format}"
 
-        if output.lower() == "stdout":
-            assert not writer.writes_bytes, "stdout does not support binary output"
+        if str(output).lower() == "stdout":
             output_handle = sys.stdout
         else:
-            mode = "wb" if writer.writes_bytes else "w"
-            output_handle = click.open_file(output, mode)
+            output_handle = click.open_file(str(output), "wb")
 
-        entries = (tup._asdict() for tup in df_result.itertuples(index=False))
-        writer.write(output_handle, entries)
+        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(
@@ -130,17 +128,33 @@ def auto_cli(f, *args, **kwargs):
     main = click.option(
         "--format",
         default="csv",
-        type=click.Choice(WriterRegistry().supported_formats, case_sensitive=False),
+        type=click.Choice(output_format_list, case_sensitive=False),
         help="The output format.",
     )(main)
 
     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.2.6 → nerdd_module-0.3.6}/nerdd_module/config/__init__.py

@@ -1,7 +1,7 @@
-from .auto_configuration import *
 from .configuration import *
 from .default_configuration import *
 from .dict_configuration import *
 from .merged_configuration import *
 from .package_configuration import *
+from .search_yaml_configuration import *
 from .yaml_configuration import *

nerdd_module-0.3.6/nerdd_module/config/configuration.py

@@ -0,0 +1,90 @@
+from abc import ABC, abstractmethod
+from functools import lru_cache
+from typing import List
+
+__all__ = ["Configuration"]
+
+
+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) -> None:
+        pass
+
+    @lru_cache(1)
+    def get_dict(self) -> dict:
+        config = self._get_dict()
+
+        if "result_properties" not in config:
+            config["result_properties"] = []
+
+        # 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"))
+        assert (
+            num_atom_properties == 0 or num_derivative_properties == 0
+        ), "A module can only predict atom or derivative properties, not both."
+
+        return config
+
+    @abstractmethod
+    def _get_dict(self) -> dict:
+        pass
+
+    def is_empty(self) -> bool:
+        return self.get_dict() == {}
+
+    def molecular_property_columns(self) -> List[dict]:
+        return get_property_columns_of_type(self.get_dict(), "molecule")
+
+    def atom_property_columns(self) -> List[dict]:
+        return get_property_columns_of_type(self.get_dict(), "atom")
+
+    def derivative_property_columns(self) -> List[dict]:
+        return get_property_columns_of_type(self.get_dict(), "derivative")
+
+    def get_task(self) -> str:
+        # if task is specified in the config, use that
+        config = self.get_dict()
+        if "task" in config:
+            return config["task"]
+
+        # try to derive the task from the result_properties
+        num_atom_properties = len(self.atom_property_columns())
+        num_derivative_properties = len(self.derivative_property_columns())
+
+        if num_atom_properties > 0:
+            return "atom_property_prediction"
+        elif num_derivative_properties > 0:
+            return "derivative_property_prediction"
+        else:
+            return "molecular_property_prediction"
+
+    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) -> str:
+        return f"{self.__class__.__name__}({self._get_dict()})"

{nerdd_module-0.2.6 → nerdd_module-0.3.6}/nerdd_module/config/default_configuration.py

@@ -1,15 +1,15 @@
-from stringcase import snakecase
+from typing import Any
+
+from stringcase import snakecase  # type: ignore
 
 from ..polyfills import version
-from .configuration import Configuration
+from .dict_configuration import DictConfiguration
 
 __all__ = ["DefaultConfiguration"]
 
 
-class DefaultConfiguration(Configuration):
-    def __init__(self, nerdd_module):
-        super().__init__()
-
+class DefaultConfiguration(DictConfiguration):
+    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"):
@@ -25,17 +25,15 @@ class DefaultConfiguration(Configuration):
         try:
             module = nerdd_module.__module__
             root_module = module.split(".", 1)[0]
-            version_ = version(root_module)
+            package_version = version(root_module)
         except ModuleNotFoundError:
-            pass
+            package_version = "0.0.1"
 
-        self.config = dict(
+        config = dict(
             name=name,
-            version=version_,
-            task="molecular_property_prediction",
+            version=package_version,
             job_parameters=[],
             result_properties=[],
         )
 
-    def _get_dict(self):
-        return self.config
+        super().__init__(config)

{nerdd_module-0.2.6 → nerdd_module-0.3.6}/nerdd_module/config/dict_configuration.py

@@ -4,10 +4,9 @@ __all__ = ["DictConfiguration"]
 
 
 class DictConfiguration(Configuration):
-    def __init__(self, config):
+    def __init__(self, config: dict) -> None:
         super().__init__()
+        self._config = config
 
-        self.config = config
-
-    def _get_dict(self):
-        return self.config
+    def _get_dict(self) -> dict:
+        return self._config

nerdd_module-0.3.6/nerdd_module/config/merged_configuration.py

@@ -0,0 +1,44 @@
+from collections import Counter
+
+from .configuration import Configuration
+from .dict_configuration import DictConfiguration
+
+__all__ = ["MergedConfiguration"]
+
+
+def merge(*args: dict) -> dict:
+    assert len(args) > 0
+
+    first_entry = args[0]
+    assert all(isinstance(d, type(first_entry)) for d in args)
+
+    if isinstance(first_entry, list):
+        return [e for d in args for e in d]
+    if isinstance(first_entry, dict):
+        count_fields = Counter([k for d in args for k in d.keys()])
+
+        # merge fields that occur in multiple dicts
+        overlapping_fields = [k for k, v in count_fields.items() if v > 1]
+        merged_overlapping_fields = {
+            k: merge(*[d[k] for d in args if k in d]) for k in overlapping_fields
+        }
+
+        # collect fields that occur in only one dict
+        non_overlapping_fields = [k for k, v in count_fields.items() if v == 1]
+        merged_non_overlapping_fields = {
+            k: v for d in args for k, v in d.items() if k in non_overlapping_fields
+        }
+
+        return {
+            **merged_non_overlapping_fields,
+            **merged_overlapping_fields,
+        }
+    else:
+        # merge all configurations starting from the first one
+        # --> last configuration has the highest priority
+        return args[-1]
+
+
+class MergedConfiguration(DictConfiguration):
+    def __init__(self, *configs: Configuration):
+        super().__init__(merge(*[c.get_dict() for c in configs]))

{nerdd_module-0.2.6 → nerdd_module-0.3.6}/nerdd_module/config/package_configuration.py

@@ -1,3 +1,5 @@
+import logging
+
 from ..polyfills import files
 from .configuration import Configuration
 from .dict_configuration import DictConfiguration
@@ -5,9 +7,11 @@ from .yaml_configuration import YamlConfiguration
 
 __all__ = ["PackageConfiguration"]
 
+logger = logging.getLogger(__name__)
+
 
 class PackageConfiguration(Configuration):
-    def __init__(self, package):
+    def __init__(self, package: str) -> None:
         super().__init__()
 
         # get the resource directory
@@ -16,16 +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():
-                self.config = YamlConfiguration(config_file, base_path=root_dir)
+            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.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.6/nerdd_module/config/search_yaml_configuration.py

@@ -0,0 +1,37 @@
+import logging
+import os
+from typing import Optional
+
+from .configuration import Configuration
+from .dict_configuration import DictConfiguration
+from .yaml_configuration import YamlConfiguration
+
+__all__ = ["SearchYamlConfiguration"]
+
+logger = logging.getLogger(__name__)
+
+
+class SearchYamlConfiguration(DictConfiguration):
+    def __init__(self, start: str, base_path: Optional[str] = None) -> None:
+        # provide a default configuration if no configuration file is found
+        config: Configuration = DictConfiguration({})
+
+        if start is not None:
+            # start at the directory containing the file where nerdd_module_class is
+            # defined and go up the directory tree until nerdd.yml is found (or root is
+            # reached)
+            leaf = start
+            while True:
+                if os.path.isfile(os.path.join(leaf, "nerdd.yml")):
+                    default_config_file = os.path.join(leaf, "nerdd.yml")
+                    break
+                elif leaf == os.path.dirname(leaf):  # reached root
+                    default_config_file = None
+                    break
+                leaf = os.path.dirname(leaf)
+
+            if default_config_file is not None:
+                logger.info(f"Found configuration file in project directory: {default_config_file}")
+                config = YamlConfiguration(default_config_file, base_path)
+
+        super().__init__(config.get_dict())