Table Cache

Cache classes for Table and Row.

Classes:

Name	Description
RowCache	Cache for Row (internal).
TableCache	Cache for Table (internal).

_XP_CELL_IDX module-attribute

_XP_CELL_IDX = xpath_compile(
    "(table:table-cell|table:covered-table-cell)[$idx]"
)

_XP_COLUMN_IDX module-attribute

_XP_COLUMN_IDX = xpath_compile(
    "(table:table-column|table:table-columns/table:table-column|table:table-header-columns/table:table-column)[$idx]"
)

_XP_ROW_IDX module-attribute

_XP_ROW_IDX = xpath_compile(
    "(table:table-row|table:table-rows/table:table-row|table:table-header-rows/table:table-row|table:table-row-group/child::table:table-row)[$idx]"
)

RowCache

Cache for Row (internal).

Methods:

Name	Description
__init__	Initialize a RowCache.
__str__
cached_cell	Retrieve Cell in cache.
cell_idx	Find cell index in the map from the position.
cell_map_length	Return the length of the cell map.
clear_cell_indexes	Clear the indexed cached cells.
copy	Return a copy of the row cache.
delete_cell_in_cache	Delete the cell at position x from cache and row element.
insert_cell_in_cache	Insert a cell in cache and row element at position x.
insert_cell_map_once	Insert a repeated cell count into the cell map.
make_cell_map	Build the cell map from repeated sequence data.
set_cell_in_cache	Update the cache and row element with a cell at position x.
store_cell	Store Cell in cache.
width	Get the number of expected cells in the row, i.e. addition

Attributes:

Name	Type	Description
__slots__
cell_elements	dict[int, Cell]
cell_map	list[int]

Source code in odfdo/table_cache.py

class RowCache:
    """Cache for Row (internal)."""

    __slots__ = ("cell_elements", "cell_map")

    def __init__(self) -> None:
        """Initialize a RowCache."""
        self.cell_map: list[int] = []
        self.cell_elements: dict[int, Cell] = {}

    def __str__(self) -> str:
        return f"RC cell:{self.cell_map!r}"

    @classmethod
    def copy(cls, source: RowCache) -> RowCache:
        """Return a copy of the row cache."""
        rc = cls()
        rc.cell_map = source.cell_map[:]
        return rc

    def width(self) -> int:
        """Get the number of expected cells in the row, i.e. addition
        repetitions.

        Returns:
            int: The number of expected cells in the row.

        """
        try:
            return self.cell_map[-1] + 1
        except IndexError:
            return 0

    def clear_cell_indexes(self) -> None:
        """Clear the indexed cached cells."""
        self.cell_elements = {}

    def cell_idx(self, position: int) -> int | None:
        """Find cell index in the map from the position."""
        idx = bisect_left(self.cell_map, position)
        if idx < len(self.cell_map):
            return idx
        return None

    def cell_map_length(self) -> int:
        """Return the length of the cell map."""
        return len(self.cell_map)

    def cached_cell(self, idx: int) -> Cell | None:
        """Retrieve Cell in cache."""
        return self.cell_elements.get(idx)

    def store_cell(self, cell: Cell, idx: int) -> None:
        """Store Cell in cache."""
        self.cell_elements[idx] = cell

    def insert_cell_map_once(self, repeated: int) -> None:
        """Insert a repeated cell count into the cell map."""
        self.cell_map = _insert_map_once(self.cell_map, len(self.cell_map), repeated)

    # def erase_cell_map_once(self, odf_idx: int) -> None:
    #     self.cell_map = _erase_map_once(self.cell_map, odf_idx)

    def make_cell_map(self, idx_repeated_sequence: list[tuple[int, int]]) -> None:
        """Build the cell map from repeated sequence data."""
        self.cell_map = _make_cache_map(idx_repeated_sequence)

    def set_cell_in_cache(
        self,
        x: int,
        cell: Cell,
        vault: Row,
        clone: bool,
    ) -> Cell:
        """Update the cache and row element with a cell at position x."""
        idx = self.cell_idx(x)
        if idx is None:
            raise ValueError
        current_cached_cell: Cell | None = self.cached_cell(idx)
        if current_cached_cell is None:
            current_cached_cell = vault._get_element_idx2(_XP_CELL_IDX, idx)  # ty: ignore[invalid-assignment]
        if not current_cached_cell:
            raise ValueError  # pragma: nocover
        self.clear_cell_indexes()
        emap, new_cell = _set_item_in_vault(
            x,
            cell,
            idx,
            current_cached_cell,
            vault,
            self.cell_map,
            _XP_CELL_IDX,
            clone,
        )
        self.cell_map = emap
        return new_cell  # ty: ignore[invalid-return-type]

    def insert_cell_in_cache(
        self,
        x: int,
        cell: Cell,
        vault: Row,
    ) -> Cell:
        """Insert a cell in cache and row element at position x."""
        idx = self.cell_idx(x)
        if idx is None:
            raise ValueError
        current_cached_cell: Cell | None = self.cached_cell(idx)
        if current_cached_cell is None:
            current_cached_cell = vault._get_element_idx2(_XP_CELL_IDX, idx)  # ty: ignore[invalid-assignment]
        if not current_cached_cell:
            raise ValueError  # pragma: nocover
        self.clear_cell_indexes()
        emap, new_cell = _insert_item_in_vault(
            x,
            cell,
            idx,
            current_cached_cell,
            vault,
            self.cell_map,
        )
        self.cell_map = emap
        return new_cell  # ty: ignore[invalid-return-type]

    def delete_cell_in_cache(
        self,
        x: int,
        vault: Row,
    ) -> None:
        """Delete the cell at position x from cache and row element."""
        idx = self.cell_idx(x)
        if idx is None:
            raise ValueError
        current_cached_cell: Cell | None = self.cached_cell(idx)
        if current_cached_cell is None:
            current_cached_cell = vault._get_element_idx2(_XP_CELL_IDX, idx)  # ty: ignore[invalid-assignment]
        if not current_cached_cell:
            raise ValueError  # pragma: nocover
        self.clear_cell_indexes()
        emap = _delete_item_in_vault(
            idx,
            current_cached_cell,
            vault,
            self.cell_map,
        )
        self.cell_map = emap

