ChessAnalysisPipeline 0.0.15__py3-none-any.whl → 0.0.16__py3-none-any.whl

CHAP/common/models/map.py

@@ -15,16 +15,17 @@ from typing import (
 import numpy as np
 from pydantic import (
     BaseModel,
+    Field,
+    FilePath,
+    PrivateAttr,
     conint,
     conlist,
     constr,
-    FilePath,
-    PrivateAttr,
-    root_validator,
-    validator,
+    field_validator,
+    model_validator,
 )
 from pyspec.file.spec import FileSpec
-
+from typing_extensions import Annotated
 
 class Sample(BaseModel):
     """Class representing a sample metadata configuration.
@@ -35,7 +36,7 @@ class Sample(BaseModel):
     :type description: str, optional
     """
     name: constr(min_length=1)
-    description: Optional[str]
+    description: Optional[str] = ''
 
 
 class SpecScans(BaseModel):
@@ -44,24 +45,23 @@ class SpecScans(BaseModel):
     :ivar spec_file: Path to the SPEC file.
     :type spec_file: str
     :ivar scan_numbers: List of scan numbers to use.
-    :type scan_numbers: list[int]
+    :type scan_numbers: Union(int, list[int], str)
     :ivar par_file: Path to a non-default SMB par file.
     :type par_file: str, optional
     """
     spec_file: FilePath
-    scan_numbers: conlist(item_type=conint(gt=0), min_items=1)
-    par_file: Optional[FilePath]
+    scan_numbers: conlist(item_type=conint(gt=0), min_length=1)
+    par_file: Optional[FilePath] = None
 
-    @validator('spec_file', allow_reuse=True)
-    def validate_spec_file(cls, spec_file, values):
+    @field_validator('spec_file')
+    @classmethod
+    def validate_spec_file(cls, spec_file):
         """Validate the specified SPEC file.
 
         :param spec_file: Path to the SPEC file.
         :type spec_file: str
-        :param values: Dictionary of validated class field values.
-        :type values: dict
         :raises ValueError: If the SPEC file is invalid.
-        :return: Absolute path to the SPEC file, if it is valid.
+        :return: Absolute path to the SPEC file.
         :rtype: str
         """
         try:
@@ -71,26 +71,29 @@ class SpecScans(BaseModel):
             raise ValueError(f'Invalid SPEC file {spec_file}')
         return spec_file
 
-    @validator('scan_numbers', pre=True, allow_reuse=True)
-    def validate_scan_numbers(cls, scan_numbers, values):
+    @field_validator('scan_numbers', mode='before')
+    @classmethod
+    def validate_scan_numbers(cls, scan_numbers, info):
         """Validate the specified list of scan numbers.
 
         :param scan_numbers: List of scan numbers.
-        :type scan_numbers: list of int
-        :param values: Dictionary of validated class field values.
-        :type values: dict
+        :type scan_numbers: Union(int, list[int], str)
+        :param info: Pydantic validator info object.
+        :type info: pydantic_core._pydantic_core.ValidationInfo
         :raises ValueError: If a specified scan number is not found in
             the SPEC file.
         :return: List of scan numbers.
-        :rtype: list of int
+        :rtype: list[int]
         """
-        if isinstance(scan_numbers, str):
+        if isinstance(scan_numbers, int):
+            scan_numbers = [scan_numbers]
+        elif isinstance(scan_numbers, str):
             # Local modules
             from CHAP.utils.general import string_to_list
 
             scan_numbers = string_to_list(scan_numbers)
 
-        spec_file = values.get('spec_file')
+        spec_file = info.data.get('spec_file')
         if spec_file is not None:
             spec_scans = FileSpec(spec_file)
             for scan_number in scan_numbers:
@@ -100,16 +103,15 @@ class SpecScans(BaseModel):
                         f'No scan number {scan_number} in {spec_file}')
         return scan_numbers
 
-    @validator('par_file', allow_reuse=True)
-    def validate_par_file(cls, par_file, values):
+    @field_validator('par_file')
+    @classmethod
+    def validate_par_file(cls, par_file):
         """Validate the specified SMB par file.
 
         :param par_file: Path to a non-default SMB par file.
         :type par_file: str
-        :param values: Dictionary of validated class field values.
-        :type values: dict
         :raises ValueError: If the SMB par file is invalid.
-        :return: Absolute path to the SMB par file, if it is valid.
+        :return: Absolute path to the SMB par file.
         :rtype: str
         """
         if par_file is None or not par_file:
@@ -244,7 +246,8 @@ class PointByPointScanData(BaseModel):
                        'smb_par', 'expression']
     name: constr(strip_whitespace=True, min_length=1)
 
-    @validator('label')
+    @field_validator('label')
+    @classmethod
     def validate_label(cls, label):
         """Validate that the supplied `label` does not conflict with
         any of the values for `label` reserved for certain data needed
@@ -253,8 +256,7 @@ class PointByPointScanData(BaseModel):
         :param label: The value of `label` to validate.
         :type label: str
         :raises ValueError: If `label` is one of the reserved values.
-        :return: The original supplied value `label`, if it is
-            allowed.
+        :return: The originally supplied value `label`.
         :rtype: str
         """
         if ((not issubclass(cls,CorrectionsData))
@@ -329,6 +331,7 @@ class PointByPointScanData(BaseModel):
            needed for evaluating the expression.
         :return: None
         """
+        # Third party modules
         from ast import parse
         from asteval import get_ast_names
 
@@ -401,7 +404,7 @@ class PointByPointScanData(BaseModel):
             return get_smb_par_value(spec_scans.spec_file,
                                      scan_number,
                                      self.name)
-        elif self.data_type == 'expression':
+        if self.data_type == 'expression':
             return get_expression_value(spec_scans,
                                         scan_number,
                                         scan_step_index,
@@ -526,8 +529,10 @@ def get_expression_value(spec_scans:SpecScans, scan_number:int,
     :return: The value of the .par file value for  the scan requested.
     :rtype: float
     """
+    # Third party modules
     from ast import parse
     from asteval import get_ast_names, Interpreter
+
     labels = get_ast_names(parse(expression))
     symtable = {}
     for l in labels:
@@ -540,35 +545,35 @@ def get_expression_value(spec_scans:SpecScans, scan_number:int,
     aeval = Interpreter(symtable=symtable)
     return aeval(expression)
 
-def validate_data_source_for_map_config(data_source, values):
+def validate_data_source_for_map_config(data_source, info):
     """Confirm that an instance of PointByPointScanData is valid for
     the station and scans provided by a map configuration dictionary.
 
     :param data_source: The input object to validate.
-    :type data_source: PintByPointScanData
-    :param values: The map configuration dictionary.
-    :type values: dict
-    :raises Exception: If `data_source` cannot be validated for
-        `values`.
-    :return: `data_source`, if it is valid.
+    :type data_source: PointByPointScanData
+    :param info: Pydantic validator info object.
+    :type info: pydantic_core._pydantic_core.ValidationInfo
+    :raises Exception: If `data_source` cannot be validated.
+    :return: the validated `data_source` instance.
     :rtype: PointByPointScanData
     """
     def _validate_data_source_for_map_config(
-            data_source, values, parent_list=None):
+            data_source, info, parent_list=None):
         if isinstance(data_source, list):
             return [_validate_data_source_for_map_config(
-                d_s, values, parent_list=data_source) for d_s in data_source]
+                d_s, info, parent_list=data_source) for d_s in data_source]
         if data_source is not None:
+            values = info.data
             if data_source.data_type == 'expression':
-                data_source.validate_for_scalar_data(
-                    values.get('scalar_data', parent_list))
+                data_source.validate_for_scalar_data(values['scalar_data'])
             else:
                 import_scanparser(
-                    values.get('station'), values.get('experiment_type'))
-                data_source.validate_for_station(values.get('station'))
-                data_source.validate_for_spec_scans(values.get('spec_scans'))
-        return(data_source)
-    return _validate_data_source_for_map_config(data_source, values)
+                    values['station'], values['experiment_type'])
+                data_source.validate_for_station(values['station'])
+                data_source.validate_for_spec_scans(values['spec_scans'])
+        return data_source
+
+    return _validate_data_source_for_map_config(data_source, info)
 
 
 class IndependentDimension(PointByPointScanData):
@@ -601,11 +606,20 @@ class IndependentDimension(PointByPointScanData):
     end: Optional[int] = None
     step: Optional[conint(gt=0)] = 1
 
-#    @validator('step')
-#    def validate_step(cls, value):
-#        if value == 0 :
+#    @field_validator('step')
+#    @classmethod
+#    def validate_step(cls, step):
+#        """Validate that the supplied value of `step`.
+#
+#        :param step: The value of `step` to validate.
+#        :type step: str
+#        :raises ValueError: If `step` is zero.
+#        :return: The originally supplied value `step`.
+#        :rtype: int
+#        """
+#        if step == 0 :
 #            raise ValueError('slice step cannot be zero')
-#        return value
+#        return step
 
 
 class CorrectionsData(PointByPointScanData):
@@ -641,7 +655,7 @@ class CorrectionsData(PointByPointScanData):
         :return: A list of reserved labels.
         :rtype: list[str]
         """
-        return list((*cls.__fields__['label'].type_.__args__, 'round'))
+        return list((*cls.model_fields['label'].annotation.__args__, 'round'))
 
 
 class PresampleIntensity(CorrectionsData):
@@ -713,60 +727,68 @@ class SpecConfig(BaseModel):
     :type spec_scans: list[SpecScans]
     """
     station: Literal['id1a3', 'id3a', 'id3b']
-    experiment_type: Literal['SAXSWAXS', 'EDD', 'XRF', 'TOMO']
-    spec_scans: conlist(item_type=SpecScans, min_items=1)
+    experiment_type: Literal['EDD', 'GIWAXS', 'SAXSWAXS', 'TOMO', 'XRF']
+    spec_scans: conlist(item_type=SpecScans, min_length=1)
 
-    @root_validator(pre=True)
-    def validate_config(cls, values):
+    @model_validator(mode='before')
+    @classmethod
+    def validate_config(cls, data):
         """Ensure that a valid configuration was provided and finalize
         spec_file filepaths.
 
-        :param values: Dictionary of validated class field values.
-        :type values: dict
-        :return: The validated list of `values`.
+        :param data: Pydantic validator data object.
+        :type data: SpecConfig, pydantic_core._pydantic_core.ValidationInfo
+        :return: The currently validated list of class properties.
         :rtype: dict
         """
-        inputdir = values.get('inputdir')
+        inputdir = data.get('inputdir')
         if inputdir is not None:
-            spec_scans = values.get('spec_scans')
+            spec_scans = data.get('spec_scans')
             for i, scans in enumerate(deepcopy(spec_scans)):
-                spec_file = scans['spec_file']
-                if not os.path.isabs(spec_file):
-                    spec_scans[i]['spec_file'] = os.path.join(
-                        inputdir, spec_file)
-                spec_scans[i] = SpecScans(**spec_scans[i], **values)
-            values['spec_scans'] = spec_scans
-        return values
-
-    @validator('experiment_type')
-    def validate_experiment_type(cls, value, values):
+                if isinstance(scans, dict):
+                    spec_file = scans['spec_file']
+                    if not os.path.isabs(spec_file):
+                        spec_scans[i]['spec_file'] = os.path.join(
+                            inputdir, spec_file)
+                else:
+                    spec_file = scans.spec_file
+                    if not os.path.isabs(spec_file):
+                        spec_scans[i].spec_file = os.path.join(
+                            inputdir, spec_file)
+            data['spec_scans'] = spec_scans
+        return data
+
+    @field_validator('experiment_type')
+    @classmethod
+    def validate_experiment_type(cls, experiment_type, info):
         """Ensure values for the station and experiment_type fields are
         compatible
 
-        :param value: Field value to validate (`experiment_type`).
-        :type value: str
-        :param values: Dictionary of validated class field values.
-        :type values: dict
+        :param experiment_type: The value of `experiment_type` to
+            validate.
+        :type experiment_type: str
+        :param info: Pydantic validator info object.
+        :type info: pydantic_core._pydantic_core.ValidationInfo
         :raises ValueError: Invalid experiment type.
         :return: The validated field for `experiment_type`.
         :rtype: str
         """
-        station = values.get('station')
+        station = info.data.get('station')
         if station == 'id1a3':
-            allowed_experiment_types = ['SAXSWAXS', 'EDD', 'TOMO']
+            allowed_experiment_types = ['EDD', 'SAXSWAXS', 'TOMO']
         elif station == 'id3a':
             allowed_experiment_types = ['EDD', 'TOMO']
         elif station == 'id3b':
-            allowed_experiment_types = ['SAXSWAXS', 'XRF', 'TOMO']
+            allowed_experiment_types = ['GIWAXS', 'SAXSWAXS', 'TOMO', 'XRF']
         else:
             allowed_experiment_types = []
-        if value not in allowed_experiment_types:
+        if experiment_type not in allowed_experiment_types:
             raise ValueError(
                 f'For station {station}, allowed experiment types are '
                 f'{", ".join(allowed_experiment_types)}. '
-                f'Supplied experiment type {value} is not allowed.')
-        import_scanparser(station, value)
-        return value
+                f'Supplied experiment type {experiment_type} is not allowed.')
+        import_scanparser(station, experiment_type)
+        return experiment_type
 
 
 class MapConfig(BaseModel):
@@ -802,189 +824,124 @@ class MapConfig(BaseModel):
         map. In the NeXus file representation of the map, datasets for
         these values will be included, defaults to `[]`.
     :type scalar_data: list[PointByPointScanData], optional
-    :ivar map_type: Type of map, structured or unstructured,
-        defaults to `'structured'`.
-    :type map_type: Literal['structured', 'unstructured'], optional
     """
     title: constr(strip_whitespace=True, min_length=1)
     station: Literal['id1a3', 'id3a', 'id3b']
-    experiment_type: Literal['SAXSWAXS', 'EDD', 'XRF', 'TOMO']
+    experiment_type: Literal['EDD', 'GIWAXS', 'SAXSWAXS', 'TOMO', 'XRF']
     sample: Sample
-    spec_scans: conlist(item_type=SpecScans, min_items=1)
-    independent_dimensions: conlist(
-        item_type=IndependentDimension, min_items=1)
-    presample_intensity: Optional[PresampleIntensity]
-    dwell_time_actual: Optional[DwellTimeActual]
-    postsample_intensity: Optional[PostsampleIntensity]
+    spec_scans: conlist(item_type=SpecScans, min_length=1)
     scalar_data: Optional[list[PointByPointScanData]] = []
-    attrs: Optional[dict] = {}
-    map_type: Optional[Literal['structured', 'unstructured']] = 'structured'
-    _coords: dict = PrivateAttr()
+    independent_dimensions: conlist(
+        item_type=IndependentDimension, min_length=1)
+    presample_intensity: Optional[PresampleIntensity] = None
+    dwell_time_actual: Optional[DwellTimeActual] = None
+    postsample_intensity: Optional[PostsampleIntensity] = None
+    attrs: Optional[Annotated[dict, Field(validate_default=True)]] = {}
+#    _coords: dict = PrivateAttr()
     _dims: tuple = PrivateAttr()
-    _scan_step_indices: list = PrivateAttr()
-    _shape: tuple = PrivateAttr()
-
-    _validate_independent_dimensions = validator(
-        'independent_dimensions',
-        each_item=True,
-        allow_reuse=True)(validate_data_source_for_map_config)
-    _validate_presample_intensity = validator(
-        'presample_intensity',
-        allow_reuse=True)(validate_data_source_for_map_config)
-    _validate_dwell_time_actual = validator(
-        'dwell_time_actual',
-        allow_reuse=True)(validate_data_source_for_map_config)
-    _validate_postsample_intensity = validator(
-        'postsample_intensity',
-        allow_reuse=True)(validate_data_source_for_map_config)
-    _validate_scalar_data = validator(
-        'scalar_data',
-        allow_reuse=True)(validate_data_source_for_map_config)
-
-    @root_validator(pre=True)
-    def validate_config(cls, values):
+#    _scan_step_indices: list = PrivateAttr()
+#    _shape: tuple = PrivateAttr()
+
+    _validate_independent_dimensions = field_validator(
+        'independent_dimensions')(validate_data_source_for_map_config)
+    _validate_presample_intensity = field_validator(
+        'presample_intensity')(validate_data_source_for_map_config)
+    _validate_dwell_time_actual = field_validator(
+        'dwell_time_actual')(validate_data_source_for_map_config)
+    _validate_postsample_intensity = field_validator(
+        'postsample_intensity')(validate_data_source_for_map_config)
+    _validate_scalar_data = field_validator(
+        'scalar_data')(validate_data_source_for_map_config)
+
+    @model_validator(mode='before')
+    @classmethod
+    def validate_config(cls, data):
         """Ensure that a valid configuration was provided and finalize
         spec_file filepaths.
 
-        :param values: Dictionary of validated class field values.
-        :type values: dict
-        :return: The validated list of `values`.
+        :param data: Pydantic validator data object.
+        :type data:
+            MapConfig, pydantic_core._pydantic_core.ValidationInfo
+        :return: The currently validated list of class properties.
         :rtype: dict
         """
-        inputdir = values.get('inputdir')
+        inputdir = data.get('inputdir')
         if inputdir is not None:
-            spec_scans = values.get('spec_scans')
+            spec_scans = data.get('spec_scans')
             for i, scans in enumerate(deepcopy(spec_scans)):
                 spec_file = scans['spec_file']
                 if not os.path.isabs(spec_file):
                     spec_scans[i]['spec_file'] = os.path.join(
                         inputdir, spec_file)
-                spec_scans[i] = SpecScans(**spec_scans[i], **values)
-            values['spec_scans'] = spec_scans
-        return values
+                spec_scans[i] = SpecScans(**spec_scans[i], **data)
+            data['spec_scans'] = spec_scans
+        return data
 
-    @validator('experiment_type')
-    def validate_experiment_type(cls, value, values):
+    @field_validator('experiment_type')
+    @classmethod
+    def validate_experiment_type(cls, experiment_type, info):
         """Ensure values for the station and experiment_type fields are
         compatible.
 
-        :param value: Field value to validate (`experiment_type`).
-        :type value: dict
-        :param values: Dictionary of validated class field values.
-        :type values: dict
+        :param experiment_type: The value of `experiment_type` to
+            validate.
+        :type experiment_type: dict
+        :param info: Pydantic validator info object.
+        :type info: pydantic_core._pydantic_core.ValidationInfo
         :raises ValueError: Invalid experiment type.
         :return: The validated field for `experiment_type`.
         :rtype: str
         """
-        station = values['station']
+        station = info.data['station']
         if station == 'id1a3':
-            allowed_experiment_types = ['SAXSWAXS', 'EDD', 'TOMO']
+            allowed_experiment_types = ['EDD', 'SAXSWAXS', 'TOMO']
         elif station == 'id3a':
             allowed_experiment_types = ['EDD', 'TOMO']
         elif station == 'id3b':
-            allowed_experiment_types = ['SAXSWAXS', 'XRF', 'TOMO']
+            allowed_experiment_types = ['GIWAXS', 'SAXSWAXS', 'TOMO', 'XRF']
         else:
             allowed_experiment_types = []
-        if value not in allowed_experiment_types:
+        if experiment_type not in allowed_experiment_types:
             raise ValueError(
                 f'For station {station}, allowed experiment types are '
                 f'{", ".join(allowed_experiment_types)}. '
-                f'Supplied experiment type {value} is not allowed.')
-        return value
+                f'Supplied experiment type {experiment_type} is not allowed.')
+        return experiment_type
 
-    @validator('attrs', always=True)
-    def validate_attrs(cls, value, values):
+    #RV maybe better to use model_validator, see v2 docs?
+    @field_validator('attrs')
+    @classmethod
+    def validate_attrs(cls, attrs, info):
         """Read any additional attributes depending on the values for
         the station and experiment_type fields.
 
-        :param value: Field value to validate (`attrs`).
-        :type value: dict
-        :param values: Dictionary of validated class field values.
-        :type values: dict
+        :param attrs: Any additional attributes to the MapConfig class.
+        :type attrs: dict
+        :param info: Pydantic validator info object.
+        :type info: pydantic_core._pydantic_core.ValidationInfo
         :raises ValueError: Invalid attribute.
         :return: The validated field for `attrs`.
         :rtype: dict
         """
         # Get the map's scan_type for EDD experiments
+        values = info.data
         station = values['station']
         experiment_type = values['experiment_type']
         if station in ['id1a3', 'id3a'] and experiment_type == 'EDD':
-            value['scan_type'] = cls.get_smb_par_attr(values, 'scan_type')
-            value['config_id'] = cls.get_smb_par_attr(values, 'config_id')
-            value['dataset_id'] = cls.get_smb_par_attr(values, 'dataset_id')
+            attrs['scan_type'] = cls.get_smb_par_attr(values, 'scan_type')
+            attrs['config_id'] = cls.get_smb_par_attr(values, 'config_id')
+            attrs['dataset_id'] = cls.get_smb_par_attr(values, 'dataset_id')
             axes_labels = {1: 'fly_labx', 2: 'fly_laby', 3: 'fly_labz',
                            4: 'fly_ometotal'}
-            if value['scan_type'] is None:
-                return value
-            if value['scan_type'] != 0:
-                value['fly_axis_labels'] = [
+            if attrs['scan_type'] is None:
+                return attrs
+            if attrs['scan_type'] != 0:
+                attrs['fly_axis_labels'] = [
                     axes_labels[cls.get_smb_par_attr(values, 'fly_axis0')]]
-            if value['scan_type'] in (2, 3, 5):
-                value['fly_axis_labels'].append(
+            if attrs['scan_type'] in (2, 3, 5):
+                attrs['fly_axis_labels'].append(
                     axes_labels[cls.get_smb_par_attr(values, 'fly_axis1')])
-        return value
-
-    @validator('map_type', pre=True, always=True)
-    def validate_map_type(cls, map_type, values):
-        """Validate the map_type field.
-
-        :param map_type: Type of map, structured or unstructured,
-            defaults to `'structured'`.
-        :type map_type: Literal['structured', 'unstructured']]
-        :param values: Dictionary of validated class field values.
-        :type values: dict
-        :return: The validated value for map_type.
-        :rtype: str
-        """
-        dims = {}
-        attrs = values.get('attrs', {})
-        scan_type = attrs.get('scan_type', -1)
-        fly_axis_labels = attrs.get('fly_axis_labels', [])
-        spec_scans = values['spec_scans']
-        independent_dimensions = values['independent_dimensions']
-        scalar_data = values['scalar_data']
-        import_scanparser(values['station'], values['experiment_type'])
-        for i, dim in enumerate(deepcopy(independent_dimensions)):
-            if dim.label in fly_axis_labels:
-                relative = True
-                ndigits = 3
-            else:
-                relative = False
-                ndigits = None
-            dims[dim.label] = []
-            for scans in spec_scans:
-                for scan_number in scans.scan_numbers:
-                    scanparser = scans.get_scanparser(scan_number)
-                    for scan_step_index in range(
-                            scanparser.spec_scan_npts):
-                        dims[dim.label].append(dim.get_value(
-                            scans, scan_number, scan_step_index,
-                            scalar_data, relative, ndigits))
-            dims[dim.label] = np.unique(dims[dim.label])
-            if dim.end is None:
-                dim.end = len(dims[dim.label])
-            dims[dim.label] = dims[dim.label][slice(
-                dim.start, dim.end, dim.step)]
-            independent_dimensions[i] = dim
-
-        coords = np.zeros([v.size for v in dims.values()], dtype=np.int64)
-        for scans in spec_scans:
-            for scan_number in scans.scan_numbers:
-                scanparser = scans.get_scanparser(scan_number)
-                for scan_step_index in range(scanparser.spec_scan_npts):
-                    coords[tuple([
-                        list(dims[dim.label]).index(
-                            dim.get_value(scans, scan_number, scan_step_index,
-                                          scalar_data, True, 3))
-                        if dim.label in fly_axis_labels else
-                        list(dims[dim.label]).index(
-                            dim.get_value(scans, scan_number, scan_step_index,
-                                          scalar_data))
-                        for dim in independent_dimensions])] += 1
-        if any(True for v in coords.flatten() if v == 0 or v > 1):
-            return 'unstructured'
-        else:
-            return 'structured'
+        return attrs
 
     @staticmethod
     def get_smb_par_attr(class_fields, label, units='-', name=None):
@@ -1002,8 +959,8 @@ class MapConfig(BaseModel):
                 except:
                     print(
                         f'Warning: No value found for .par file value "{name}"'
-                        + f' on scan {scan_number} in spec file '
-                        + f'{scans.spec_file}.')
+                        f' on scan {scan_number} in spec file '
+                        f'{scans.spec_file}.')
                     values.append(None)
         values = list(set(values))
         if len(values) != 1:
@@ -1030,6 +987,7 @@ class MapConfig(BaseModel):
         """Return a dictionary of the values of each independent
         dimension across the map.
         """
+        raise RuntimeError(f'property coords not implemented')
         if not hasattr(self, '_coords'):
             scan_type = self.attrs.get('scan_type', -1)
             fly_axis_labels = self.attrs.get('fly_axis_labels', [])
@@ -1061,8 +1019,7 @@ class MapConfig(BaseModel):
         map.
         """
         if not hasattr(self, '_dims'):
-            self._dims = [
-                dim.label for dim in self.independent_dimensions[::-1]]
+            self._dims = [dim.label for dim in self.independent_dimensions]
         return self._dims
 
     @property
@@ -1071,6 +1028,7 @@ class MapConfig(BaseModel):
         object, the scan number, and scan step index for every point
         on the map.
         """
+        raise RuntimeError(f'property scan_step_indices not implemented')
         if not hasattr(self, '_scan_step_indices'):
             scan_step_indices = []
             for scans in self.spec_scans:
@@ -1087,10 +1045,10 @@ class MapConfig(BaseModel):
         """Return the shape of the map -- a tuple representing the
         number of unique values of each dimension across the map.
         """
+        raise RuntimeError(f'property shape not implemented')
         if not hasattr(self, '_shape'):
             if self.map_type == 'structured':
-                self._shape = tuple(
-                    [len(v) for k, v in self.coords.items()][::-1])
+                self._shape = tuple([len(v) for k, v in self.coords.items()])
             else:
                 self._shape =  (len(self.scan_step_indices),) 
         return self._shape
@@ -1104,6 +1062,7 @@ class MapConfig(BaseModel):
         :return: A list of coordinate values.
         :rtype: dict
         """
+        raise RuntimeError(f'get_coords not implemented')
         if self.map_type == 'structured':
             scan_type = self.attrs.get('scan_type', -1)
             fly_axis_labels = self.attrs.get('fly_axis_labels', [])
@@ -1131,6 +1090,7 @@ class MapConfig(BaseModel):
         :return: One frame of raw detector data.
         :rtype: np.ndarray
         """
+        raise RuntimeError(f'get_detector_data not implemented')
         scans, scan_number, scan_step_index = \
             self.get_scan_step_index(map_index)
         scanparser = scans.get_scanparser(scan_number)
@@ -1147,6 +1107,7 @@ class MapConfig(BaseModel):
             step index.
         :rtype: tuple[SpecScans, int, int]
         """
+        raise RuntimeError(f'get_scan_step_index not implemented')
         scan_type = self.attrs.get('scan_type', -1)
         fly_axis_labels = self.attrs.get('fly_axis_labels', [])
         if self.map_type == 'structured':
@@ -1179,6 +1140,7 @@ class MapConfig(BaseModel):
         :type map_index: tuple
         :return: Raw data value.
         """
+        raise RuntimeError(f'get_value not implemented')
         scans, scan_number, scan_step_index = \
             self.get_scan_step_index(map_index)
         return data.get_value(scans, scan_number, scan_step_index,
@@ -1194,40 +1156,9 @@ def import_scanparser(station, experiment):
     :type station: str
     :param experiment: The experiment type.
     :type experiment: Literal[
-        'SAXSWAXS', 'EDD', 'XRF', 'Tomo', 'Powder']
+        'EDD', 'GIWAXS', 'SAXSWAXS', 'TOMO', 'XRF']
     """
-
-    station = station.lower()
-    experiment = experiment.lower()
-
     # Local modules
-    if station in ('id1a3', 'id3a'):
-        if experiment in ('saxswaxs', 'powder'):
-            from CHAP.utils.scanparsers \
-                import SMBLinearScanParser as ScanParser
-        elif experiment == 'edd':
-            from CHAP.utils.scanparsers \
-                import SMBMCAScanParser as ScanParser
-        elif experiment == 'tomo':
-            from CHAP.utils.scanparsers \
-                import SMBRotationScanParser as ScanParser
-        else:
-            raise ValueError(
-                f'Invalid experiment type for station {station}: {experiment}')
-    elif station == 'id3b':
-        if experiment == 'saxswaxs':
-            from CHAP.utils.scanparsers \
-                import FMBSAXSWAXSScanParser as ScanParser
-        elif experiment == 'tomo':
-            from CHAP.utils.scanparsers \
-                import FMBRotationScanParser as ScanParser
-        elif experiment == 'xrf':
-            from CHAP.utils.scanparsers \
-                import FMBXRFScanParser as ScanParser
-        else:
-            raise ValueError(
-                f'Invalid experiment type for station {station}: {experiment}')
-    else:
-        raise ValueError(f'Invalid station: {station}')
+    from chess_scanparsers import choose_scanparser
 
-    globals()['ScanParser'] = ScanParser
+    globals()['ScanParser'] = choose_scanparser(station, experiment)