PR: Improve initialization time of "Signal", a core component of "Colour".

[tjdcs]

Summary

This PR implements a performance improvement for Signal in signal.py.

The initialization of _function, the private backing attribute for the function property, is relatively expensive. This performance issue was discovered when creating an MSDS object from a long list of SpectralDistributions or large ndarrays. The _create_function is invoked frequently when not needed. This PR updates relavent code to always use the function property. the function property has been changed to only invoke _create_function if the _function property has been invalidated (by setting it equal to None). If the function property is never accessed, then the relevant initialization does not take place (lazy initialization)

Under some conditions, this change results in a 90% reduction in Signal initialization run time

Preflight

Code Style and Quality

• Unit tests have been implemented and passed.
• Mypy static checking has been run and passed.
• Pre-commit hooks have been run and passed.
• [N/A] New transformations have been added to the Automatic Colour Conversion Graph.
• [N/A] New transformations have been exported to the relevant namespaces, e.g. colour, colour.models.

Documentation

• [N/A] New features are documented along with examples if relevant.
• [N/A] The documentation is Sphinx and numpydoc compliant.

[tjdcs]

Looks like this is well formed now.

[tjdcs]

@KelSolaar Other than the issue with static type checking (looks like something related to a new version of pip and an old installation method from a dependency) this should be ready for review.

[KelSolaar]

Hey @tjdcs,

Thank you! Two notes:

• The Static Typing issue is because we need to cast the return value of the function method to a Callable:

    @property
    def function(self) -> Callable:
        """
        Getter property for the continuous signal callable.

        Returns
        -------
        Callable
            Continuous signal callable.
        """

        if self._function is None:
            self._create_function()

        return cast(Callable, self._function)

• Given that the _create_function is only used once now, we should probably move its code inside the function method directly, so maybe it becomes that now:

    @property
    def function(self) -> Callable:
        """
        Getter property for the continuous signal callable.

        Returns
        -------
        Callable
            Continuous signal callable.
        """

        if self._function is None:
            if self._domain.size != 0 and self._range.size != 0:
                self._function = self._extrapolator(
                    self._interpolator(
                        self.domain, self.range, **self._interpolator_kwargs
                    ),
                    **self._extrapolator_kwargs,
                )
            else:

                def _undefined_function(*args: Any, **kwargs: Any):
                    """
                    Raise a :class:`ValueError` exception.

                    Other Parameters
                    ----------------
                    args
                        Arguments.
                    kwargs
                        Keywords arguments.

                    Raises
                    ------
                    ValueError
                    """

                    raise ValueError(
                        "Underlying signal interpolator function does not exists, "
                        "please ensure you defined both "
                        '"domain" and "range" variables!'
                    )

                self._function = _undefined_function

        return cast(Callable, self._function)

[KelSolaar]

Thank you!

There are some issues with GH so I cannot comment on the changes directly, anyway, the Callable | None construct was introduced in Python 3.10 so we tend to use the longer Union[Callable, None] form for now. I will merge and fix in a subsequent commit!