__slots__ class-attribute instance-attribute

__slots__ = ('cell_elements', 'cell_map')

cell_elements instance-attribute

cell_elements: dict[int, Cell] = {}

cell_map instance-attribute

cell_map: list[int] = []

__init__

__init__() -> None

Initialize a RowCache.

Source code in odfdo/table_cache.py

def __init__(self) -> None:
    """Initialize a RowCache."""
    self.cell_map: list[int] = []
    self.cell_elements: dict[int, Cell] = {}

__str__

__str__() -> str

Source code in odfdo/table_cache.py

def __str__(self) -> str:
    return f"RC cell:{self.cell_map!r}"

cached_cell

cached_cell(idx: int) -> Cell | None

Retrieve Cell in cache.

Source code in odfdo/table_cache.py

def cached_cell(self, idx: int) -> Cell | None:
    """Retrieve Cell in cache."""
    return self.cell_elements.get(idx)

cell_idx

cell_idx(position: int) -> int | None

Find cell index in the map from the position.

Source code in odfdo/table_cache.py

def cell_idx(self, position: int) -> int | None:
    """Find cell index in the map from the position."""
    idx = bisect_left(self.cell_map, position)
    if idx < len(self.cell_map):
        return idx
    return None

cell_map_length

cell_map_length() -> int

Return the length of the cell map.

Source code in odfdo/table_cache.py

def cell_map_length(self) -> int:
    """Return the length of the cell map."""
    return len(self.cell_map)

clear_cell_indexes

clear_cell_indexes() -> None

Clear the indexed cached cells.

Source code in odfdo/table_cache.py

def clear_cell_indexes(self) -> None:
    """Clear the indexed cached cells."""
    self.cell_elements = {}

copy classmethod

copy(source: RowCache) -> RowCache

Return a copy of the row cache.

Source code in odfdo/table_cache.py

@classmethod
def copy(cls, source: RowCache) -> RowCache:
    """Return a copy of the row cache."""
    rc = cls()
    rc.cell_map = source.cell_map[:]
    return rc

delete_cell_in_cache

delete_cell_in_cache(x: int, vault: Row) -> None

Delete the cell at position x from cache and row element.

Source code in odfdo/table_cache.py

def delete_cell_in_cache(
    self,
    x: int,
    vault: Row,
) -> None:
    """Delete the cell at position x from cache and row element."""
    idx = self.cell_idx(x)
    if idx is None:
        raise ValueError
    current_cached_cell: Cell | None = self.cached_cell(idx)
    if current_cached_cell is None:
        current_cached_cell = vault._get_element_idx2(_XP_CELL_IDX, idx)  # ty: ignore[invalid-assignment]
    if not current_cached_cell:
        raise ValueError  # pragma: nocover
    self.clear_cell_indexes()
    emap = _delete_item_in_vault(
        idx,
        current_cached_cell,
        vault,
        self.cell_map,
    )
    self.cell_map = emap

insert_cell_in_cache

insert_cell_in_cache(
    x: int, cell: Cell, vault: Row
) -> Cell

Insert a cell in cache and row element at position x.

Source code in odfdo/table_cache.py

def insert_cell_in_cache(
    self,
    x: int,
    cell: Cell,
    vault: Row,
) -> Cell:
    """Insert a cell in cache and row element at position x."""
    idx = self.cell_idx(x)
    if idx is None:
        raise ValueError
    current_cached_cell: Cell | None = self.cached_cell(idx)
    if current_cached_cell is None:
        current_cached_cell = vault._get_element_idx2(_XP_CELL_IDX, idx)  # ty: ignore[invalid-assignment]
    if not current_cached_cell:
        raise ValueError  # pragma: nocover
    self.clear_cell_indexes()
    emap, new_cell = _insert_item_in_vault(
        x,
        cell,
        idx,
        current_cached_cell,
        vault,
        self.cell_map,
    )
    self.cell_map = emap
    return new_cell  # ty: ignore[invalid-return-type]

insert_cell_map_once

insert_cell_map_once(repeated: int) -> None

Insert a repeated cell count into the cell map.

Source code in odfdo/table_cache.py

def insert_cell_map_once(self, repeated: int) -> None:
    """Insert a repeated cell count into the cell map."""
    self.cell_map = _insert_map_once(self.cell_map, len(self.cell_map), repeated)

make_cell_map

make_cell_map(
    idx_repeated_sequence: list[tuple[int, int]],
) -> None

Build the cell map from repeated sequence data.

Source code in odfdo/table_cache.py

