Merge pull request #441 from neutrons/EWM6091_reduction_output_workspace_names

reduction output-workspace names

Author: ekapadi

src/snapred/backend/dao/ingredients/CalibrationMetricsWorkspaceIngredients.py

@@ -16,4 +16,4 @@ class CalibrationMetricsWorkspaceIngredients(BaseModel):
     """
 
     calibrationRecord: CalibrationRecord
-    timestamp: Optional[int] = None
+    timestamp: Optional[float] = None

src/snapred/backend/dao/ingredients/ReductionIngredients.py

@@ -11,13 +11,15 @@
 from snapred.backend.dao.ingredients.PreprocessReductionIngredients import PreprocessReductionIngredients
 from snapred.backend.dao.ingredients.ReductionGroupProcessingIngredients import ReductionGroupProcessingIngredients
 from snapred.backend.dao.state.PixelGroup import PixelGroup
-from snapred.meta.mantid.WorkspaceNameGenerator import WorkspaceName
 
 
 class ReductionIngredients(BaseModel):
     """Data class to hold the ingredients for each subrecipe of reduction and itself"""
 
-    maskList: List[WorkspaceName]
+    runNumber: str
+    useLiteMode: bool
+    timestamp: float
+
     pixelGroups: List[PixelGroup]
     detectorPeaksMany: List[List[GroupPeakList]]
 
@@ -31,7 +33,7 @@ class ReductionIngredients(BaseModel):
     #
     def preprocess(self) -> PreprocessReductionIngredients:
         # Note: at present, there are no required parameters.
-        return PreprocessReductionIngredients(maskList=None)
+        return PreprocessReductionIngredients()
 
     def groupProcessing(self, groupingIndex: int) -> ReductionGroupProcessingIngredients:
         return ReductionGroupProcessingIngredients(pixelGroup=self.pixelGroups[groupingIndex])
@@ -50,6 +52,4 @@ def applyNormalization(self, groupingIndex: int) -> ApplyNormalizationIngredient
 
     model_config = ConfigDict(
         extra="forbid",
-        # required in order to use 'WorkspaceName'
-        arbitrary_types_allowed=True,
     )

src/snapred/backend/dao/reduction/ReductionRecord.py

@@ -1,10 +1,9 @@
-from typing import Any, Dict, List
+from typing import Dict, List
 
-from pydantic import BaseModel, ConfigDict, ValidationError, field_validator, model_validator
+from pydantic import BaseModel, ConfigDict, Field
 
 from snapred.backend.dao.calibration.CalibrationRecord import CalibrationRecord
 from snapred.backend.dao.normalization.NormalizationRecord import NormalizationRecord
-from snapred.backend.dao.ObjectSHA import ObjectSHA
 from snapred.backend.dao.state.PixelGroupingParameters import PixelGroupingParameters
 from snapred.meta.mantid.WorkspaceNameGenerator import WorkspaceName
 
@@ -17,35 +16,19 @@ class ReductionRecord(BaseModel):
     calibration, normalization, and pixel grouping details.
     """
 
-    runNumbers: List[str]
+    # Reduction has distinct registration attributes from Calibration and Normalization.
+    #   for this reason, this class is not derived from 'Record',
+    #   and does not include a 'CalculationParameters' instance.
     useLiteMode: bool
+    timestamp: float = Field(frozen=True, default=None)
+
+    # specific to reduction records
+    runNumber: str
     calibration: CalibrationRecord
     normalization: NormalizationRecord
     pixelGroupingParameters: Dict[str, List[PixelGroupingParameters]]
-    version: int
-    stateId: ObjectSHA
-    workspaceNames: List[WorkspaceName]
-
-    @field_validator("stateId", mode="before")
-    @classmethod
-    def str_to_ObjectSHA(cls, v: Any) -> Any:
-        # ObjectSHA to be stored in JSON as _only_ a single hex string, for the hex digest itself
-        if isinstance(v, str):
-            return ObjectSHA(hex=v, decodedKey=None)
-        return v
 
