PyPI - nerdd-module - Versions diffs - 0.3.40__tar.gz → 0.3.42__tar.gz - Mend

@@ -51,15 +51,50 @@ class Choice(BaseModel):
     label: Optional[str] = None
+JobType = Literal["int", "integer", "float", "bool", "boolean", "str", "string"]
 class JobParameter(BaseModel):
     name: str
-    type: str
+    type: JobType
     visible_name: Optional[str] = None
     help_text: Optional[str] = None
     default: Any = None
     required: bool = False
     choices: Optional[List[Choice]] = None
+    def validate_value(self, value: Any) -> None:
+        if self.type == ["int", "integer"]:
+            if not isinstance(value, int):
+                raise ValueError(
+                    f"Parameter {self.name} must be an integer, got {type(value).__name__}."
+                )
+        elif self.type == "float":
+            if not isinstance(value, (int, float)):
+                raise ValueError(
+                    f"Parameter {self.name} must be a float, got {type(value).__name__}."
+                )
+        elif self.type in ["bool", "boolean"]:
+            if not isinstance(value, bool):
+                raise ValueError(
+                    f"Parameter {self.name} must be a boolean, got {type(value).__name__}."
+                )
+        elif self.type in ["str", "string"]:
+            if not isinstance(value, str):
+                raise ValueError(
+                    f"Parameter {self.name} must be a string, got {type(value).__name__}."
+                )
+        else:
+            raise ValueError(f"Unknown type for parameter {self.name}: {self.type}")
+        if self.choices:
+            choice_values = [choice.value for choice in self.choices]
+            if value not in choice_values:
+                raise ValueError(
+                    f"Invalid value for parameter {self.name}: {value}. "
+                    f"Expected one of {choice_values}."
+                )
 Task = Literal[
     "molecular_property_prediction",
@@ -207,3 +242,25 @@ class Module(BaseModel):
                 )
         return values
+    def validate_job_parameters(self, params: dict) -> None:
+        """
+        Validate the job parameters against the module's job parameters.
+        Raises an error if a parameter is missing or has an invalid type.
+        """
+        # make sure that all job parameters are present
+        for param in self.job_parameters:
+            if param.name not in params and param.required:
+                raise ValueError(f"Missing required job parameter: {param.name}")
+        # check that there are no additional parameters
+        param_names = {param.name for param in self.job_parameters}
+        for key in params.keys():
+            if key not in param_names:
+                raise ValueError(f"Unknown job parameter: {key}")
+        # validate all parameters
+        for param in self.job_parameters:
+            if param.name in params:
+                value = params[param.name]
+                param.validate_value(value)

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nerdd-module
-Version: 0.3.40
+Version: 0.3.42
 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>

@@ -0,0 +1,49 @@
+from typing import Any, Callable
+from ..config import Module, ResultProperty
+from .converter import Converter
+from .converter_config import ALL, ConverterConfig
+__all__ = ["BasicTypeConverter", "basic_data_types"]
+basic_data_types = [
+    "int",
+    "float",
+    "string",
+    "bool",
+]
+class BasicTypeConverter(Converter):
+    def __init__(
+        self,
+        module_config: Module,
+        result_property: ResultProperty,
+        output_format: str,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(module_config, result_property, output_format, **kwargs)
+        self.type = self.result_property.type
+        self._f: Callable[[Any], Any]
+        if self.type == "int":
+            self._f = int
+        elif self.type == "float":
+            self._f = float
+        elif self.type == "string":
+            self._f = str
+        elif self.type == "bool":
+            self._f = bool
+        else:
+            self._f = lambda v: v
+    def _convert(self, input: Any, context: dict) -> Any:
+        if input is None:
+            return None
+        return self._f(input)
+    config = ConverterConfig(
+        data_types=basic_data_types,
+        output_formats=ALL,
+    )

@@ -52,13 +52,21 @@ def predictions_atomic_mass_model(representations, version, multiplier):
     "all results are considered",
     target_fixture="subset",
 )
-def subset_without_none(predictions):
+def all_results(predictions):
     return predictions
 @when(
     "the subset of the result where the input was not None is considered",
     target_fixture="subset",
 )
-def subset_without_none(predictions):
+def subset_without_input_none(predictions):
     # remove None entries
     return [p for p in predictions if p["input_mol"] is not None]
+@when(
+    "the subset of the result where the preprocessed mol was not None is considered",
+    target_fixture="subset",
+)
+def subset_without_preprocessed_none(predictions):
+    # remove None entries
+    return [p for p in predictions if p["preprocessed_mol"] is not None]

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nerdd-module
-Version: 0.3.40
+Version: 0.3.42
 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>

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "nerdd-module"
-version = "0.3.40"
+version = "0.3.42"
 description = "Base package to create NERDD modules"
 readme = "README.md"
 license = "BSD-3-Clause"

nerdd-module 0.3.40__tar.gz → 0.3.42__tar.gz

nerdd-module 0.3.40tar.gz → 0.3.42tar.gz