def make_cell_map(self, idx_repeated_sequence: list[tuple[int, int]]) -> None:
    """Build the cell map from repeated sequence data."""
    self.cell_map = _make_cache_map(idx_repeated_sequence)

set_cell_in_cache

set_cell_in_cache(
    x: int, cell: Cell, vault: Row, clone: bool
) -> Cell

Update the cache and row element with a cell at position x.

Source code in odfdo/table_cache.py

def set_cell_in_cache(
    self,
    x: int,
    cell: Cell,
    vault: Row,
    clone: bool,
) -> Cell:
    """Update the cache and row element with a cell at position x."""
    idx = self.cell_idx(x)
    if idx is None:
        raise ValueError
    current_cached_cell: Cell | None = self.cached_cell(idx)
    if current_cached_cell is None:
        current_cached_cell = vault._get_element_idx2(_XP_CELL_IDX, idx)  # ty: ignore[invalid-assignment]
    if not current_cached_cell:
        raise ValueError  # pragma: nocover
    self.clear_cell_indexes()
    emap, new_cell = _set_item_in_vault(
        x,
        cell,
        idx,
        current_cached_cell,
        vault,
        self.cell_map,
        _XP_CELL_IDX,
        clone,
    )
    self.cell_map = emap
    return new_cell  # ty: ignore[invalid-return-type]

store_cell

store_cell(cell: Cell, idx: int) -> None

Store Cell in cache.

Source code in odfdo/table_cache.py

def store_cell(self, cell: Cell, idx: int) -> None:
    """Store Cell in cache."""
    self.cell_elements[idx] = cell

width

width() -> int

Get the number of expected cells in the row, i.e. addition repetitions.

Returns:

Name	Type	Description
int	int	The number of expected cells in the row.

Source code in odfdo/table_cache.py

def width(self) -> int:
    """Get the number of expected cells in the row, i.e. addition
    repetitions.

    Returns:
        int: The number of expected cells in the row.

    """
    try:
        return self.cell_map[-1] + 1
    except IndexError:
        return 0

TableCache

Cache for Table (internal).

Methods:

Name	Description
__init__	Initialize a TableCache.
__str__
cached_col	Retrieve Column in cache.
cached_row	Retrieve Row in cache.
clear_col_indexes	Clear the indexed cached columns.
clear_row_indexes	Clear the indexed cached rows.
col_idx	Find column index in the map from the position.
col_map_length	Return the length of the column map.
copy	Return a copy of the table cache.
delete_col_in_cache	Delete the column at position x from cache and table element.
delete_row_in_cache	Delete the row at position y from cache and table element.
height	Get the current height of the table.
insert_col_in_cache	Insert a column in cache and table element at position x.
insert_col_map_once	Insert a repeated column count into the column map.
insert_row_in_cache	Insert a row in cache and table element at position y.
insert_row_map_once	Insert a repeated row count into the row map.
make_col_map	Build the column map from repeated sequence data.
make_row_map	Build the row map from repeated sequence data.
row_idx	Find row index in the map from the position.
set_col_in_cache	Update the cache and table element with a column at position x.
set_row_in_cache	Update the cache and table element with a row at position y.
store_col	Store Column in cache.
store_row	Store Row in cache.
width	Get the current width of the table, measured on columns.

Attributes:

Name	Type	Description
__slots__
cached_width	int | None
col_elements	dict[int, Column]
col_map	list[int]
row_elements	dict[int, Row]
row_map	list[int]

Source code in odfdo/table_cache.py

