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: ilist.IList[int, Nx], y_indices: ilist.IList[int, Ny]
) -> "Grid[Nx, Ny]":
    """Get a sub-grid view based on the specified x and y indices.

    Args:
        x_indices (ilist.IList[int, Nx]): The x indices to include in the sub-grid.
        y_indices (ilist.IList[int, Ny]): The y indices to include in the sub-grid.

    Returns:
        Grid[Nx, Ny]: The sub-grid view.
    """
    return SubGrid(parent=self, x_indices=x_indices, y_indices=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 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: ilist.IList[int, Any], y_indices: ilist.IList[int, Any]
):
    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]),
    )