Method _get_info

tables/expression.py:495–602

Return various info needed for evaluating the computation loop.

(
        self, shape: list[int], maindim: int | None, itermode: bool = False
    )

        return shape, maindim

    def _get_info(
        self, shape: list[int], maindim: int | None, itermode: bool = False
    ) -> (
        tuple[int, list[int], int, int, int | None, int]
        | tuple[
            int,
            list[int],
            int,
            int,
            int | None,
            int,
            ContainerType,
            int,
            int,
            int,
            int,
        ]
    ):
        """Return various info needed for evaluating the computation loop."""
        # Compute the shape of the resulting container having
        # in account new possible values of start, stop and step in
        # the inputs range
        if maindim is not None:
            start, stop, step = slice(
                self.start, self.stop, self.step
            ).indices(shape[maindim])
            shape[maindim] = min(shape[maindim], len(range(start, stop, step)))
            i_nrows = shape[maindim]
        else:
            start, stop, step = 0, 0, None
            i_nrows = 0

        if not itermode:
            # Create a container for output if not defined yet
            o_maindim = 0  # Default maindim
            if self.out is None:
                out = np.empty(shape, dtype=self._single_row_out.dtype)
                # Get the trivial values for start, stop and step
                if maindim is not None:
                    o_start, o_stop, o_step = (0, shape[maindim], 1)
                else:
                    o_start, o_stop, o_step = (0, 0, 1)
            else:
                out = self.out
                # Out container already provided.  Do some sanity checks.
                if hasattr(out, "maindim"):
                    o_maindim = out.maindim

                # Refine the shape of the resulting container having in
                # account new possible values of start, stop and step in
                # the output range
                o_shape = list(out.shape)
                s = slice(self.o_start, self.o_stop, self.o_step)
                o_start, o_stop, o_step = s.indices(o_shape[o_maindim])
                o_shape[o_maindim] = min(
                    o_shape[o_maindim], len(range(o_start, o_stop, o_step))
                )