types

@classmethod
def from_positions(
    cls,
    x_positions: Sequence[float],
    y_positions: Sequence[float],
):
    """Create a grid from sequence of x and y positions.

    Args:

        x_positions (Sequence[float]): The x positions.
        y_positions (Sequence[float]): The y positions.

    Returns:
        Grid: A grid object with the specified x and y positions.
    """
    x_init = x_positions[0] if len(x_positions) > 0 else None
    y_init = y_positions[0] if len(y_positions) > 0 else None

    if len(x_positions) > 1:
        x_spacing = tuple(
            x_positions[i + 1] - x_positions[i] for i in range(len(x_positions) - 1)
        )
    else:
        x_spacing = ()

    if len(y_positions) > 1:
        y_spacing = tuple(
            y_positions[i + 1] - y_positions[i] for i in range(len(y_positions) - 1)
        )
    else:
        y_spacing = ()

    return cls(x_spacing, y_spacing, x_init, y_init)

def get(self, idx: tuple[int, int]) -> tuple[float, float]:
    """Get the (x, y) position at the specified grid index.

    Args:
        idx (tuple[int, int]): The (x, y) index in the grid.

    Returns:
        tuple[float, float]: The (x, y) position in the grid.
    """
    return (self.x_positions[idx[0]], self.y_positions[idx[1]])

def get_view(self, x_indices, y_indices) -> "Grid":
    """Get a sub-grid view based on the specified x and y indices.

    Args:
        x_indices (Sequence[int]): The x indices to include in the sub-grid.
        y_indices (Sequence[int]): The y indices to include in the sub-grid.

    Returns:
        Grid: The sub-grid view.
    """
    if isinstance(x_indices, ilist.IList):
        x_indices = x_indices.data

    if isinstance(y_indices, ilist.IList):
        y_indices = y_indices.data

    return SubGrid(
        parent=self,
        x_indices=ilist.IList(x_indices),
        y_indices=ilist.IList(y_indices),
    )

def is_equal(self, other: Any) -> bool:
    """Check if two grid geometry are equal."""
    if not isinstance(other, Grid):
        return False
    return (
        self.x_spacing == other.x_spacing
        and self.y_spacing == other.y_spacing
        and self.x_init == other.x_init
        and self.y_init == other.y_init
    )

def repeat(
    self, x_times: int, y_times: int, x_gap: float, y_gap: float
) -> "Grid[NumX, NumY]":
    """Repeat the grid in both x and y directions with specified gaps.

    Args:
        x_times (int): The number of times to repeat the grid in the x direction.
        y_times (int): The number of times to repeat the grid in the y direction.
        x_gap (float): The gap between repeated grids in the x direction.
        y_gap (float): The gap between repeated grids in the y direction.

    Returns:
        Grid[NumX, NumY]: A new grid with the specified repetitions and gaps.

    """

    if x_times < 1 or y_times < 1:
        raise ValueError("x_times and y_times must be non-negative")

    return Grid(
        x_spacing=sum((self.x_spacing + (x_gap,) for _ in range(x_times - 1)), ())
        + self.x_spacing,
        y_spacing=sum((self.y_spacing + (y_gap,) for _ in range(y_times - 1)), ())
        + self.y_spacing,
        x_init=self.x_init,
        y_init=self.y_init,
    )

def scale(self, x_scale: float, y_scale: float) -> "Grid[NumX, NumY]":
    """Scale the grid spacings by the specified x and y factors with fixed x and y initial positions.

    Args:
        x_scale (float): The scaling factor for the x spacings.
        y_scale (float): The scaling factor for the y spacings.

    Returns:
        Grid[NumX, NumY]: A new grid with scaled x and y spacings

    """
    return Grid(
        x_spacing=tuple(spacing * x_scale for spacing in self.x_spacing),
        y_spacing=tuple(spacing * y_scale for spacing in self.y_spacing),
        x_init=self.x_init,
        y_init=self.y_init,
    )

