Fifth step in transitioning to pydantic: more Experiment

Author: AndrewSazonov

src/easydiffraction/analysis/calculators/calculator_cryspy.py

@@ -321,7 +321,8 @@ def _convert_experiment_to_cryspy_cif(
                 }
             cif_lines.append('')
             for local_attr_name, engine_key_name in instrument_mapping.items():
-                attr_obj = instrument.__dict__.get(local_attr_name)
+                # attr_obj = instrument.__dict__.get(local_attr_name)
+                attr_obj = getattr(instrument, local_attr_name, None)
                 if attr_obj is not None:
                     cif_lines.append(f'{engine_key_name} {attr_obj.value}')
 
@@ -347,7 +348,8 @@ def _convert_experiment_to_cryspy_cif(
                 cif_lines.append('_tof_profile_peak_shape Gauss')
             cif_lines.append('')
             for local_attr_name, engine_key_name in peak_mapping.items():
-                attr_obj = peak.__dict__.get(local_attr_name)
+                # attr_obj = peak.__dict__.get(local_attr_name)
+                attr_obj = getattr(peak, local_attr_name, None)
                 if attr_obj is not None:
                     cif_lines.append(f'{engine_key_name} {attr_obj.value}')
 

src/easydiffraction/core/parameters2.py

@@ -410,6 +410,14 @@ class DescriptorStr(GenericDescriptorStr, CifHelper):
     pass
 
 
+# ----------------------------------------------------------------------
+# DescriptorFloat
+# ----------------------------------------------------------------------
+@dataclass(kw_only=True)
+class DescriptorFloat(GenericDescriptorFloat, CifHelper):
+    pass
+
+
 # ----------------------------------------------------------------------
 # Parameter
 # ----------------------------------------------------------------------

src/easydiffraction/core/singletons.py

@@ -50,11 +50,13 @@ def add_to_uid_map(self, parameter):
         from easydiffraction.core.parameters import Descriptor
         from easydiffraction.core.parameters import GenericConstant
         from easydiffraction.core.parameters import Parameter
+        from easydiffraction.core.parameters2 import DescriptorFloat
         from easydiffraction.core.parameters2 import DescriptorStr as DescriptorStr
         from easydiffraction.core.parameters2 import Parameter as Parameter2
 
         if not isinstance(
-            parameter, (GenericConstant, Descriptor, Parameter, Parameter2, DescriptorStr)
+            parameter,
+            (GenericConstant, Descriptor, Parameter, Parameter2, DescriptorStr, DescriptorFloat),
         ):
             raise TypeError(
                 f'Cannot add object of type {type(parameter).__name__} to UID map. '

src/easydiffraction/experiments/collections/background.py

@@ -17,8 +17,9 @@
 
 from easydiffraction.core.categories import CategoryCollection
 from easydiffraction.core.categories import CategoryItem
-from easydiffraction.core.parameters import Descriptor
-from easydiffraction.core.parameters import Parameter
+from easydiffraction.core.parameters2 import DescriptorStr
+from easydiffraction.core.parameters2 import Parameter
+from easydiffraction.core.parameters2 import RangeValidator
 from easydiffraction.utils.formatting import paragraph
 from easydiffraction.utils.formatting import warning
 from easydiffraction.utils.utils import render_table
@@ -45,27 +46,42 @@ def __init__(
     ):
         super().__init__()
 
-        self.x = Descriptor(
-            value=x,
-            name='x',
-            value_type=float,
+        self._x = DescriptorStr(  # TODO: Should be DescriptorFloat?
+            _init_value=x,
+            _validator=RangeValidator(ge=0, default=0.0),
             _full_cif_names=['_pd_background.line_segment_X'],
-            default_value=x,
+            name='x',
             description='X-coordinates used to create many straight-line segments '
             'representing the background in a calculated diffractogram.',
         )
-        self.y = Parameter(
-            value=y,  # TODO: rename to intensity
-            name='y',  # TODO: rename to intensity
+        self._y = Parameter(
+            _init_value=y,  # TODO: rename to intensity
+            _validator=RangeValidator(ge=0, default=0.0),
             _full_cif_names=['_pd_background.line_segment_intensity'],
-            default_value=y,
+            name='y',  # TODO: rename to intensity
             description='Intensity used to create many straight-line segments '
             'representing the background in a calculated diffractogram',
         )
         # self._category_entry_attr_name = str(x)
         self._category_entry_attr_name = self.x.name
         self.name = self.x.value
 
+    @property
+    def x(self):
+        return self._x
+
+    @x.setter
+    def x(self, value):
+        self._x.value = value
+
+    @property
+    def y(self):
+        return self._y
+
+    @y.setter
+    def y(self, value):
+        self._y.value = value
+
 
 class PolynomialTerm(CategoryItem):
     """Chebyshev polynomial term.
@@ -80,38 +96,57 @@ class PolynomialTerm(CategoryItem):
         # New canonical names
         'order',
         'coef',
-        # Backward compatibility (aliases)
-        'chebyshev_order',
-        'chebyshev_coef',
+        # Backward compatibility (aliases) # TODO: Remove?
+        'chebyshev_order',  # TODO: Remove?
+        'chebyshev_coef',  # TODO: Remove?
     }
 
     @property
     def category_key(self) -> str:  # noqa: D401
         return 'background'
 
-    def __init__(self, order: int, coef: float) -> None:
+    def __init__(
+        self,
+        order: int,
+        coef: float,
+    ) -> None:
         super().__init__()
 
         # Canonical descriptors
-        self.order = Descriptor(
-            value=order,
-            name='order',
-            value_type=int,
+        self._order = DescriptorStr(  # TODO: Should be DescriptorInt?
+            _init_value=order,
+            _validator=RangeValidator(ge=0, default=0.0),
             _full_cif_names=['_pd_background.Chebyshev_order'],
-            default_value=order,
+            name='order',
             description='Order used in a Chebyshev polynomial background term',
         )
-        self.coef = Parameter(
-            value=coef,
-            name='coef',
+        self._coef = Parameter(
+            _init_value=coef,
+            _validator=RangeValidator(ge=0, default=0.0),
             _full_cif_names=['_pd_background.Chebyshev_coef'],
-            default_value=coef,
+            name='coef',
             description='Coefficient used in a Chebyshev polynomial background term',
         )
 
+        @property
+        def order(self):
+            return self._order
+
+        @order.setter
+        def order(self, value):
+            self._order.value = value
+
+        @property
+        def coef(self):
+            return self._coef
+
+        @coef.setter
+        def coef(self, value):
+            self._coef.value = value
+
         # Backward-compatible aliases (point to same objects)
-        self.chebyshev_order = self.order
-        self.chebyshev_coef = self.coef
+        self.chebyshev_order = self.order  # TODO: Remove?
+        self.chebyshev_coef = self.coef  # TODO: Remove?
 
         # Entry attribute used as the identifier within the collection
         self._category_entry_attr_name = self.order.name

src/easydiffraction/experiments/collections/excluded_regions.py

@@ -5,8 +5,8 @@
 
 from easydiffraction.core.categories import CategoryCollection
 from easydiffraction.core.categories import CategoryItem
-from easydiffraction.core.parameters import Descriptor
-from easydiffraction.core.parameters import Parameter
+from easydiffraction.core.parameters2 import DescriptorFloat
+from easydiffraction.core.parameters2 import RangeValidator
 from easydiffraction.utils.formatting import paragraph
 from easydiffraction.utils.utils import render_table
 
@@ -29,19 +29,18 @@ def __init__(
     ):
         super().__init__()
 
-        self.start = Descriptor(
-            value=start,
-            name='start',
-            value_type=float,
+        self.start = DescriptorFloat(
+            _init_value=start,
+            _validator=RangeValidator(ge=0, default=0.0),
             _full_cif_names=['_excluded_region.start'],
-            default_value=start,
+            name='start',
             description='Start of the excluded region.',
         )
-        self.end = Parameter(
-            value=end,
-            name='end',
+        self.end = DescriptorFloat(
+            _init_value=end,
+            _validator=RangeValidator(ge=0, default=0.0),
             _full_cif_names=['_excluded_region.end'],
-            default_value=end,
+            name='end',
             description='End of the excluded region.',
         )
         # self._category_entry_attr_name = f'{start}-{end}'

src/easydiffraction/experiments/collections/linked_phases.py

@@ -4,8 +4,10 @@
 
 from easydiffraction.core.categories import CategoryCollection
 from easydiffraction.core.categories import CategoryItem
-from easydiffraction.core.parameters import Descriptor
-from easydiffraction.core.parameters import Parameter
+from easydiffraction.core.parameters2 import DescriptorStr
+from easydiffraction.core.parameters2 import Parameter
+from easydiffraction.core.parameters2 import RangeValidator
+from easydiffraction.core.parameters2 import RegexValidator
 
 
 class LinkedPhase(CategoryItem):
@@ -26,24 +28,45 @@ def __init__(
     ):
         super().__init__()
 
-        self.id = Descriptor(
-            value=id,
-            name='id',
-            value_type=str,
+        self._id = DescriptorStr(
+            _init_value=id,
+            _validator=RegexValidator(
+                # TODO: the following pattern is valid for dict key
+                #  (keywords are not checked). CIF label is less strict.
+                #  So, we need converter?
+                pattern=r'^[A-Za-z_][A-Za-z0-9_]*$',
+                default='Si',
+            ),
             _full_cif_names=['_pd_phase_block.id'],
-            default_value=id,
+            name='id',
             description='Identifier of the linked phase.',
         )
-        self.scale = Parameter(
-            value=scale,
-            name='scale',
+        self._scale = Parameter(
+            _init_value=scale,
+            _validator=RangeValidator(default=1.0),
             _full_cif_names=['_pd_phase_block.scale'],
-            default_value=scale,
+            name='scale',
             description='Scale factor of the linked phase.',
         )
         self._category_entry_attr_name = self.id.name
         self.name = self.id.value
 
+    @property
+    def id(self) -> DescriptorStr:
+        return self._id
+
+    @id.setter
+    def id(self, value: str):
+        self._id.value = value
+
+    @property
+    def scale(self) -> Parameter:
+        return self._scale
+
+    @scale.setter
+    def scale(self, value: float):
+        self._scale.value = value
+
 
 class LinkedPhases(CategoryCollection[LinkedPhase]):
     """Collection of LinkedPhase instances."""

src/easydiffraction/experiments/components/experiment_type.py

@@ -4,7 +4,8 @@
 from enum import Enum
 
 from easydiffraction.core.categories import CategoryItem
-from easydiffraction.core.parameters import Descriptor
+from easydiffraction.core.parameters2 import DescriptorStr
+from easydiffraction.core.parameters2 import ListValidator
 
 
 class SampleFormEnum(str, Enum):
@@ -87,39 +88,46 @@ def __init__(
         scattering_type: str,
     ):
         super().__init__()
-
-        self.sample_form: Descriptor = Descriptor(
-            value=sample_form,
-            name='sample_form',
-            value_type=str,
+        self.sample_form: DescriptorStr = DescriptorStr(
+            _init_value=sample_form,
+            _validator=ListValidator(
+                allowed_values=[e.value for e in SampleFormEnum],
+                default=SampleFormEnum.default(),
+            ),
             _full_cif_names=['_expt_type.sample_form'],
-            default_value=SampleFormEnum.default(),
+            name='sample_form',
             description='Specifies whether the diffraction data corresponds to '
             'powder diffraction or single crystal diffraction',
         )
-        self.beam_mode: Descriptor = Descriptor(
-            value=beam_mode,
-            name='beam_mode',
-            value_type=str,
+        self.beam_mode: DescriptorStr = DescriptorStr(
+            _init_value=beam_mode,
+            _validator=ListValidator(
+                allowed_values=[e.value for e in BeamModeEnum],
+                default=BeamModeEnum.default(),
+            ),
             _full_cif_names=['_expt_type.beam_mode'],
-            default_value=BeamModeEnum.default(),
+            name='beam_mode',
             description='Defines whether the measurement is performed with a '
             'constant wavelength (CW) or time-of-flight (TOF) method',
         )
-        self.radiation_probe: Descriptor = Descriptor(
-            value=radiation_probe,
-            name='radiation_probe',
-            value_type=str,
+        self.radiation_probe: DescriptorStr = DescriptorStr(
+            _init_value=radiation_probe,
+            _validator=ListValidator(
+                allowed_values=[e.value for e in RadiationProbeEnum],
+                default=RadiationProbeEnum.default(),
+            ),
             _full_cif_names=['_expt_type.radiation_probe'],
-            default_value=RadiationProbeEnum.default(),
+            name='radiation_probe',
             description='Specifies whether the measurement uses neutrons or X-rays',
         )
-        self.scattering_type: Descriptor = Descriptor(
-            value=scattering_type,
-            name='scattering_type',
-            value_type=str,
+        self.scattering_type: DescriptorStr = DescriptorStr(
+            _init_value=scattering_type,
+            _validator=ListValidator(
+                allowed_values=[e.value for e in ScatteringTypeEnum],
+                default=ScatteringTypeEnum.default(),
+            ),
             _full_cif_names=['_expt_type.scattering_type'],
-            default_value=ScatteringTypeEnum.default(),
+            name='scattering_type',
             description='Specifies whether the experiment uses Bragg scattering '
             '(for conventional structure refinement) or total scattering '
             '(for pair distribution function analysis - PDF)',