operation.py

    def _get_plot_coordinates_for_latency(
        self,
    ) -> Tuple[Tuple[float, float], ...]:
        # Points for latency polygon
        latency = []
        input_latencies = self.input_latency_offsets()
        output_latencies = self.output_latency_offsets()
        # Remember starting point
        start_point = (input_latencies[0], 0.0)
        num_in = self.input_count
        latency.append(start_point)
        for k in range(1, num_in):
            latency.append((input_latencies[k - 1], k / num_in))
            latency.append((input_latencies[k], k / num_in))
        latency.append((input_latencies[num_in - 1], 1))

        num_out = self.output_count
        latency.append((output_latencies[num_out - 1], 1))
        for k in reversed(range(1, num_out)):
            latency.append((output_latencies[k], k / num_out))
            latency.append((output_latencies[k - 1], k / num_out))
        latency.append((output_latencies[0], 0.0))
        # Close the polygon
        latency.append(start_point)

        return tuple(latency)

    def get_input_coordinates(self) -> Tuple[Tuple[float, float], ...]:
        # doc-string inherited
        num_in = self.input_count
        return tuple(
            (
                self.input_latency_offsets()[k],
                (1 + 2 * k) / (2 * num_in),
            )
            for k in range(num_in)
        )

    def get_output_coordinates(self) -> Tuple[Tuple[float, float], ...]:
        # doc-string inherited
        num_out = self.output_count
        return tuple(
            (
                self.output_latency_offsets()[k],
                (1 + 2 * k) / (2 * num_out),
            )
            for k in range(num_out)
        )

    @property
    def is_linear(self) -> bool:
        # doc-string inherited
        if self.is_constant:
            return True
        return False

    @property
    def is_constant(self) -> bool:
        # doc-string inherited
        return all(
            input_.connected_source.operation.is_constant for input_ in self.inputs
        )

    @property
    def is_swappable(self) -> bool:
        # doc-string inherited
        return False

    def swap_io(self) -> None:
        # doc-string inherited
        if not self.is_swappable:
            raise TypeError(f"operation io cannot be swapped for {type(self)}")
        if self.input_count == 2 and self.output_count == 1:
            self._input_ports.reverse()
            for i, p in enumerate(self._input_ports):
                p._index = i