class TableCache:
    """Cache for Table (internal)."""

    __slots__ = (
        "cached_width",
        "col_elements",
        "col_map",
        "row_elements",
        "row_map",
    )

    def __init__(self) -> None:
        """Initialize a TableCache."""
        self.row_map: list[int] = []
        self.col_map: list[int] = []
        self.row_elements: dict[int, Row] = {}
        self.col_elements: dict[int, Column] = {}
        self.cached_width: int | None = None

    def __str__(self) -> str:
        return f"TC row:{self.row_map!r} col:{self.col_map!r}"

    @classmethod
    def copy(cls, source: TableCache) -> TableCache:
        """Return a copy of the table cache."""
        tc = cls()
        tc.row_map = source.row_map[:]
        tc.col_map = source.col_map[:]
        tc.cached_width = source.cached_width
        return tc

    def height(self) -> int:
        """Get the current height of the table.

        Returns:
            int: The current height of the table.

        """
        try:
            return self.row_map[-1] + 1
        except IndexError:
            return 0

    def width(self) -> int:
        """Get the current width of the table, measured on columns.

        Rows may have different widths, use the Table API to ensure width
        consistency.

        Returns:
            int: The current width of the table.

        """
        try:
            return self.col_map[-1] + 1
        except IndexError:
            return 0

    def clear_row_indexes(self) -> None:
        """Clear the indexed cached rows."""
        self.row_elements = {}
        self.cached_width = None

    def clear_col_indexes(self) -> None:
        """Clear the indexed cached columns."""
        self.col_elements = {}
        self.cached_width = None

    def row_idx(self, position: int) -> int | None:
        """Find row index in the map from the position."""
        idx = bisect_left(self.row_map, position)
        if idx < len(self.row_map):
            return idx
        return None

    def col_idx(self, position: int) -> int | None:
        """Find column index in the map from the position."""
        idx = bisect_left(self.col_map, position)
        if idx < len(self.col_map):
            return idx
        return None

    def col_map_length(self) -> int:
        """Return the length of the column map."""
        return len(self.col_map)

    def cached_row(self, idx: int) -> Row | None:
        """Retrieve Row in cache."""
        return self.row_elements.get(idx)

    def cached_col(self, idx: int) -> Column | None:
        """Retrieve Column in cache."""
        return self.col_elements.get(idx)

    def store_row(self, row: Row, idx: int) -> None:
        """Store Row in cache."""
        self.row_elements[idx] = row

    def store_col(self, col: Column, idx: int) -> None:
        """Store Column in cache."""
        self.col_elements[idx] = col

    def insert_row_map_once(self, repeated: int) -> None:
        """Insert a repeated row count into the row map."""
        self.row_map = _insert_map_once(self.row_map, len(self.row_map), repeated)
        self.cached_width = None

    # def erase_row_map_once(self, odf_idx: int) -> None:
    #     self.row_map = _erase_map_once(self.row_map, odf_idx)

    def insert_col_map_once(self, repeated: int) -> None:
        """Insert a repeated column count into the column map."""
        self.col_map = _insert_map_once(self.col_map, len(self.col_map), repeated)
        self.cached_width = None

    # def erase_col_map_once(self, odf_idx: int) -> None:
    #     self.col_map = _erase_map_once(self.col_map, odf_idx)

    def make_row_map(self, idx_repeated_sequence: list[tuple[int, int]]) -> None:
        """Build the row map from repeated sequence data."""
        self.row_map = _make_cache_map(idx_repeated_sequence)
        self.cached_width = None

    def make_col_map(self, idx_repeated_sequence: list[tuple[int, int]]) -> None:
        """Build the column map from repeated sequence data."""
        self.col_map = _make_cache_map(idx_repeated_sequence)
        self.cached_width = None

    def set_row_in_cache(
        self,
        y: int,
        row: Row,
        vault: Table,
        clone: bool,
    ) -> Row:
        """Update the cache and table element with a row at position y."""
        idx = self.row_idx(y)
        if idx is None:
            raise ValueError
        current_cached_row: Row | None = self.cached_row(idx)
        if current_cached_row is None:
            current_cached_row = vault._get_element_idx2(_XP_ROW_IDX, idx)  # ty: ignore[invalid-assignment]
        if not current_cached_row:
            raise ValueError  # pragma: nocover
        self.clear_row_indexes()
        emap, new_row = _set_item_in_vault(
            y,
            row,
            idx,
            current_cached_row,
            vault,
            self.row_map,
            _XP_ROW_IDX,
            clone,
        )
        self.row_map = emap
        return new_row  # ty: ignore[invalid-return-type]

    def insert_row_in_cache(
        self,
        y: int,
        row: Row,
        vault: Table,
    ) -> Row:
        """Insert a row in cache and table element at position y."""
        idx = self.row_idx(y)
        if idx is None:
            raise ValueError
        current_cached_row: Row | None = self.cached_row(idx)
        if current_cached_row is None:
            current_cached_row = vault._get_element_idx2(_XP_ROW_IDX, idx)  # ty: ignore[invalid-assignment]
        if not current_cached_row:
            raise ValueError  # pragma: nocover
        self.clear_row_indexes()
        emap, new_row = _insert_item_in_vault(
            y,
            row,
            idx,
            current_cached_row,
            vault,
            self.row_map,
        )
        self.row_map = emap
        return new_row  # ty: ignore[invalid-return-type]

    def delete_row_in_cache(
        self,
        y: int,
        vault: Table,
    ) -> None:
        """Delete the row at position y from cache and table element."""
        idx = self.row_idx(y)
        if idx is None:
            raise ValueError
        current_cached_row: Row | None = self.cached_row(idx)
        if current_cached_row is None:
            current_cached_row = vault._get_element_idx2(_XP_ROW_IDX, idx)  # ty: ignore[invalid-assignment]
        if not current_cached_row:
            raise ValueError  # pragma: nocover
        self.clear_row_indexes()
        emap = _delete_item_in_vault(
            idx,
            current_cached_row,
            vault,
            self.row_map,
        )
        self.row_map = emap

    def set_col_in_cache(
        self,
        x: int,
        column: Column,
        vault: Table,
    ) -> Column:
        """Update the cache and table element with a column at position x."""
        idx = self.col_idx(x)
        if idx is None:
            raise ValueError
        current_cached_col: Column | None = self.cached_col(idx)
        if current_cached_col is None:
            current_cached_col = vault._get_element_idx2(_XP_COLUMN_IDX, idx)  # ty: ignore[invalid-assignment]
        if not current_cached_col:
            raise ValueError  # pragma: nocover
        self.clear_col_indexes()
        emap, new_col = _set_item_in_vault(
            x,
            column,
            idx,
            current_cached_col,
            vault,
            self.col_map,
            _XP_COLUMN_IDX,
        )
        self.col_map = emap
        return new_col  # ty: ignore[invalid-return-type]

    def insert_col_in_cache(
        self,
        x: int,
        column: Column,
        vault: Table,
    ) -> Column:
        """Insert a column in cache and table element at position x."""
        idx = self.col_idx(x)
        if idx is None:
            raise ValueError
        current_cached_col: Column | None = self.cached_col(idx)
        if current_cached_col is None:
            current_cached_col = vault._get_element_idx2(_XP_COLUMN_IDX, idx)  # ty: ignore[invalid-assignment]
        if not current_cached_col:
            raise ValueError  # pragma: nocover
        self.clear_col_indexes()
        emap, new_col = _insert_item_in_vault(
            x,
            column,
            idx,
            current_cached_col,
            vault,
            self.col_map,
        )
        self.col_map = emap
        return new_col  # ty: ignore[invalid-return-type]

    def delete_col_in_cache(
        self,
        x: int,
        vault: Table,
    ) -> None:
        """Delete the column at position x from cache and table element."""
        idx = self.col_idx(x)
        if idx is None:
            raise ValueError
        current_cached_col: Column | None = self.cached_col(idx)
        if current_cached_col is None:
            current_cached_col = vault._get_element_idx2(_XP_COLUMN_IDX, idx)  # ty: ignore[invalid-assignment]
        if not current_cached_col:
            raise ValueError  # pragma: nocover
        self.clear_col_indexes()
        emap = _delete_item_in_vault(
            idx,
            current_cached_col,
            vault,
            self.col_map,
        )
        self.col_map = emap

