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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nerdd-module
-Version: 0.3.9
+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,6 +57,7 @@ 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
@@ -77,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"

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

@@ -1,4 +1,5 @@
 import logging
+import os
 import sys
 from typing import Any, Callable
 
@@ -6,7 +7,10 @@ import rich_click as click
 from decorator import decorator
 from stringcase import spinalcase
 
+from .config import JobParameter
+from .input import Reader
 from .model import Model
+from .output import FileWriter, Writer
 
 __all__ = ["auto_cli"]
 
@@ -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)
 
     #

{nerdd_module-0.3.9 → 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.9 → 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.9 → 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.9 → 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.9 → 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"]
 
@@ -48,3 +49,5 @@ class FileReader(Reader):
 
     def __repr__(self) -> str:
         return f"FileReader(data_dir={self.data_dir})"
+
+    config = ReaderConfig(examples=["compounds.smiles"])

{nerdd_module-0.3.9 → 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"]
 
@@ -55,3 +56,9 @@ class InchiReader(Reader):
 
     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.9 → 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.9 → 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"]
 
@@ -65,3 +66,5 @@ class SmilesReader(Reader):
 
     def __repr__(self) -> str:
         return "SmilesReader()"
+
+    config = ReaderConfig(examples=["C1=NC2=C(N1COCCO)N=C(NC2=O)N"])

{nerdd_module-0.3.9 → nerdd_module-0.3.10}/nerdd_module/model/convert_representations_step.py

@@ -9,10 +9,12 @@ __all__ = ["ConvertRepresentationsStep"]
 class ConvertRepresentationsStep(MapStep):
     def __init__(self, result_properties: list, output_format: str, **kwargs: Any) -> None:
         super().__init__()
-        self._property_type_map = {
-            p["name"]: Converter.get_converter(p.get("type"), output_format, **kwargs)
+        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._property_type_map[k].convert(v, record) for k, v in record.items()}
+        return {
+            k: self._converter_map[k].convert(input=v, context=record) for k, v in record.items()
+        }

{nerdd_module-0.3.9 → nerdd_module-0.3.10}/nerdd_module/model/enforce_schema_step.py

@@ -12,7 +12,9 @@ logger = logging.getLogger(__name__)
 class EnforceSchemaStep(Step):
     def __init__(self, config: Configuration, output_format: str) -> None:
         super().__init__()
-        self._property_names = [p["name"] for p in config.get_visible_properties(output_format)]
+        self._property_names = [
+            p.name for p in config.get_dict().get_visible_properties(output_format)
+        ]
 
         # check that properties are unique
         if len(self._property_names) != len(set(self._property_names)):

{nerdd_module-0.3.9 → nerdd_module-0.3.10}/nerdd_module/model/model.py

@@ -6,6 +6,7 @@ from typing import Any, Iterable, Iterator, List, Optional, Tuple
 from rdkit.Chem import Mol
 from stringcase import snakecase  # type: ignore
 
+from ..config import JobParameter
 from ..problem import Problem
 from ..steps import OutputStep, Step
 from ..util import call_with_mappings
@@ -96,7 +97,7 @@ class Model(ABC):
 
     description = property(fget=lambda self: self._get_description())
 
-    def _get_job_parameters(self) -> List[dict]:
+    def _get_job_parameters(self) -> List[JobParameter]:
         return []
 
     job_parameters = property(fget=lambda self: self._get_job_parameters())

{nerdd_module-0.3.9 → nerdd_module-0.3.10}/nerdd_module/model/read_input_step.py

@@ -15,7 +15,7 @@ class ReadInputStep(Step):
     def _run(self, source: Iterator[dict]) -> Iterator[dict]:
         for entry in self._explorer.explore(self._input):
             record = dict(
-                raw_input=entry.raw_input,
+                input_text=entry.raw_input,
                 source=entry.source,
                 input_type=entry.input_type,
                 input_mol=entry.mol,

{nerdd_module-0.3.9 → nerdd_module-0.3.10}/nerdd_module/model/simple_model.py

@@ -7,7 +7,9 @@ from ..config import (
     Configuration,
     DefaultConfiguration,
     DictConfiguration,
+    JobParameter,
     MergedConfiguration,
+    Module,
     PackageConfiguration,
     SearchYamlConfiguration,
 )
@@ -64,7 +66,7 @@ class SimpleModel(Model):
         return [
             EnforceSchemaStep(self._get_config(), output_format),
             ConvertRepresentationsStep(
-                self.get_config().get("result_properties", []), output_format, **kwargs
+                self.get_config().result_properties, output_format, **kwargs
             ),
             WriteOutputStep(output_format, **kwargs),
         ]
@@ -105,7 +107,7 @@ class SimpleModel(Model):
         ]
 
         # add default properties mol_id, raw_input, etc.
-        task = MergedConfiguration(*configs).get_task()
+        task = MergedConfiguration(*configs).get_dict().task
 
         # check whether we need to add to add a property "atom_id" or "derivative_id"
         task_based_property = []
@@ -121,9 +123,9 @@ class SimpleModel(Model):
         default_properties_start = [
             {"name": "mol_id", "type": "integer"},
             *task_based_property,
-            {"name": "raw_input", "type": "string"},
+            {"name": "input_text", "type": "string"},
             {"name": "input_type", "type": "string"},
-            {"name": "source"},
+            {"name": "source", "type": "string"},
             {"name": "name", "type": "string"},
             {"name": "input_mol", "type": "mol"},
             {"name": "preprocessed_mol", "type": "mol"},
@@ -141,23 +143,23 @@ class SimpleModel(Model):
 
         return MergedConfiguration(*configs)
 
-    def get_config(self) -> dict:
+    def get_config(self) -> Module:
         return self._get_config().get_dict()
 
     def _get_batch_size(self) -> int:
         default = super()._get_batch_size()
-        return self.get_config().get("batch_size", default)
+        return self.get_config().batch_size or default
 
     def _get_name(self) -> str:
         default = super()._get_name()
-        return self.get_config().get("name", default)
+        return self.get_config().name or default
 
     def _get_description(self) -> str:
         default = super()._get_description()
-        return self.get_config().get("description", default)
+        return self.get_config().description or default
 
-    def _get_job_parameters(self) -> List[dict]:
-        return super()._get_job_parameters() + self.get_config().get("job_parameters", [])
+    def _get_job_parameters(self) -> List[JobParameter]:
+        return super()._get_job_parameters() + self.get_config().job_parameters
 
 
 class CustomPreprocessingStep(PreprocessingStep):

{nerdd_module-0.3.9 → nerdd_module-0.3.10}/nerdd_module/output/writer.py

@@ -46,6 +46,13 @@ class Writer(ABC):
             raise ValueError(f"Unknown output format: {output_format}")
         return _factories[output_format](kwargs)
 
+    @classmethod
+    def get_writers(cls, **kwargs: Any) -> Dict[str, Writer]:
+        return {
+            output_format: cls.get_writer(output_format, **kwargs)
+            for output_format in _factories.keys()
+        }
+
     @classmethod
     def get_output_formats(cls) -> List[str]:
         return list(_factories.keys())

{nerdd_module-0.3.9 → nerdd_module-0.3.10}/nerdd_module.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nerdd-module
-Version: 0.3.9
+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,6 +57,7 @@ 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
@@ -77,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"

{nerdd_module-0.3.9 → nerdd_module-0.3.10}/nerdd_module.egg-info/SOURCES.txt

@@ -16,6 +16,7 @@ nerdd_module/config/configuration.py
 nerdd_module/config/default_configuration.py
 nerdd_module/config/dict_configuration.py
 nerdd_module/config/merged_configuration.py
+nerdd_module/config/models.py
 nerdd_module/config/package_configuration.py
 nerdd_module/config/search_yaml_configuration.py
 nerdd_module/config/yaml_configuration.py
@@ -31,6 +32,7 @@ nerdd_module/input/inchi_reader.py
 nerdd_module/input/list_reader.py
 nerdd_module/input/mol_reader.py
 nerdd_module/input/reader.py
+nerdd_module/input/reader_config.py
 nerdd_module/input/sdf_reader.py
 nerdd_module/input/smiles_reader.py
 nerdd_module/input/string_reader.py

{nerdd_module-0.3.9 → nerdd_module-0.3.10}/nerdd_module.egg-info/requires.txt

@@ -4,6 +4,7 @@ filetype~=1.2.0
 rich-click>=1.7.1
 stringcase>=1.2.0
 decorator>=5.1.1
+pydantic>=2
 
 [:python_version < "3.10"]
 importlib-metadata>=4.6
@@ -37,7 +38,7 @@ pytest
 pytest-sugar
 pytest-cov
 pytest-asyncio
-pytest-bdd
+pytest-bdd==7.3.0
 pytest-mock
 pytest-watcher
 hypothesis

{nerdd_module-0.3.9 → nerdd_module-0.3.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nerdd-module"
-version = "0.3.9"
+version = "0.3.10"
 description = "Base package to create NERDD modules"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -17,6 +17,7 @@ dependencies = [
     "rich-click>=1.7.1",
     "stringcase>=1.2.0",
     "decorator>=5.1.1",
+    "pydantic>=2",
     # install importlib-resources and importlib-metadata for old Python versions
     "importlib-resources>=5; python_version<'3.9'",
     "importlib-metadata>=4.6; python_version<'3.10'",
@@ -76,7 +77,7 @@ test = [
     "pytest-sugar",
     "pytest-cov",
     "pytest-asyncio",
-    "pytest-bdd",
+    "pytest-bdd==7.3.0",
     "pytest-mock",
     "pytest-watcher",
     "hypothesis",
@@ -125,10 +126,12 @@ ignore = [
 ]
 
 [tool.mypy]
+# type stubs of packages lacking types are in the "typings" directory
 mypy_path="typings"
 # strict=true
 disallow_untyped_defs = true
-# no_implicit_optional = True
+# disallow_any_unimported = true
+no_implicit_optional = true
 # check_untyped_defs = True
 # show_error_codes = True 
 

nerdd_module-0.3.9/nerdd_module/config/configuration.py

@@ -1,91 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import List, Optional
-
-__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:
-        self._cached_config: Optional[dict] = None
-
-    def get_dict(self) -> dict:
-        if self._cached_config is None:
-            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."
-
-            self._cached_config = config
-
-        return self._cached_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()})"