# How to Enable Data Integrity and Table Size Checking in Outfancy

> Learn to enable data integrity and table size checking in Outfancy. Follow this guide to ensure your data is accurate and tables are optimized. Improve your Outfancy experience now.

- Repository: [Carlos A. Planchón/outfancy](https://github.com/carlosplanchon/outfancy)
- Tags: how-to-guide
- Published: 2026-02-26

---

**Enable data integrity and table size checking in Outfancy by calling `Table.set_check_data(True)` and `Table.set_check_table_size(True)` on your Table instance before invoking `render()`.**

Outfancy is a Python library designed for rendering clean, formatted tables in terminal environments. When working with dynamic datasets, you can activate built-in validation mechanisms to catch structural errors and enforce row limits before the rendering pipeline executes.

## Understanding the Validation Options

Outfancy's table rendering engine validates incoming datasets through two independent checks defined in [`outfancy/table.py`](https://github.com/carlosplanchon/outfancy/blob/main/outfancy/table.py):

- **Data integrity checking** validates that your dataset is a non-empty list of tuples with consistent column counts, ensuring no tuple contains lists or boolean values.
- **Table size checking** verifies that the number of rows does not exceed the configured `maximum_number_of_rows` threshold.

Both checks are disabled by default (`self.check_data = False` and `self.check_table_size = False`) and must be explicitly enabled via setter methods.

## Enabling Data Integrity Checking

To validate dataset structure before rendering, call `set_check_data(True)` on your `Table` instance. When enabled, the `render()` method invokes `check_data_integrity()` (lines 84-124 in [`outfancy/table.py`](https://github.com/carlosplanchon/outfancy/blob/main/outfancy/table.py)) to verify:

- The dataset is a non-empty list of tuples
- Every tuple has identical length (consistent columns)
- No tuple element is a list or boolean

If validation fails, `render()` returns an error string instead of the formatted table:

```python
from outfancy import Table

tbl = Table()
tbl.set_check_data(True)

# This will fail validation due to inconsistent tuple lengths and invalid types

bad_data = [
    (1, 'Alice'),                     # 2 columns

    (2, ['Bob', 'extra']),            # list inside tuple → invalid

    (3, 'Carol', 'Manager', 'extra')  # 4 columns

]

result = tbl.render(bad_data)
print(result)

# Output: --- Table > Render > check_data_integrity: Corrupt or invalid data. ---

```

## Configuring Table Size Limits

To enforce row count limits, enable size checking with `set_check_table_size(True)` and optionally configure the limit using `set_maximum_number_of_rows()` (default is `-1` for unlimited). This triggers the `check_correct_table_size()` method (lines 72-84 in [`outfancy/table.py`](https://github.com/carlosplanchon/outfancy/blob/main/outfancy/table.py)):

```python
tbl = Table()
tbl.set_check_table_size(True)
tbl.set_maximum_number_of_rows(2)   # Allow only 2 rows

data = [
    (1, 'Alice'), 
    (2, 'Bob'), 
    (3, 'Carol')
]

result = tbl.render(data)
print(result)

# Output: --- Table > Render: The data dimensions are incongruent. ---

```

## Complete Implementation Example

Here is a full implementation enabling both validation layers with a configured row limit:

```python
from outfancy import Table

# Create a Table instance

tbl = Table()

# Enable both safety checks

tbl.set_check_data(True)          # Validate data structure and content

tbl.set_check_table_size(True)    # Enforce row-count limits

# Set maximum rows (optional, defaults to -1/unlimited)

tbl.set_maximum_number_of_rows(100)

# Render a valid dataset

data = [
    (1, 'Alice', 'Engineer'),
    (2, 'Bob', 'Designer'),
    (3, 'Carol', 'Manager')
]

result = tbl.render(data)
print(result)

```

## How Validation Works in the Rendering Pipeline

According to the source code in [`outfancy/table.py`](https://github.com/carlosplanchon/outfancy/blob/main/outfancy/table.py), the `render()` method (around lines 300-324) consults these boolean flags early in the execution flow:

```python
if self.check_data:
    if self.check_data_integrity(data):
        return '--- Table > Render > check_data_integrity: Corrupt or invalid data. ---'

if self.check_table_size:
    if self.check_correct_table_size(data):
        return '--- Table > Render: The data dimensions are incongruent. --- '

```

The flags are initialized in the `Table` class constructor at lines 46-51:

- **Integrity flag and setter**: Lines 46-48 define `self.check_data` and `set_check_data()`
- **Size flag and setter**: Lines 49-51 define `self.check_table_size` and `set_check_table_size()`

Because these checks execute before any formatting logic, they prevent processing overhead on invalid datasets.

## Summary

- **Data integrity checking** validates tuple structure, column consistency, and prohibited data types via `Table.set_check_data(True)`, implemented in `check_data_integrity()` at lines 84-124 of [`outfancy/table.py`](https://github.com/carlosplanchon/outfancy/blob/main/outfancy/table.py).
- **Table size checking** enforces row limits via `Table.set_check_table_size(True)` and `set_maximum_number_of_rows()`, implemented in `check_correct_table_size()` at lines 72-84.
- Both checks are evaluated at the start of the `render()` method (lines 300-324) before any table formatting occurs.
- Failed validations return descriptive error strings rather than raising exceptions.

## Frequently Asked Questions

### What happens if I enable data integrity checking but pass an empty list?

The `check_data_integrity()` method validates that the dataset is non-empty. Passing an empty list will trigger the validation failure, causing `render()` to return the error message: `--- Table > Render > check_data_integrity: Corrupt or invalid data. ---`.

### Can I enable only one check without the other?

Yes, the two validation systems operate independently. You can call `set_check_data(True)` without enabling table size checking, or vice versa. Each flag controls only its specific validation routine in the rendering pipeline.

### Does enabling these checks affect rendering performance?

The validation adds minimal overhead because it executes early in the `render()` method before expensive formatting operations. The integrity check iterates through the dataset once to validate tuple lengths and types, while the size check simply compares `len(data)` against `maximum_number_of_rows`.

### Where are the setter methods defined in the source code?

The setter methods are defined in [`outfancy/table.py`](https://github.com/carlosplanchon/outfancy/blob/main/outfancy/table.py). Specifically, `set_check_data()` appears around lines 46-48 and `set_check_table_size()` around lines 49-51, alongside the boolean flag initializations in the `Table` class constructor.