nerdd-module 0.3.8__tar.gz → 0.3.10__tar.gz

{nerdd_module-0.3.8 → nerdd_module-0.3.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nerdd-module
-Version: 0.3.8
+Version: 0.3.10
 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>
@@ -57,15 +57,18 @@ 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: pydantic>=2
 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: mypy==1.13.0; 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"
 Provides-Extra: rdkit
 Requires-Dist: rdkit>=2022.3.3; extra == "rdkit"
 Provides-Extra: csp
@@ -75,7 +78,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; extra == "test"
+Requires-Dist: pytest-bdd==7.3.0; extra == "test"
 Requires-Dist: pytest-mock; extra == "test"
 Requires-Dist: pytest-watcher; extra == "test"
 Requires-Dist: hypothesis; extra == "test"
@@ -100,6 +103,7 @@ 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` 
+2. Install test dependencies with `pip install -e .[test,dev,csp]` 
+3. Install pre-commit hooks `pre-commit install`
+4. Run tests via `pytest` or `pytest-watch` (short: `ptw`)
+5. Build docs via `pip install -e .[docs]`  and `mkdocs serve` 

nerdd_module-0.3.10/README.md

@@ -0,0 +1,19 @@
+# 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. Install pre-commit hooks `pre-commit install`
+4. Run tests via `pytest` or `pytest-watch` (short: `ptw`)
+5. Build docs via `pip install -e .[docs]`  and `mkdocs serve` 

{nerdd_module-0.3.8 → nerdd_module-0.3.10}/nerdd_module/cli.py

@@ -1,18 +1,22 @@
 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 stringcase import spinalcase
 
+from .config import JobParameter
+from .input import Reader
 from .model import Model
+from .output import FileWriter, Writer
 
 __all__ = ["auto_cli"]
 
 input_description = """{description}
 
-INPUT molecules are provided as file paths or strings. The following formats are 
+INPUT molecules are provided as file paths or strings. The following formats are
 supported:
 
 {input_format_list}
@@ -21,25 +25,21 @@ Note that input formats shouldn't be mixed.
 """
 
 
-def infer_click_type(param: dict) -> click.ParamType:
-    if "choices" in param:
-        choices = [c["value"] for c in param["choices"]]
+def infer_click_type(param: JobParameter) -> click.ParamType:
+    if param.choices is not None:
+        choices = [c.value for c in param.choices]
         return click.Choice(choices)
 
     type_map = {
         "float": click.FLOAT,
-        "int": click.INT,
-        "str": click.STRING,
+        "integer": click.INT,
+        "string": click.STRING,
         "bool": click.BOOL,
     }
 
-    if "type" not in param:
-        raise ValueError(f"Parameter {param['name']} does not have a type")
-
-    t = param["type"]
-
+    t = param.type
     if t not in type_map:
-        raise ValueError(f"Unknown type {t} for parameter {param['name']}")
+        raise ValueError(f"Unknown type {t} for parameter {param.name}")
 
     return type_map[t]
 
@@ -47,7 +47,7 @@ def infer_click_type(param: dict) -> click.ParamType:
 @decorator
 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()
@@ -59,21 +59,33 @@ def auto_cli(f: Callable[..., Model], *args: Any, **kwargs: Any) -> None:
         description=model.description, input_format_list=input_format_list
     )
 
-    output_format_list = ["sdf", "csv"]
+    output_format_list = [
+        output_format
+        for output_format, writer in Writer.get_writers(output_file=None).items()
+        if isinstance(writer, FileWriter)
+    ]
 
     # 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 = ""
+    examples = []
+    if hasattr(model, "get_config"):
+        example_smiles = model.get_config().example_smiles
+        if example_smiles is not None:
+            examples.append(example_smiles)
+
+    for ReaderClass in Reader.get_reader_mapping():
+        if hasattr(ReaderClass, "config"):
+            reader_examples = ReaderClass.config.get("examples", [])
+            for example in reader_examples:
+                # check if example fits on one line
+                if len(example) < 120 and "\n" not in example:
+                    examples.append(example)
+
+    if len(examples) > 0:
+        footer = "Examples:\n"
+        for example in examples:
+            footer += f'* {command_name} "{example}"\n'
+    else:
+        footer = ""
 
     #
     # Define the CLI entry point
@@ -107,12 +119,12 @@ def auto_cli(f: Callable[..., Model], *args: Any, **kwargs: Any) -> None:
     #
     for param in model.job_parameters:
         # convert parameter name to spinal case (e.g. "max_confs" -> "max-confs")
-        param_name = spinalcase(param["name"])
+        param_name = spinalcase(param.name)
         main = click.option(
             f"--{param_name}",
-            default=param.get("default", None),
+            default=param.default,
             type=infer_click_type(param),
-            help=param.get("help_text", None),
+            help=param.help_text,
         )(main)
 
     #
@@ -157,4 +169,4 @@ def auto_cli(f: Callable[..., Model], *args: Any, **kwargs: Any) -> None:
     # 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()
+    main()

{nerdd_module-0.3.8 → nerdd_module-0.3.10}/nerdd_module/config/__init__.py

@@ -2,6 +2,7 @@ from .configuration import *
 from .default_configuration import *
 from .dict_configuration import *
 from .merged_configuration import *
+from .models import *
 from .package_configuration import *
 from .search_yaml_configuration import *
 from .yaml_configuration import *

nerdd_module-0.3.10/nerdd_module/config/configuration.py

@@ -0,0 +1,32 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from .models import Module
+
+__all__ = ["Configuration"]
+
+
+class Configuration(ABC):
+    def __init__(self) -> None:
+        self._cached_config: Optional[Module] = None
+
+    def get_dict(self) -> Module:
+        if self._cached_config is None:
+            config = self._get_dict()
+
+            # validate the config
+            module = Module(**config)
+
+            self._cached_config = module
+
+        return self._cached_config
+
+    @abstractmethod
+    def _get_dict(self) -> dict:
+        pass
+
+    def is_empty(self) -> bool:
+        return self.get_dict() == {}
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self._get_dict()})"

{nerdd_module-0.3.8 → nerdd_module-0.3.10}/nerdd_module/config/merged_configuration.py

@@ -41,4 +41,4 @@ def merge(*args: dict) -> dict:
 
 class MergedConfiguration(DictConfiguration):
     def __init__(self, *configs: Configuration):
-        super().__init__(merge(*[c.get_dict() for c in configs]))
+        super().__init__(merge(*[c._get_dict() for c in configs]))

nerdd_module-0.3.10/nerdd_module/config/models.py

@@ -0,0 +1,178 @@
+from typing import Any, List, Literal, Optional, Union
+
+from pydantic import BaseModel, model_validator
+
+
+class Partner(BaseModel):
+    name: str
+    logo: str
+    url: Optional[str] = None
+
+
+class Author(BaseModel):
+    """
+    Author information
+
+    Attributes:
+        first_name : str
+            First name of the author.
+        last_name : str
+            Last name of the author.
+        email : Optional[str]
+            Email of the author. If provided, the author is a corresponding author.
+    """
+
+    first_name: str
+    last_name: str
+    email: Optional[str] = None
+
+
+class Publication(BaseModel):
+    title: str
+    authors: List[Author] = []
+    journal: str
+    year: int
+    doi: Optional[str]
+
+
+class JobParameterChoice(BaseModel):
+    value: str
+    label: Optional[str] = None
+
+
+class JobParameter(BaseModel):
+    name: str
+    type: str
+    visible_name: Optional[str] = None
+    help_text: Optional[str] = None
+    default: Optional[str] = None
+    required: bool = False
+    choices: Optional[List[JobParameterChoice]] = None
+
+
+Task = Literal[
+    "molecular_property_prediction",
+    "atom_property_prediction",
+    "derivative_property_prediction",
+]
+Level = Literal["molecule", "atom", "derivative"]
+
+FormatSpec = Union[List[str], str]
+
+
+class IncludeExcludeFormatSpec(BaseModel):
+    include: Optional[FormatSpec]
+    exclude: Optional[FormatSpec]
+
+
+class ResultProperty(BaseModel):
+    name: str
+    type: str
+    visible_name: Optional[str] = None
+    help_text: Optional[str] = None
+    sortable: bool = False
+    group: Optional[str] = None
+    level: Level = "molecule"
+    formats: Union[FormatSpec, IncludeExcludeFormatSpec, None] = None
+    representation: Optional[str] = None
+
+    def is_visible(self, output_format: str) -> bool:
+        formats = self.formats
+
+        if formats is None:
+            return True
+        elif isinstance(formats, list):
+            return output_format in formats
+        elif isinstance(formats, IncludeExcludeFormatSpec):
+            include = formats.include
+            exclude = formats.exclude or []
+            return (include is None or output_format in include) and output_format not in exclude
+        else:
+            raise ValueError(f"Invalid formats declaration {formats} in result property {self}")
+
+
+class Module(BaseModel):
+    task: Optional[Task] = None
+    rank: Optional[int] = None
+    name: Optional[str] = None
+    batch_size: int = 100
+    version: Optional[str] = None
+    visible_name: Optional[str] = None
+    logo: Optional[str] = None
+    logo_title: Optional[str] = None
+    logo_caption: Optional[str] = None
+    example_smiles: Optional[str] = None
+    title: Optional[str] = None
+    description: Optional[str] = None
+    partners: List[Partner] = []
+    publications: List[Publication] = []
+    about: Optional[str] = None
+    job_parameters: List[JobParameter] = []
+    result_properties: List[ResultProperty] = []
+
+    def get_property_columns_of_type(self, t: Level) -> List[ResultProperty]:
+        return [c for c in self.result_properties if c.level == t]
+
+    def molecular_property_columns(self) -> List[ResultProperty]:
+        return self.get_property_columns_of_type("molecule")
+
+    def atom_property_columns(self) -> List[ResultProperty]:
+        return self.get_property_columns_of_type("atom")
+
+    def derivative_property_columns(self) -> List[ResultProperty]:
+        return self.get_property_columns_of_type("derivative")
+
+    def get_visible_properties(self, output_format: str) -> List[ResultProperty]:
+        return [p for p in self.result_properties if p.is_visible(output_format)]
+
+    @model_validator(mode="after")
+    @classmethod
+    def validate_model(cls, values: Any) -> Any:
+        assert isinstance(values, Module)
+
+        num_atom_properties = len(values.get_property_columns_of_type("atom"))
+        num_derivative_properties = len(values.get_property_columns_of_type("derivative"))
+        task = values.task
+        if task is None:
+            # if task is not specified, try to derive it from the result_properties
+            if num_atom_properties > 0:
+                task = "atom_property_prediction"
+            elif num_derivative_properties > 0:
+                task = "derivative_property_prediction"
+            else:
+                task = "molecular_property_prediction"
+
+            values.task = task
+        else:
+            # if task is specified, check if it is consistent with the result_properties
+            if num_atom_properties > 0:
+                assert (
+                    task == "atom_property_prediction"
+                ), "Task should be atom_property_prediction if atom properties are present."
+            elif num_derivative_properties > 0:
+                assert task == "derivative_property_prediction", (
+                    "Task should be derivative_property_prediction if derivative properties "
+                    "are present."
+                )
+            else:
+                assert task == "molecular_property_prediction", (
+                    "Task should be molecular_property_prediction if no atom or derivative "
+                    "properties are present."
+                )
+
+        # check that a module can only predict atom or derivative properties, not both
+        assert (
+            num_atom_properties == 0 or num_derivative_properties == 0
+        ), "A module can only predict atom or derivative properties, not both."
+
+        # check that two properties with the same group appear next to each other
+        groups = [p.group for p in values.result_properties if p.group is not None]
+        for group in groups:
+            indices = [i for i, p in enumerate(values.result_properties) if p.group == group]
+            for i, j in zip(indices[:-1], indices[1:]):
+                assert i + 1 == j, (
+                    f"Properties with the same group should appear next to each other, "
+                    f"but group {group} appears at incides {i} and {j}."
+                )
+
+        return values

{nerdd_module-0.3.8 → nerdd_module-0.3.10}/nerdd_module/config/package_configuration.py

@@ -32,4 +32,4 @@ class PackageConfiguration(Configuration):
                 self.config = DictConfiguration({})
 
     def _get_dict(self) -> dict:
-        return self.config.get_dict()
+        return self.config._get_dict()

{nerdd_module-0.3.8 → nerdd_module-0.3.10}/nerdd_module/config/search_yaml_configuration.py

@@ -34,4 +34,4 @@ class SearchYamlConfiguration(DictConfiguration):
                 logger.info(f"Found configuration file in project directory: {default_config_file}")
                 config = YamlConfiguration(default_config_file, base_path)
 
-        super().__init__(config.get_dict())
+        super().__init__(config._get_dict())

{nerdd_module-0.3.8 → nerdd_module-0.3.10}/nerdd_module/config/yaml_configuration.py

@@ -1,4 +1,5 @@
 import base64
+import mimetypes
 import os
 from pathlib import Path
 from typing import IO, Any, Union
@@ -42,9 +43,16 @@ def image_constructor(loader: CustomLoaderLike, node: yaml.Node) -> str:
 
             # determine the file type from the file extension
             kind = filetype.guess(f)
-            assert kind is not None
+            if kind is not None:
+                mime = kind.mime
+            else:
+                # For filetypes without magic headers (e.g. SVG), the filetype library
+                # doesn't work. In these cases, we try the mimetypes library.
+                mime, _ = mimetypes.guess_type(path)
 
-            return f"data:{kind.mime};base64,{encoded}"
+            assert mime is not None, f"Could not determine mime type for {path}"
+
+            return f"data:{mime};base64,{encoded}"
 
 
 class YamlConfiguration(Configuration):

{nerdd_module-0.3.8 → nerdd_module-0.3.10}/nerdd_module/input/depth_first_explorer.py

@@ -15,7 +15,7 @@ class InvalidInputReader(Reader):
         yield MoleculeEntry(
             raw_input=input,
             input_type="unknown",
-            source=tuple(["input"]),
+            source=("input",),
             mol=None,
             errors=[Problem("invalid_input", "Invalid input")],
         )

{nerdd_module-0.3.8 → nerdd_module-0.3.10}/nerdd_module/input/explorer.py

@@ -5,9 +5,6 @@ from .reader import MoleculeEntry, Reader
 
 
 class Explorer(ABC):
-    def __init__(self) -> None:
-        pass
-
     @abstractmethod
     def explore(self, input: Any) -> Iterator[MoleculeEntry]:
         pass

{nerdd_module-0.3.8 → nerdd_module-0.3.10}/nerdd_module/input/file_reader.py

@@ -3,6 +3,7 @@ from pathlib import Path
 from typing import Any, Iterator, Tuple, Union
 
 from .reader import ExploreCallable, MoleculeEntry, Reader
+from .reader_config import ReaderConfig
 
 __all__ = ["FileReader"]
 
@@ -20,8 +21,8 @@ class FileReader(Reader):
         # convert filename to path
         try:
             path = Path(filename)
-        except TypeError:
-            raise ValueError("input must be a valid path")
+        except TypeError as e:
+            raise ValueError("input must be a valid path") from e
 
         # convert to absolute path
         if not path.is_absolute():
@@ -44,7 +45,9 @@ class FileReader(Reader):
                     source: Tuple[str, ...] = tuple()
                 else:
                     source = entry.source
-                yield entry._replace(source=tuple([filename, *source]))
+                yield entry._replace(source=(filename, *source))
 
     def __repr__(self) -> str:
         return f"FileReader(data_dir={self.data_dir})"
+
+    config = ReaderConfig(examples=["compounds.smiles"])

{nerdd_module-0.3.8 → nerdd_module-0.3.10}/nerdd_module/input/inchi_reader.py

@@ -6,6 +6,7 @@ from rdkit.rdBase import BlockLogs
 
 from ..problem import Problem
 from .reader import ExploreCallable, MoleculeEntry, Reader
+from .reader_config import ReaderConfig
 
 __all__ = ["InchiReader"]
 
@@ -48,10 +49,16 @@ class InchiReader(Reader):
                 yield MoleculeEntry(
                     raw_input=line,
                     input_type="inchi",
-                    source=tuple(["raw_input"]),
+                    source=("raw_input",),
                     mol=mol,
                     errors=errors,
                 )
 
     def __repr__(self) -> str:
         return "InchiReader()"
+
+    config = ReaderConfig(
+        examples=[
+            "InChI=1S/C18H16O3/c1-2-13(12-8-4-3-5-9-12)16-17(19)14-10-6-7-11-15(14)21-18(16)20/h3-11,13,19H,2H2,1H3"
+        ]
+    )

{nerdd_module-0.3.8 → nerdd_module-0.3.10}/nerdd_module/input/mol_reader.py

@@ -14,7 +14,7 @@ class MolReader(Reader):
         yield MoleculeEntry(
             raw_input=mol,
             input_type="rdkit_mol",
-            source=tuple(["raw_input"]),
+            source=("raw_input",),
             mol=mol,
             errors=[],
         )

{nerdd_module-0.3.8 → nerdd_module-0.3.10}/nerdd_module/input/reader.py

@@ -1,12 +1,10 @@
 from __future__ import annotations
 
 import inspect
-from abc import ABC, ABCMeta, abstractmethod
-from functools import partial
+from abc import ABC, abstractmethod
 from typing import Any, Callable, Iterator, List, NamedTuple, Optional, Tuple, Type
 
 from rdkit.Chem import Mol
-from typing_extensions import Protocol
 
 from ..problem import Problem
 from ..util import call_with_mappings
@@ -25,34 +23,30 @@ class MoleculeEntry(NamedTuple):
 ExploreCallable = Callable[[Any], Iterator[MoleculeEntry]]
 
 
-class ReaderFactory(Protocol):
-    def __call__(self, config: dict, *args: Any, **kwargs: Any) -> Reader: ...
+_factories: List[Type["Reader"]] = []
 
 
-_factories: List[ReaderFactory] = []
-
-
-class ReaderMeta(ABCMeta):
-    def __init__(cls, name: str, bases: Tuple[type, ...], dct: dict) -> None:
-        super().__init__(name, bases, dct)
-
-        if not inspect.isabstract(cls):
-            _factories.append(
-                partial(
-                    call_with_mappings,
-                    cls,
-                )
-            )
-
-
-class Reader(ABC, metaclass=ReaderMeta):
+class Reader(ABC):
     def __init__(self) -> None:
         super().__init__()
 
+    @classmethod
+    def __init_subclass__(
+        cls,
+        **kwargs: Any,
+    ) -> None:
+        super().__init_subclass__(**kwargs)
+        if not inspect.isabstract(cls):
+            _factories.append(cls)
+
     @abstractmethod
     def read(self, input: Any, explore: ExploreCallable) -> Iterator[MoleculeEntry]:
         pass
 
+    @classmethod
+    def get_reader_mapping(cls: Type[Reader]) -> List[Type["Reader"]]:
+        return _factories
+
     @classmethod
     def get_readers(cls: Type[Reader], **kwargs: Any) -> List[Reader]:
-        return [factory(kwargs) for factory in _factories]
+        return [call_with_mappings(factory, kwargs) for factory in _factories]

nerdd_module-0.3.10/nerdd_module/input/reader_config.py

@@ -0,0 +1,7 @@
+from typing import List, TypedDict
+
+__all__ = ["ReaderConfig"]
+
+
+class ReaderConfig(TypedDict):
+    examples: List[str]

{nerdd_module-0.3.8 → nerdd_module-0.3.10}/nerdd_module/input/sdf_reader.py

@@ -61,7 +61,7 @@ class SdfReader(Reader):
                     yield MoleculeEntry(
                         raw_input=mol_block,
                         input_type="mol_block",
-                        source=tuple(["raw_input"]),
+                        source=("raw_input",),
                         mol=mol,
                         errors=errors,
                     )

{nerdd_module-0.3.8 → nerdd_module-0.3.10}/nerdd_module/input/smiles_reader.py

@@ -6,6 +6,7 @@ from rdkit.rdBase import BlockLogs
 
 from ..problem import Problem
 from .reader import ExploreCallable, MoleculeEntry, Reader
+from .reader_config import ReaderConfig
 
 __all__ = ["SmilesReader"]
 
@@ -58,10 +59,12 @@ class SmilesReader(Reader):
                 yield MoleculeEntry(
                     raw_input=line,
                     input_type="smiles",
-                    source=tuple(["raw_input"]),
+                    source=("raw_input",),
                     mol=mol,
                     errors=errors,
                 )
 
     def __repr__(self) -> str:
         return "SmilesReader()"
+
+    config = ReaderConfig(examples=["C1=NC2=C(N1COCCO)N=C(NC2=O)N"])

{nerdd_module-0.3.8 → nerdd_module-0.3.10}/nerdd_module/input/tar_reader.py

@@ -21,7 +21,7 @@ class TarReader(Reader):
                 if not member.isfile():
                     continue
                 for entry in explore(tar.extractfile(member)):
-                    yield entry._replace(source=tuple([member.name, *entry.source]))
+                    yield entry._replace(source=(member.name, *entry.source))
 
     def __repr__(self) -> str:
         return "TarReader()"