__slots__ class-attribute instance-attribute

__slots__ = (
    "cached_width",
    "col_elements",
    "col_map",
    "row_elements",
    "row_map",
)

cached_width instance-attribute

cached_width: int | None = None

col_elements instance-attribute

col_elements: dict[int, Column] = {}

col_map instance-attribute

col_map: list[int] = []

row_elements instance-attribute

row_elements: dict[int, Row] = {}

row_map instance-attribute

row_map: list[int] = []

__init__

__init__() -> None

Initialize a TableCache.

Source code in odfdo/table_cache.py

def __init__(self) -> None:
    """Initialize a TableCache."""
    self.row_map: list[int] = []
    self.col_map: list[int] = []
    self.row_elements: dict[int, Row] = {}
    self.col_elements: dict[int, Column] = {}
    self.cached_width: int | None = None

__str__

__str__() -> str

Source code in odfdo/table_cache.py

def __str__(self) -> str:
    return f"TC row:{self.row_map!r} col:{self.col_map!r}"

cached_col

cached_col(idx: int) -> Column | None

Retrieve Column in cache.

Source code in odfdo/table_cache.py

def cached_col(self, idx: int) -> Column | None:
    """Retrieve Column in cache."""
    return self.col_elements.get(idx)

cached_row

cached_row(idx: int) -> Row | None

Retrieve Row in cache.

Source code in odfdo/table_cache.py

def cached_row(self, idx: int) -> Row | None:
    """Retrieve Row in cache."""
    return self.row_elements.get(idx)

clear_col_indexes

clear_col_indexes() -> None

Clear the indexed cached columns.

Source code in odfdo/table_cache.py

def clear_col_indexes(self) -> None:
    """Clear the indexed cached columns."""
    self.col_elements = {}
    self.cached_width = None

clear_row_indexes

clear_row_indexes() -> None

Clear the indexed cached rows.

Source code in odfdo/table_cache.py

def clear_row_indexes(self) -> None:
    """Clear the indexed cached rows."""
    self.row_elements = {}
    self.cached_width = None

col_idx

col_idx(position: int) -> int | None

Find column index in the map from the position.

Source code in odfdo/table_cache.py

def col_idx(self, position: int) -> int | None:
    """Find column index in the map from the position."""
    idx = bisect_left(self.col_map, position)
    if idx < len(self.col_map):
        return idx
    return None

col_map_length

col_map_length() -> int

Return the length of the column map.

Source code in odfdo/table_cache.py

def col_map_length(self) -> int:
    """Return the length of the column map."""
    return len(self.col_map)

copy classmethod

copy(source: TableCache) -> TableCache

Return a copy of the table cache.

Source code in odfdo/table_cache.py

@classmethod
def copy(cls, source: TableCache) -> TableCache:
    """Return a copy of the table cache."""
    tc = cls()
    tc.row_map = source.row_map[:]
    tc.col_map = source.col_map[:]
    tc.cached_width = source.cached_width
    return tc

delete_col_in_cache

delete_col_in_cache(x: int, vault: Table) -> None

Delete the column at position x from cache and table element.

Source code in odfdo/table_cache.py

def delete_col_in_cache(
    self,
    x: int,
    vault: Table,
) -> None:
    """Delete the column at position x from cache and table element."""
    idx = self.col_idx(x)
    if idx is None:
        raise ValueError
    current_cached_col: Column | None = self.cached_col(idx)
    if current_cached_col is None:
        current_cached_col = vault._get_element_idx2(_XP_COLUMN_IDX, idx)  # ty: ignore[invalid-assignment]
    if not current_cached_col:
        raise ValueError  # pragma: nocover
    self.clear_col_indexes()
    emap = _delete_item_in_vault(
        idx,
        current_cached_col,
        vault,
        self.col_map,
    )
    self.col_map = emap

delete_row_in_cache

delete_row_in_cache(y: int, vault: Table) -> None

Delete the row at position y from cache and table element.

Source code in odfdo/table_cache.py

def delete_row_in_cache(
    self,
    y: int,
    vault: Table,
) -> None:
    """Delete the row at position y from cache and table element."""
    idx = self.row_idx(y)
    if idx is None:
        raise ValueError
    current_cached_row: Row | None = self.cached_row(idx)
    if current_cached_row is None:
        current_cached_row = vault._get_element_idx2(_XP_ROW_IDX, idx)  # ty: ignore[invalid-assignment]
    if not current_cached_row:
        raise ValueError  # pragma: nocover
    self.clear_row_indexes()
    emap = _delete_item_in_vault(
        idx,
        current_cached_row,
        vault,
        self.row_map,
    )
    self.row_map = emap