-    @model_validator(mode="after")
-    def checkStateId(self):
-        cal = self.calibration
-        norm = self.normalization
-        redStateId = self.stateId
-
-        calStateId = cal.calibrationFittingIngredients.instrumentState.id
-        normStateId = norm.calibration.instrumentState.id
-        if not (calStateId == normStateId == redStateId):
-            raise ValidationError("Calibration, normalization, and reduction records are not from the same state.")
-
-        return self
+    workspaceNames: List[WorkspaceName]
 
     model_config = ConfigDict(
         # required in order to use 'WorkspaceName'

src/snapred/backend/dao/request/FarmFreshIngredients.py

@@ -1,12 +1,15 @@
-from typing import Any, List, Optional, Union
+from typing import Any, List, NamedTuple, Optional
 
-from pydantic import BaseModel, ConfigDict, field_validator
+from pydantic import BaseModel, ConfigDict, field_validator, model_validator
 
 from snapred.backend.dao.Limit import Limit, Pair
 from snapred.backend.dao.state import FocusGroup
 from snapred.meta.Config import Config
 from snapred.meta.mantid.AllowedPeakTypes import SymmetricPeakEnum
 
+# TODO: this declaration is duplicated in `ReductionRequest`.
+Versions = NamedTuple("Versions", [("calibration", Optional[int]), ("normalization", Optional[int])])
+
 
 class FarmFreshIngredients(BaseModel, extra="forbid"):
     """
@@ -17,9 +20,25 @@ class FarmFreshIngredients(BaseModel, extra="forbid"):
     # Do NOT use inside ingredients for algorithms
 
     runNumber: str
-    version: Optional[str] = None
+
+    versions: Versions = Versions(None, None)
+    # allow 'versions' to be accessed as a single version,
+    #   or, to be accessed ambiguously
+
+    @property
+    def version(self) -> Optional[int]:
+        if self.versions.calibration is not None and self.versions.normalization is not None:
+            raise RuntimeError("accessing 'version' property when 'versions' is non-singular")
+        return self.versions[0]
+
+    @version.setter
+    def version(self, v: Optional[int]):
+        self.versions = (v, None)
+
     useLiteMode: bool
-    focusGroup: Union[FocusGroup, List[FocusGroup]]
+
+    ## mandatory for reduction
+    timestamp: Optional[float] = None
 
     ## needs to be mandatory for diffcal
     cifPath: Optional[str] = None
@@ -40,6 +59,28 @@ class FarmFreshIngredients(BaseModel, extra="forbid"):
     fwhmMultipliers: Pair[float] = Pair.model_validate(Config["calibration.parameters.default.FWHMMultiplier"])
     maxChiSq: Optional[float] = Config["constants.GroupDiffractionCalibration.MaxChiSq"]
 
+    focusGroups: Optional[List[FocusGroup]] = None
+
+    # Allow 'focusGroups' to be accessed as a single 'focusGroup'
+    @property
+    def focusGroup(self) -> FocusGroup:
+        if len(self.focusGroups) > 1:
+            raise RuntimeError("accessing 'focusGroup' property when 'focusGroups' is non-singular")
+        return self.focusGroups[0]
+
+    @focusGroup.setter
+    def focusGroup(self, fg: FocusGroup):
+        if fg is None:
+            raise ValueError("'focusGroup' is None")
+        self.focusGroups = [fg]
+
+    @field_validator("versions")
+    @classmethod
+    def validate_versions(cls, v) -> Versions:
+        if not isinstance(v, Versions):
+            v = Versions(v)
+        return v
+
     @field_validator("crystalDBounds", mode="before")
     @classmethod
     def validate_crystalDBounds(cls, v: Any) -> Limit[float]:
@@ -60,4 +101,18 @@ def validate_fwhmMultipliers(cls, v: Any) -> Pair[float]:
             v = Pair[float](**v.dict())
         return v
 
+    @model_validator(mode="before")
+    @classmethod
+    def validate_focusGroups(cls, v: Any):
+        if isinstance(v, dict):
+            if "focusGroup" in v:
+                if "focusGroups" in v:
+                    raise ValueError("initialization with both 'focusGroup' and 'focusGroups' properties")
+                fg = v["focusGroup"]
+                if fg is None:
+                    raise ValueError("'focusGroup' is None")
+                v["focusGroups"] = [fg]
+                del v["focusGroup"]
+        return v
+
     model_config = ConfigDict(extra="forbid")

src/snapred/backend/dao/request/ReductionRequest.py

@@ -1,17 +1,22 @@
-from typing import List, Literal, Optional, Union
+from typing import List, NamedTuple, Optional, Union
 
 from pydantic import BaseModel, ConfigDict
 
 from snapred.backend.dao.state.FocusGroup import FocusGroup
 from snapred.backend.error.ContinueWarning import ContinueWarning
 
+Versions = NamedTuple("Versions", [("calibration", Optional[int]), ("normalization", Optional[int])])
+
 
 class ReductionRequest(BaseModel):
     runNumber: Union[str, List[str]]
     useLiteMode: bool
+    timestamp: Optional[float] = None
     focusGroups: List[FocusGroup] = []
-    userSelectedMaskPath: Optional[str] = None
-    version: Union[int, Literal["*"]] = "*"
+
+    # Calibration and normalization versions:
+    #   `None` => <use latest version>
+    versions: Versions = Versions(None, None)
 
     # TODO: Move to SNAPRequest
     continueFlags: Optional[ContinueWarning.Type] = None

src/snapred/backend/data/DataExportService.py

@@ -1,5 +1,5 @@
+import time
 from pathlib import Path
-from typing import Optional
 
 from pydantic import validate_call
 
@@ -41,6 +41,9 @@ def getFullLiteDataFilePath(self, runNumber: str) -> Path:
         fileName = Config[pre] + str(runNumber) + Config[ext]
         return Path(path, fileName)
 
+    def getUniqueTimestamp(self) -> time.struct_time:
+        return self.dataService.getUniqueTimestamp()
+
     ##### REDUCTION METHODS #####
 
     # NOTE will be added shortly
@@ -79,11 +82,11 @@ def exportNormalizationState(self, normalization: Normalization):
 
     ##### REDUCTION METHODS #####
 
-    def exportReductionRecord(self, record: ReductionRecord, version: Optional[int] = None) -> ReductionRecord:
-        return self.dataService.writeReductionRecord(record, version)
+    def exportReductionRecord(self, record: ReductionRecord):
+        self.dataService.writeReductionRecord(record)
 
     def exportReductionData(self, record: ReductionRecord):
-        return self.dataService.writeReductionData(record)
+        self.dataService.writeReductionData(record)
 
     ##### WORKSPACE METHODS #####