Appian Grid

Use page.grid(...) to work with rows and cells in an Appian grid. The factory waits for the matching grid before returning it, so callers can use it directly.

items = page.grid(label="Items")

A grid can be identified by label, header, row_name, or column_name. Additional identifiers can narrow the match.

label matches only the grid's own accessible name. header matches either a region's accessible name or header text, without requiring a heading role. Header text can appear in a heading, nested span, paragraph, strong text, or table caption. Text outside the grid resolves through its nearest table-containing ancestor; a caption resolves to its own table. Ordinary cell text is not treated as a header. A grid matched by both region and text paths is returned only once:

details = page.grid(header="Item Details")

Count the displayed rows

count = page.grid(label="Items").row_count()

row_count() returns the number of data rows currently displayed. It does not count the header and does not return the total number of records across other pages.

Work with a row

Rows can be identified by visible text or by a one-based row number:

items = page.grid(label="Items")

row = items.row(name="Item 1001")
row.click()

Work with a cell

A cell can be found directly from the grid:

cell = items.cell(
    row_name="Item 1001",
    column_name="Status",
)

Names and one-based numbers can be mixed:

items.cell(row_name="Item 1001", column_number=3)
items.cell(row_number=1, column_name="Status")
items.cell(row_number=1, column_number=3)

You can also start from a row or column:

items.row(name="Item 1001").cell(column_name="Owner")
items.column(name="Status").cell(row_name="Item 1001")

Use components inside a cell

Cells expose the same Appian component style used elsewhere:

items.cell(
    row_name="Item 1001",
    column_name="Action",
).buttons[0].click()

items.cell(
    row_name="Item 1001",
    column_name="Status",
).dropdowns[0].select(value="Active")

Matching options

exact=True and visible=True are the defaults. Use exact=False for an intentional partial match and visible=None when visibility should not filter the result.

page.grid(label="Items", exact=False)
page.grid(label="Items", visible=None)

Check whether a matching grid is visible now:

items = page.grid(label="Items", wait=False)
if items.is_visible():
    print("Items grid is visible")

is_visible() itself returns immediately. Use wait=False on the factory to probe an optional grid without waiting. By default page.grid() already waits.

The default visible=True waits for a visible table. visible=False waits for an attached hidden table, and visible=None waits for an attached table with either visibility. A missing table never counts as a ready hidden grid.

Timeout values are in seconds. The grid uses the supplied timeout, or the configured browser/context timeout when omitted (90 seconds in CORE). This waits for the grid, not for a particular row to be added.

You can explicitly wait on a previously obtained component after a UI transition:

items = page.grid(label="Items", wait=False)
items.wait_until_ready()
items.wait_until_visible(timeout=8)

API

AppianGrid

Reusable operations for Appian grids and editable grids.

AppianGrid provides semantic table/grid operations and can be instantiated through AppianPage.grid(...) as a semantic Appian grid component. At least one of label, header, row_name, or column_name is required for the component form.

visible is tri-state: True selects visible tables, False selects hidden tables, and None applies no visibility filter so the live locator can contain both visible and hidden matches.

is_visible

is_visible() -> bool

Return whether the first matching grid is currently visible.

This is an immediate check; it does not wait for a grid to appear.

wait_until_visible

wait_until_visible(
    timeout: float | int | None = None,
) -> AppianGrid

Wait for the first matching grid to become visible and return it.

The optional timeout overrides this grid's configured timeout in seconds.

wait_until_ready

wait_until_ready(
    timeout: float | int | None = None,
) -> AppianGrid

Wait for a matching grid using its configured visibility constraint.

Visible grids must be visible. Hidden and unfiltered grids must be attached; the live locator retains the requested visibility filter.

cell

cell(
    *,
    row_name: str | None = None,
    row_number: int | None = None,
    column_name: str | None = None,
    column_number: int | None = None,
    visible: bool | str | None = True,
    exact: bool = True
)

Return a cell directly from this table.

The explicit row/column arguments take precedence. When omitted, row_name and column_name supplied when this AppianGrid was created are reused. Row and column numbers are one-based.

appian_column

appian_column(
    *,
    name: str | None = None,
    column_number: int | None = None,
    visible: bool | str | None = True,
    exact: bool = True
)

Return a semantic column scoped to this Appian grid.

row

row(
    *,
    name: str | None = None,
    row_number: int | None = None,
    visible: bool | str | None = True,
    exact: bool = True
)

Return a semantic row scoped to this Appian grid.

column

column(
    *,
    name: str | None = None,
    column_number: int | None = None,
    visible: bool | str | None = True,
    exact: bool = True
)

Return a semantic column scoped to this table.

row_count

row_count(
    *,
    visible: bool | str | None = None,
    timeout: float | int | None = None
) -> int

Return the number of currently rendered data rows.

Header rows, empty-state placeholders, and Appian paging totals are not counted. timeout waits only for the table to exist; it does not wait for an empty table to gain rows.