height

height() -> int

Get the current height of the table.

Returns:

Name	Type	Description
int	int	The current height of the table.

Source code in odfdo/table_cache.py

def height(self) -> int:
    """Get the current height of the table.

    Returns:
        int: The current height of the table.

    """
    try:
        return self.row_map[-1] + 1
    except IndexError:
        return 0

insert_col_in_cache

insert_col_in_cache(
    x: int, column: Column, vault: Table
) -> Column

Insert a column in cache and table element at position x.

Source code in odfdo/table_cache.py

def insert_col_in_cache(
    self,
    x: int,
    column: Column,
    vault: Table,
) -> Column:
    """Insert a column in cache and table element at position x."""
    idx = self.col_idx(x)
    if idx is None:
        raise ValueError
    current_cached_col: Column | None = self.cached_col(idx)
    if current_cached_col is None:
        current_cached_col = vault._get_element_idx2(_XP_COLUMN_IDX, idx)  # ty: ignore[invalid-assignment]
    if not current_cached_col:
        raise ValueError  # pragma: nocover
    self.clear_col_indexes()
    emap, new_col = _insert_item_in_vault(
        x,
        column,
        idx,
        current_cached_col,
        vault,
        self.col_map,
    )
    self.col_map = emap
    return new_col  # ty: ignore[invalid-return-type]

insert_col_map_once

insert_col_map_once(repeated: int) -> None

Insert a repeated column count into the column map.

Source code in odfdo/table_cache.py

def insert_col_map_once(self, repeated: int) -> None:
    """Insert a repeated column count into the column map."""
    self.col_map = _insert_map_once(self.col_map, len(self.col_map), repeated)
    self.cached_width = None

insert_row_in_cache

insert_row_in_cache(y: int, row: Row, vault: Table) -> Row

Insert a row in cache and table element at position y.

Source code in odfdo/table_cache.py

def insert_row_in_cache(
    self,
    y: int,
    row: Row,
    vault: Table,
) -> Row:
    """Insert a row in cache and table element at position y."""
    idx = self.row_idx(y)
    if idx is None:
        raise ValueError
    current_cached_row: Row | None = self.cached_row(idx)
    if current_cached_row is None:
        current_cached_row = vault._get_element_idx2(_XP_ROW_IDX, idx)  # ty: ignore[invalid-assignment]
    if not current_cached_row:
        raise ValueError  # pragma: nocover
    self.clear_row_indexes()
    emap, new_row = _insert_item_in_vault(
        y,
        row,
        idx,
        current_cached_row,
        vault,
        self.row_map,
    )
    self.row_map = emap
    return new_row  # ty: ignore[invalid-return-type]

insert_row_map_once

insert_row_map_once(repeated: int) -> None

Insert a repeated row count into the row map.

Source code in odfdo/table_cache.py

def insert_row_map_once(self, repeated: int) -> None:
    """Insert a repeated row count into the row map."""
    self.row_map = _insert_map_once(self.row_map, len(self.row_map), repeated)
    self.cached_width = None

make_col_map

make_col_map(
    idx_repeated_sequence: list[tuple[int, int]],
) -> None

Build the column map from repeated sequence data.

Source code in odfdo/table_cache.py

def make_col_map(self, idx_repeated_sequence: list[tuple[int, int]]) -> None:
    """Build the column map from repeated sequence data."""
    self.col_map = _make_cache_map(idx_repeated_sequence)
    self.cached_width = None

make_row_map

make_row_map(
    idx_repeated_sequence: list[tuple[int, int]],
) -> None

Build the row map from repeated sequence data.

Source code in odfdo/table_cache.py

def make_row_map(self, idx_repeated_sequence: list[tuple[int, int]]) -> None:
    """Build the row map from repeated sequence data."""
    self.row_map = _make_cache_map(idx_repeated_sequence)
    self.cached_width = None

row_idx

row_idx(position: int) -> int | None

Find row index in the map from the position.

Source code in odfdo/table_cache.py

def row_idx(self, position: int) -> int | None:
    """Find row index in the map from the position."""
    idx = bisect_left(self.row_map, position)
    if idx < len(self.row_map):
        return idx
    return None

set_col_in_cache

set_col_in_cache(
    x: int, column: Column, vault: Table
) -> Column

Update the cache and table element with a column at position x.

Source code in odfdo/table_cache.py

def set_col_in_cache(
    self,
    x: int,
    column: Column,
    vault: Table,
) -> Column:
    """Update the cache and table element with a column at position x."""
    idx = self.col_idx(x)
    if idx is None:
        raise ValueError
    current_cached_col: Column | None = self.cached_col(idx)
    if current_cached_col is None:
        current_cached_col = vault._get_element_idx2(_XP_COLUMN_IDX, idx)  # ty: ignore[invalid-assignment]
    if not current_cached_col:
        raise ValueError  # pragma: nocover
    self.clear_col_indexes()
    emap, new_col = _set_item_in_vault(
        x,
        column,
        idx,
        current_cached_col,
        vault,
        self.col_map,
        _XP_COLUMN_IDX,
    )
    self.col_map = emap
    return new_col  # ty: ignore[invalid-return-type]

set_row_in_cache

set_row_in_cache(
    y: int, row: Row, vault: Table, clone: bool
) -> Row

