Skip to content

Reference

Validators for the configuration options.

We can combine multiple validation conditions by summing them, thus creating a AND condition

Raises: InvalidConfiguration: If passed value does not meet its imposed conditions InternalError: Passing unknown configuration of the methods

constraint_map = {'ValueInInterval': ValueInInterval, 'ValueFromDtype': ValueFromDtype, 'IterableMustHave': IterableMustHave, 'ValueFromList': ValueFromIterable} module-attribute

Positive_Value_Constraint = ValueInInterval((0, np.inf), include_edges=True) module-attribute

StringValue = ValueFromDtype((str,)) module-attribute

PathValue = ValueFromDtype((str, Path)) + PathExists() module-attribute

NumericValue = ValueFromDtype((int, float)) module-attribute

IntegerValue = ValueFromDtype((int,)) module-attribute

BooleanValue = ValueFromDtype((bool,)) module-attribute

predefined_constraints = {'Positive_Value_Constraint': Positive_Value_Constraint, 'StringValue': StringValue, 'PathValue': PathValue, 'NumericValue': NumericValue, 'IntegerValue': IntegerValue, 'BooleanValue': BooleanValue} module-attribute

Constraint

Base class to define a constraint on possible values that a parameter can take.

Serves as parent class, allows the "sum" of two constraints to make "AND" operations

Attributes: constraint_text: String that describes the constraint

Raises: InvalidConfiguration: If the constraint on the parameter value is not met

Subclassed by:
Source code in src/ASTRA/utils/parameter_validators.py 
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
class Constraint:
    """Base class to define a constraint on possible values that a parameter can take.

    Serves as parent class, allows the "sum" of two constraints to make "AND" operations

    Attributes:
        constraint_text: String that describes the constraint

    Raises:
        InvalidConfiguration: If the constraint on the parameter value is not met

    """

    def __init__(self, const_text: str):  # noqa: D107
        self._constraint_list = [self._evaluate]
        self.constraint_text = const_text

    def __add__(self, other: Constraint) -> Constraint:
        """Create AND condition of current and other."""
        new_const = Constraint(self.constraint_text)
        # ensure that we don't propagate changes to all existing constraints
        new_const._constraint_list = deepcopy(self._constraint_list)
        new_const._constraint_list.append(other._evaluate)
        new_const.constraint_text += " and " + other.constraint_text

        return new_const

    def __radd__(self, other: Constraint) -> Constraint:  # noqa: D105
        return self.__add__(other)

    def _evaluate(self, value: Any) -> None:
        del value

    def check_if_value_meets_constraint(self, value: Any) -> None:
        """Compare the provided value against all constraint.

        Args:
            value (Any): Value to be compared

        Raises:
            InvalidConfiguration: If the value is not met

        """
        for evaluator in self._constraint_list:
            evaluator(value)

    def __str__(self) -> str:  # noqa: D105
        return self.constraint_text

    def __repr__(self) -> str:  # noqa: D105
        return self.constraint_text

    def __call__(self, value: Any) -> None:
        """Call the self.check_if_value_meets_constraint."""
        self.check_if_value_meets_constraint(value)

constraint_text = const_text instance-attribute

check_if_value_meets_constraint(value: Any) -> None

Compare the provided value against all constraint.

Args: value (Any): Value to be compared

Raises: InvalidConfiguration: If the value is not met

Source code in src/ASTRA/utils/parameter_validators.py 
56
57
58
59
60
61
62
63
64
65
66
67
def check_if_value_meets_constraint(self, value: Any) -> None:
    """Compare the provided value against all constraint.

    Args:
        value (Any): Value to be compared

    Raises:
        InvalidConfiguration: If the value is not met

    """
    for evaluator in self._constraint_list:
        evaluator(value)

ValueInInterval

Bases: Constraint

Constraint that imposes the provided value to be inside a given interval.

Source code in src/ASTRA/utils/parameter_validators.py 
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
class ValueInInterval(Constraint):
    """Constraint that imposes the provided value to be inside a given interval."""

    def __init__(self, interval: tuple[Any, Any], include_edges: bool = False):
        """Instantiate the ValueInInterval class.

        Args:
            interval (Tuple): Tuple of the two edges of the interval
            include_edges (bool, optional): Include the edge in the comparison.
                Defaults to False.

        """
        super().__init__(
            const_text=f"Value inside interval <{interval}>; Edges: {include_edges}",
        )
        self._interval = interval
        self._include_edges = include_edges

    def _evaluate(self, value: Any) -> None:
        good_value = False
        try:
            if self._include_edges:
                if self._interval[0] <= value <= self._interval[1]:
                    good_value = True
            elif self._interval[0] < value < self._interval[1]:
                good_value = True
        except TypeError as exc:
            msg = f"Config value can't be compared with the the interval: {value} ({type(value)}) vs {self._interval}"
            raise InvalidConfiguration(msg) from exc

        if not good_value:
            msg = f"Config value is not inside the interval: {value} vs {self._interval}"
            raise InvalidConfiguration(msg)