def set_init(
    self, x_init: float | None, y_init: float | None
) -> "Grid[NumX, NumY]":
    """Set the initial positions of the grid.

    Args:
        x_init (float | None): The new initial x position. If None, the grid
            will not have an initial x position.
        y_init (float | None): The new initial y position. If None, the grid
            will not have an initial y position.

    Returns:
        Grid[NumX, NumY]: A new grid with the specified initial positions.

    """
    return Grid(self.x_spacing, self.y_spacing, x_init, y_init)

def shift(self, x_shift: float, y_shift: float) -> "Grid[NumX, NumY]":
    """Shift the grid by the specified x and y amounts.

    Args:
        x_shift (float): The amount to shift the grid in the x direction.
        y_shift (float): The amount to shift the grid in the y direction.

    Returns:
        Grid[NumX, NumY]: A new grid with the specified shifts applied to the initial positions.

    """
    return Grid(
        x_spacing=self.x_spacing,
        y_spacing=self.y_spacing,
        x_init=self.x_init + x_shift if self.x_init is not None else None,
        y_init=self.y_init + y_shift if self.y_init is not None else None,
    )

def shift_subgrid_x(
    self, x_indices: ilist.IList[int, Nx] | slice, x_shift: float
) -> "Grid[NumX, NumY]":
    """Shift a sub grid of grid in the x directions.

    Args:
        grid (Grid): a grid object
        x_indices (float): a list/ilist of x indices to shift
        x_shift (float): shift in the x direction
    Returns:
        Grid: a new grid object that has been shifted
    """
    indices = get_indices(len(self.x_spacing) + 1, x_indices)

    def shift_x(index):
        new_spacing = self.x_spacing[index]
        if index in indices and (index + 1) not in indices:
            new_spacing -= x_shift
        elif index not in indices and (index + 1) in indices:
            new_spacing += x_shift
        return new_spacing

    new_spacing = tuple(shift_x(i) for i in range(len(self.x_spacing)))

    assert all(
        x >= 0 for x in new_spacing
    ), "Invalid shift: column order changes after shift."

    x_init = self.x_init
    if x_init is not None and 0 in indices:
        x_init += x_shift

    return Grid(
        x_spacing=new_spacing,
        y_spacing=self.y_spacing,
        x_init=x_init,
        y_init=self.y_init,
    )

def shift_subgrid_y(
    self, y_indices: ilist.IList[int, Ny] | slice, y_shift: float
) -> "Grid[NumX, NumY]":
    """Shift a sub grid of grid in the y directions.

    Args:
        grid (Grid): a grid object
        y_indices (float): a list/ilist of y indices to shift
        y_shift (float): shift in the y direction
    Returns:
        Grid: a new grid object that has been shifted
    """
    indices = get_indices(len(self.y_spacing) + 1, y_indices)

    def shift_y(index):
        new_spacing = self.y_spacing[index]
        if index in indices and (index + 1) not in indices:
            new_spacing -= y_shift
        elif index not in indices and (index + 1) in indices:
            new_spacing += y_shift
        return new_spacing

    new_spacing = tuple(shift_y(i) for i in range(len(self.y_spacing)))

    assert all(
        y >= 0 for y in new_spacing
    ), "Invalid shift: row order changes after shift."

    y_init = self.y_init
    if y_init is not None and 0 in indices:
        y_init += y_shift

    return Grid(
        x_spacing=self.x_spacing,
        y_spacing=new_spacing,
        x_init=self.x_init,
        y_init=y_init,
    )

def x_bounds(self):
    """X bounds of the grid, which is `(x_init, x_init + width)`.

    Raises:
        ValueError: If x_init is None, cannot compute bounds.

    """
    if self.x_init is None:
        raise ValueError("x_init is None, cannot compute bounds")

    return (self.x_init, self.x_init + self.width)

def y_bounds(self):
    """Y bounds of the grid, which is `(y_init, y_init + height)`.

    Raises:
        ValueError: If y_init is None, cannot compute bounds.

    """
    if self.y_init is None:
        raise ValueError("y_init is None, cannot compute bounds")

    return (self.y_init, self.y_init + self.height)

def get_view(self, x_indices, y_indices):
    return self.parent.get_view(
        x_indices=ilist.IList([self.x_indices[x_index] for x_index in x_indices]),
        y_indices=ilist.IList([self.y_indices[y_index] for y_index in y_indices]),
    )