Iterate on method_config

bw2calc/method_config.py

@@ -1,5 +1,56 @@
-from pydantic import BaseModel
+from typing import Iterable, Optional
+from pydantic import BaseModel, model_validator
 
 
 class MethodConfig(BaseModel):
-    pass
+    impact_categories: Iterable[tuple[str, ...]]
+    normalizations: Optional[dict[tuple[str, ...], tuple[str, ...]]] = None
+    weightings: Optional[dict[tuple[str, ...], tuple[str, ...]]] = None
+
+    @model_validator(mode='after')
+    def normalizations_reference_impact_categories(self):
+        if not self.normalizations:
+            return self
+        difference = set(self.normalizations).difference(set(self.impact_categories))
+        if difference:
+            raise ValueError(f"Impact categories in `normalizations` not present in `impact_categories`: {difference}")
+        return self
+
+    @model_validator(mode='after')
+    def unique_normalizations(self):
+        if self.normalizations:
+            overlap = set(self.normalizations.values()).intersection(set(self.impact_categories))
+            if overlap:
+                raise ValueError(f"Normalization identifiers overlap impact category identifiers: {overlap}")
+        return self
+
+    @model_validator(mode='after')
+    def weightings_reference_impact_categories_or_normalizations(self):
+        if not self.weightings:
+            return self
+        possibles = set(self.impact_categories)
+        if self.normalizations:
+            possibles = possibles.union(set(self.normalizations.values()))
+        difference = set(self.weightings).difference(possibles)
+        if difference:
+            raise ValueError(f"`weightings` refers to missing impact categories or normalizations: {difference}")
+        return self
+
+    @model_validator(mode='after')
+    def unique_weightings_to_impact_categories(self):
+        if not self.weightings:
+            return self
+        overlap = set(self.weightings.values()).intersection(set(self.impact_categories))
+        if overlap:
+            raise ValueError(f"Weighting identifiers overlap impact category identifiers: {overlap}")
+        return self
+
+    @model_validator(mode='after')
+    def unique_weightings_to_normalizations(self):
+        if not self.weightings:
+            return self
+        if self.normalizations:
+            overlap = set(self.weightings.values()).intersection(set(self.normalizations))
+            if overlap:
+                raise ValueError(f"Weighting identifiers overlap normalization identifiers: {overlap}")
+        return self

bw2calc/multi_lca.py

@@ -10,6 +10,7 @@
 import numpy as np
 from fs.base import FS
 from scipy import sparse
+from pydantic import BaseModel
 
 from . import PYPARDISO, __version__
 from .dictionary_manager import DictionaryManager
@@ -22,6 +23,10 @@
 logger = logging.getLogger("bw2calc")
 
 
+class DemandsValidator(BaseModel):
+    demands: dict[str, dict[int, float]]
+
+
 class MultiLCA(LCABase):
     matrix_labels = [
         "technosphere_mm",

tests/test_method_config.py

@@ -0,0 +1,21 @@
+from bw2calc.method_config import MethodConfig
+
+
+def test_method_config_valid():
+    data = {
+        'impact_categories': [('foo', 'a'), ('foo', 'b')],
+    }
+    assert MethodConfig(**data)
+
+    data = {
+        'impact_categories': [('foo', 'a'), ('foo', 'b')],
+        'normalizations': {('foo', 'a'): ('norm', 'standard'), ('foo', 'b'): ('norm', 'standard')}
+    }
+    assert MethodConfig(**data)
+
+    data = {
+        'impact_categories': [('foo', 'a'), ('foo', 'b')],
+        'normalizations': {('foo', 'a'): ('norm', 'standard'), ('foo', 'b'): ('norm', 'standard')},
+        'weightings': {('norm', 'standard'): ('weighting',)}
+    }
+    assert MethodConfig(**data)