def get_raw_value_for()

in pedalboard/_pedalboard.py [0:0]

• 91 lines of code
• 21 McCabe index (conditional complexity)

    def get_raw_value_for(self, new_value: Union[float, str, bool]) -> float:
        if self.type is float:
            to_float_value: Union[str, float, bool]
            if isinstance(new_value, str) and self.label and new_value.endswith(self.label):
                to_float_value = new_value[: -len(self.label)]
            else:
                to_float_value = new_value

            try:
                new_value = float(to_float_value)
            except ValueError:
                if self.label:
                    raise ValueError(
                        "Value received for parameter '{}' ({}) must be a number or a string (with"
                        " the optional suffix '{}')".format(
                            self.python_name, repr(new_value), self.label
                        )
                    )
                raise ValueError(
                    "Value received for parameter '{}' ({}) must be a number or a string".format(
                        self.python_name, repr(new_value)
                    )
                )
            if (self.min_value is not None and new_value < self.min_value) or (
                self.max_value is not None and new_value > self.max_value
            ):
                raise ValueError(
                    "Value received for parameter '{}' ({}) is out of range [{}{}, {}{}]".format(
                        self.python_name,
                        repr(new_value),
                        self.min_value,
                        self.label,
                        self.max_value,
                        self.label,
                    )
                )
            plugin_reported_raw_value = self.get_raw_value_for_text(str(new_value))

            closest_diff = None
            closest_range_value: Optional[Tuple[float, float]] = None
            for value, raw_value_range in self._value_to_raw_value_ranges.items():
                if not isinstance(value, float):
                    continue
                diff = new_value - value
                if closest_diff is None or abs(diff) < abs(closest_diff):
                    closest_range_value = raw_value_range
                    closest_diff = diff

            if closest_range_value is not None:
                expected_low, expected_high = closest_range_value
                if (
                    plugin_reported_raw_value < expected_low
                    or plugin_reported_raw_value > expected_high
                ):
                    # The plugin might have bad code in it when trying
                    # to parse one of the string values it gave to us.
                    # Let's use the range we had before:
                    return expected_low
            return plugin_reported_raw_value

        elif self.type is str:
            if isinstance(new_value, (str, int, float, bool)):
                new_value = str(new_value)
            else:
                raise ValueError(
                    "Value received for parameter '{}' ({}) should be a string (or string-like),"
                    " but got an object of type: {}".format(
                        self.python_name, repr(new_value), type(new_value)
                    )
                )
            if new_value not in self.valid_values:
                raise ValueError(
                    "Value received for parameter '{}' ({}) not in list of valid values: {}".format(
                        self.python_name, repr(new_value), self.valid_values
                    )
                )
            plugin_reported_raw_value = self.get_raw_value_for_text(new_value)
            expected_low, expected_high = self._value_to_raw_value_ranges[new_value]
            if (
                plugin_reported_raw_value < expected_low
                or plugin_reported_raw_value > expected_high
            ):
                # The plugin might have bad code in it when trying
                # to parse one of the string values it gave to us.
                # Let's use the range we had before:
                return expected_low
            else:
                return plugin_reported_raw_value
        elif self.type is bool:
            if not isinstance(new_value, (bool, WrappedBool)):
                raise ValueError(
                    "Value received for parameter '{}' ({}) should be a boolean,"
                    " but got an object of type: {}".format(
                        self.python_name, repr(new_value), type(new_value)
                    )
                )
            return 1.0 if new_value else 0.0
        else:
            raise ValueError(
                "Parameter has invalid type: {}. This should not be possible!".format(self.type)
            )