Update the cache and table element with a row at position y.

Source code in odfdo/table_cache.py

def set_row_in_cache(
    self,
    y: int,
    row: Row,
    vault: Table,
    clone: bool,
) -> Row:
    """Update the cache and table element with a row at position y."""
    idx = self.row_idx(y)
    if idx is None:
        raise ValueError
    current_cached_row: Row | None = self.cached_row(idx)
    if current_cached_row is None:
        current_cached_row = vault._get_element_idx2(_XP_ROW_IDX, idx)  # ty: ignore[invalid-assignment]
    if not current_cached_row:
        raise ValueError  # pragma: nocover
    self.clear_row_indexes()
    emap, new_row = _set_item_in_vault(
        y,
        row,
        idx,
        current_cached_row,
        vault,
        self.row_map,
        _XP_ROW_IDX,
        clone,
    )
    self.row_map = emap
    return new_row  # ty: ignore[invalid-return-type]

store_col

store_col(col: Column, idx: int) -> None

Store Column in cache.

Source code in odfdo/table_cache.py

def store_col(self, col: Column, idx: int) -> None:
    """Store Column in cache."""
    self.col_elements[idx] = col

store_row

store_row(row: Row, idx: int) -> None

Store Row in cache.

Source code in odfdo/table_cache.py

def store_row(self, row: Row, idx: int) -> None:
    """Store Row in cache."""
    self.row_elements[idx] = row

width

width() -> int

Get the current width of the table, measured on columns.

Rows may have different widths, use the Table API to ensure width consistency.

Returns:

Name	Type	Description
int	int	The current width of the table.

Source code in odfdo/table_cache.py

def width(self) -> int:
    """Get the current width of the table, measured on columns.

    Rows may have different widths, use the Table API to ensure width
    consistency.

    Returns:
        int: The current width of the table.

    """
    try:
        return self.col_map[-1] + 1
    except IndexError:
        return 0

_delete_item_in_vault

_delete_item_in_vault(
    idx: int,
    current_item: Cell | Row | Column,
    vault: Row | Table,
    vault_map: list[int],
) -> list[int]

Source code in odfdo/table_cache.py

def _delete_item_in_vault(
    idx: int,
    current_item: Cell | Row | Column,
    vault: Row | Table,
    vault_map: list[int],
) -> list[int]:
    current_cache = vault_map[idx]
    if idx > 0:
        before_cache = vault_map[idx - 1]
    else:
        before_cache = -1
    # current_pos = before_cache + 1
    current_repeated = current_cache - before_cache
    new_repeated = current_repeated - 1
    if new_repeated >= 1:
        current_item._set_repeated(new_repeated)
        emap = vault_map[:idx] + [(x - 1) for x in vault_map[idx:]]
    else:
        # actual erase
        vault.delete(current_item)
        emap = vault_map[:idx] + [(x - 1) for x in vault_map[idx + 1 :]]
    return emap

_erase_map_once

_erase_map_once(
    cache_map: list[int], odf_idx: int
) -> list[int]

Remove an item (cell or row) from the map.

Parameters:

Name	Type	Description	Default
cache_map	list[int]	Cache map.	required
odf_idx	int	Index in ODF XML.	required

Source code in odfdo/table_cache.py

def _erase_map_once(cache_map: list[int], odf_idx: int) -> list[int]:
    """Remove an item (cell or row) from the map.

    Args:
        cache_map: Cache map.
        odf_idx: Index in ODF XML.

    """
    if odf_idx >= len(cache_map):
        raise IndexError
    if odf_idx > 0:
        before = cache_map[odf_idx - 1]
    else:
        before = -1
    current = cache_map[odf_idx]
    repeated = current - before
    return cache_map[:odf_idx] + [(x - repeated) for x in cache_map[odf_idx + 1 :]]

_insert_item_in_vault

_insert_item_in_vault(
    position: int,
    item: Cell | Row | Column,
    idx: int,
    current_item: Cell | Row | Column,
    vault: Row | Table,
    vault_map: list[int],
) -> tuple[list[int], Cell | Row | Column]

Source code in odfdo/table_cache.py

def _insert_item_in_vault(
    position: int,
    item: Cell | Row | Column,
    idx: int,
    current_item: Cell | Row | Column,
    vault: Row | Table,
    vault_map: list[int],
) -> tuple[list[int], Cell | Row | Column]:
    repeated = item.repeated or 1
    target_idx = vault.index(current_item)
    current_cache = vault_map[idx]
    if idx > 0:
        before_cache = vault_map[idx - 1]
    else:
        before_cache = -1
    current_pos = before_cache + 1
    current_repeated = current_cache - before_cache
    repeated_before = position - current_pos
    repeated_after = current_repeated - repeated_before
    new_item = item.clone
    if repeated_before >= 1:
        current_item._set_repeated(repeated_before)
        vault.insert(new_item, position=target_idx + 1)
        after_item = current_item.clone
        after_item._set_repeated(repeated_after)
        vault.insert(after_item, position=target_idx + 2)
    else:
        # only insert new cell
        vault.insert(new_item, position=target_idx)
    # update cache
    if repeated_before >= 1:
        emap = _erase_map_once(vault_map, idx)
        emap = _insert_map_once(emap, idx, repeated_before)
        emap = _insert_map_once(emap, idx + 1, repeated)
        emap = _insert_map_once(emap, idx + 2, repeated_after)
    else:
        emap = _insert_map_once(vault_map, idx, repeated)
    return emap, new_item