ValueFromDtype

Bases: Constraint

Constraint that limits the datatype of the input.

Source code in src/ASTRA/utils/parameter_validators.py 
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
class ValueFromDtype(Constraint):
    """Constraint that limits the datatype of the input."""

    def __init__(self, dtype_list: tuple[type, ...]) -> None:
        """Constraint that limits the datatype of the input.

        Args:
            dtype_list (List[type]): Valid data types

        """
        super().__init__(const_text=f"Value from dtype <{dtype_list}>")
        self.valid_dtypes = dtype_list

        if not isinstance(dtype_list, tuple):
            msg = "Dtype list must be a tuple"
            raise InternalError(msg)

    def _evaluate(self, value: Any) -> None:
        if not isinstance(value, self.valid_dtypes):
            msg = f"Config value ({value}) not from" f"the valid dtypes: {type(value)} vs {self.valid_dtypes}"
            raise InvalidConfiguration(
                msg,
            )

valid_dtypes = dtype_list instance-attribute

ValueFromIterable

Bases: Constraint

Limits the possible values to be inside a list.

Source code in src/ASTRA/utils/parameter_validators.py 
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
class ValueFromIterable(Constraint):
    """Limits the possible values to be inside a list."""

    def __init__(self, available_options: Iterable[Any]) -> None:
        """Limits the possible values that the input can take.

        Args:
            available_options (Tuple[Any]): Tuple with the allowed values for this input

        """
        super().__init__(const_text=f"Value from list <{available_options}>")
        self.available_options = available_options
        if not isinstance(available_options, Iterable):
            msg = "The available options must be an iterable"
            raise InternalError(msg)

    def _evaluate(self, value: Any) -> None:
        bad_value = False
        if isinstance(value, (list, tuple)):
            for element in value:
                if element not in self.available_options:
                    bad_value = True
                    break
        elif isinstance(self.available_options, type) and not isinstance(
            value,
            self.available_options,
        ):
            # The value in Enum does not work properly before python3.12
            bad_value = True
        elif value not in self.available_options:
            bad_value = True

        if bad_value:
            msg = f"Config value not one of the valid ones: {value} vs {self.available_options}"
            raise InvalidConfiguration(
                msg,
            )

available_options = available_options instance-attribute

IterableMustHave

Bases: Constraint

Imposes that certain values must be inside a given iterable.

Source code in src/ASTRA/utils/parameter_validators.py 
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
class IterableMustHave(Constraint):
    """Imposes that certain values must be inside a given iterable."""

    def __init__(self, available_options: tuple[Any, ...], mode: str = "all") -> None:
        """Imposes that certain values must be inside the passed iterable object.

        Args:
            available_options (Tuple[Any]): Tuple with values that must be present in the iterable
            mode (str, optional): "all" if we want all values present in the iterable,
            "any" if we want at least one of them. Defaults to "all".

        """
        super().__init__(const_text=f"Must have value from list <{available_options}>")
        self.available_options = available_options
        self.mode = mode

        if mode not in ["all", "any"]:
            msg = "Using the wrong mode"
            raise InternalError(msg)

    def _evaluate(self, value: Any) -> None:
        if not isinstance(value, Iterable):
            msg = "Constraint needs a iterable object"
            raise InvalidConfiguration(msg)

        evaluation = [i in value for i in self.available_options]

        good_value = False

        if self.mode == "all":
            good_value = all(evaluation)
        elif self.mode == "any":
            good_value = any(evaluation)

        if not good_value:
            raise InvalidConfiguration(
                f"Config value {value} does not" " have {self.mode} of {self.available_options}",
            )

available_options = available_options instance-attribute

mode = mode instance-attribute

PathExists

Bases: Constraint

Imposes that a given path must exist.

Source code in src/ASTRA/utils/parameter_validators.py 
219
220
221
222
223
224
225
226
227
228
class PathExists(Constraint):
    """Imposes that a given path must exist."""

    def __init__(self) -> None:
        """Imposes that a given path exists."""
        super().__init__(const_text="The path must exist")

    def _evaluate(self, value: Any) -> None:
        if not Path(value).exists():
            raise InvalidConfiguration(f"Path {value} does not exist")