types

def col_y_pos(self, column_index: int):
    y_vacancies = {y for x, y in self.vacancies if x == column_index}
    return ilist.IList(
        [y for i, y in enumerate(self.y_positions) if i not in y_vacancies]
    )

def get_view(  # type: ignore
    self, x_indices: ilist.IList[int, Any], y_indices: ilist.IList[int, Any]
):
    remapping_x = {ix: i for i, ix in enumerate(x_indices)}
    remapping_y = {iy: i for i, iy in enumerate(y_indices)}
    return FilledGrid(
        parent=self.parent.get_view(x_indices, y_indices),
        vacancies=frozenset(
            (remapping_x[x], remapping_y[y])
            for x, y in self.vacancies
            if x in remapping_x and y in remapping_y
        ),
    )

def is_equal(self, other: Any) -> bool:
    return self == other

def repeat(self, x_times: int, y_times: int, x_gap: float, y_gap: float):
    new_parent = self.parent.repeat(x_times, y_times, x_gap, y_gap)
    x_dim, y_dim = self.shape
    vacancies = frozenset(
        (x + x_dim * i, y + y_dim * j)
        for i, j, (x, y) in product(range(x_times), range(y_times), self.vacancies)
    )
    return FilledGrid.vacate(new_parent, vacancies)

def row_x_pos(self, row_index: int):
    x_vacancies = {x for x, y in self.vacancies if y == row_index}
    return ilist.IList(
        [x for i, x in enumerate(self.parent.x_positions) if i not in x_vacancies]
    )

def scale(self, x_scale: float, y_scale: float):
    return FilledGrid(
        parent=self.parent.scale(x_scale, y_scale),
        vacancies=self.vacancies,
    )

def shift(self, x_shift: float, y_shift: float):
    return FilledGrid(
        parent=self.parent.shift(x_shift, y_shift),
        vacancies=self.vacancies,
    )