_insert_map_once

_insert_map_once(
    cache_map: list[int], odf_idx: int, repeated: int
) -> list[int]

Add an item (cell or row) to the map.

Parameters:

Name	Type	Description	Default
cache_map	list[int]	Cache map.	required
odf_idx	int	Index in ODF XML.	required
repeated	int	Repeated value of item, 1 or more.	required

odf_idx is NOT position (col or row), neither raw XML position, but ODF index

Source code in odfdo/table_cache.py

def _insert_map_once(
    cache_map: list[int],
    odf_idx: int,
    repeated: int,
) -> list[int]:
    """Add an item (cell or row) to the map.

    Args:
        cache_map: Cache map.
        odf_idx: Index in ODF XML.
        repeated: Repeated value of item, 1 or more.

    odf_idx is NOT position (col or row), neither raw XML position, but ODF index

    """
    repeated = repeated or 1
    if odf_idx > len(cache_map):
        raise IndexError
    if odf_idx > 0:
        before = cache_map[odf_idx - 1]
    else:
        before = -1
    juska = before + repeated  # aka max position value for item
    if odf_idx == len(cache_map):
        insort(cache_map, juska)
        return cache_map
    new_map = cache_map[:odf_idx]
    new_map.append(juska)
    new_map.extend([(x + repeated) for x in cache_map[odf_idx:]])
    return new_map

_make_cache_map

_make_cache_map(
    idx_repeated_seq: list[tuple[int, int]],
) -> list[int]

Build the initial cache map of the table.

Source code in odfdo/table_cache.py

def _make_cache_map(idx_repeated_seq: list[tuple[int, int]]) -> list[int]:
    """Build the initial cache map of the table."""
    cache_map: list[int] = []
    for odf_idx, repeated in idx_repeated_seq:
        cache_map = _insert_map_once(cache_map, odf_idx, repeated)
    return cache_map

_set_item_in_vault

_set_item_in_vault(
    position: int,
    item: Cell | Row | Column,
    idx: int,
    current_item: Cell | Row | Column,
    vault: Row | Table,
    vault_map: list[int],
    vault_scheme: XPath,
    clone: bool = True,
) -> tuple[list[int], Cell | Row | Column]

Set the item (cell, row) in its vault (row, table), updating the cache map.

Parameters:

Name	Type	Description	Default
position	int	Position of the item.	required
item	Cell | Row | Column	The item to set.	required
idx	int	Index in ODF XML.	required
current_item	Cell | Row | Column	Current item.	required
vault	Row | Table	Vault.	required
vault_map	list[int]	Vault map.	required
vault_scheme	XPath	Vault scheme.	required
clone	bool	Whether to clone the item.	True

Source code in odfdo/table_cache.py

def _set_item_in_vault(
    position: int,
    item: Cell | Row | Column,
    idx: int,
    current_item: Cell | Row | Column,
    vault: Row | Table,
    vault_map: list[int],
    vault_scheme: XPath,
    clone: bool = True,
) -> tuple[list[int], Cell | Row | Column]:
    """Set the item (cell, row) in its vault (row, table), updating the cache
    map.

    Args:
        position: Position of the item.
        item: The item to set.
        idx: Index in ODF XML.
        current_item: Current item.
        vault: Vault.
        vault_map: Vault map.
        vault_scheme: Vault scheme.
        clone: Whether to clone the item.

    """
    repeated = item.repeated or 1
    target_idx = vault.index(current_item)
    current_cache = vault_map[idx]
    if idx > 0:
        before_cache = vault_map[idx - 1]
    else:
        before_cache = -1
    current_pos = before_cache + 1
    current_repeated = current_cache - before_cache
    repeated_before = position - current_pos
    repeated_after = current_repeated - repeated_before - repeated
    if repeated_before >= 1:
        # Update repetition
        current_item._set_repeated(repeated_before)
        target_idx += 1
    else:
        # Replacing the first occurrence
        vault.delete(current_item)
    # Insert new element
    if clone:
        new_item = item.clone
    else:
        new_item = item
    vault.insert(new_item, position=target_idx)
    # Insert the remaining repetitions
    if repeated_after >= 1:
        after_item = current_item.clone
        after_item._set_repeated(repeated_after)
        vault.insert(after_item, position=target_idx + 1)
    # setting a repeated item !
    if repeated_after < 0:
        # deleting some overlapped items
        deleting = repeated_after
        while deleting < 0:
            delete_item = vault._get_element_idx2(vault_scheme, target_idx + 1)
            if delete_item is None:
                break
            is_repeated = delete_item.repeated or 1
            is_repeated += deleting
            if is_repeated > 1:
                delete_item._set_repeated(is_repeated)
            else:
                vault.delete(delete_item)
            deleting = is_repeated
    # update cache
    # remove existing
    emap = _erase_map_once(vault_map, idx)
    # add before if any:
    if repeated_before >= 1:
        emap = _insert_map_once(emap, idx, repeated_before)
        idx += 1
    # add our slot
    emap = _insert_map_once(emap, idx, repeated)
    # add after if any::
    if repeated_after >= 1:
        idx += 1
        emap = _insert_map_once(emap, idx, repeated_after)
    if repeated_after < 0:
        idx += 1
        while repeated_after < 0:
            if idx < len(emap):
                emap = _erase_map_once(emap, idx)
            repeated_after += 1
    return emap, new_item