Skip to content

omnipy.components.tables.models

Table models for row-wise, column-wise, CSV, TSV, and Pydantic-backed data.

CLASS DESCRIPTION
ColumnModel
ColumnWiseTableWithColNamesAndIndexModel
ColumnWiseTableWithColNamesModel

Represent tabular data as column names mapped to ordered value lists.
ColumnWiseTableWithColNamesNoConvertModel
ConcatByAddArrayAdapterModel
CsvTableModel

Parse CSV text into row-wise records with header-derived keys.
CsvTableOfPydanticRecordsModel

Parse CSV text into validated Pydantic records.
IterRow
IteratingPydanticRecordsModel

Validate every row in a table against a parameterized Pydantic model.
JsonMaxLevel1ColumnModel

Column model for JSON values nested at most one level deep.
JsonMaxLevel1ColumnWiseTableWithColNamesModel

Column-wise table whose cells allow JSON nesting up to one level.
JsonMaxLevel2ColumnModel

Column model for JSON values nested at most two levels deep.
JsonMaxLevel2ColumnWiseTableWithColNamesModel

Column-wise table whose cells allow JSON nesting up to two levels.
JsonScalarColumnModel

Column model whose cells are JSON scalar values.
JsonScalarColumnWiseTableWithColNamesModel

Column-wise table whose cells are JSON scalar values.
PrintableTable

Mark table-like models as printable in Omnipy rendering flows.
PydanticRecordModel

Validate a single record against a parameterized Pydantic model.
PydanticRecordModelBase

Validate tabular record data against a parameterized Pydantic schema.
PydanticRecordModelMetaclass

Compute and cache schema-derived header metadata for record models.
RowWiseTableFirstRowAsColNamesModel

Represent row-wise data where the first row defines the header.
RowWiseTableModel

Represent row-wise tabular data without explicit column names.
RowWiseTableWithColNamesModel

Represent row-wise tabular data keyed by column name.
RowWiseTableWithColNamesNoConvertModel

Store row-wise table records exactly as provided.
TableOfPydanticRecordsModel

Parse delimited text into validated Pydantic records.
TsvTableModel

Parse TSV text into row-wise records with header-derived keys.
ATTRIBUTE DESCRIPTION
ColWiseAddOtherType

TYPE: TypeAlias

JsonMaxLevel1Types

TYPE: TypeAlias

JsonMaxLevel2Types

TYPE: TypeAlias

ColWiseAddOtherType module-attribute 

ColWiseAddOtherType: TypeAlias = (
    RowWiseTableWithColNamesModel
    | IsItemSequenceLike[IsMapping[str, JsonScalar]]
    | Generator[IsMapping[str, JsonScalar]]
    | IsMapping[str, IsItemSequenceLike[JsonScalar] | Generator[JsonScalar]]
)

JsonMaxLevel1Types module-attribute 

JsonMaxLevel1Types: TypeAlias = JsonScalar | JsonDictOfScalars | JsonListOfScalars
Subclassed by:

JsonMaxLevel2Types module-attribute 

JsonMaxLevel2Types: TypeAlias = (
    JsonScalar
    | list[JsonScalar | JsonDictOfScalars | JsonListOfScalars]
    | dict[str, JsonScalar | JsonDictOfScalars | JsonListOfScalars]
)
Subclassed by:

ColumnModel

Bases: Model[_ColumnT], Generic[_ColumnT, _ItemT]


              flowchart BT
              omnipy.components.tables.models.ColumnModel[ColumnModel]
              omnipy.data.model.Model[Model]
              omnipy.data._mixins.display.ModelDisplayMixin[ModelDisplayMixin]
              omnipy.data._mixins.display.BaseDisplayMixin[BaseDisplayMixin]
              omnipy.data._data_class_creator.DataClassBase[DataClassBase]

                              omnipy.data.model.Model --> omnipy.components.tables.models.ColumnModel
                                omnipy.data._mixins.display.ModelDisplayMixin --> omnipy.data.model.Model
                                omnipy.data._mixins.display.BaseDisplayMixin --> omnipy.data._mixins.display.ModelDisplayMixin
                

                omnipy.data._data_class_creator.DataClassBase --> omnipy.data.model.Model
                
                omnipy.util.pydantic.GenericModel --> omnipy.data.model.Model
                



              click omnipy.components.tables.models.ColumnModel href "" "omnipy.components.tables.models.ColumnModel"
              click omnipy.data.model.Model href "" "omnipy.data.model.Model"
              click omnipy.data._mixins.display.ModelDisplayMixin href "" "omnipy.data._mixins.display.ModelDisplayMixin"
              click omnipy.data._mixins.display.BaseDisplayMixin href "" "omnipy.data._mixins.display.BaseDisplayMixin"
              click omnipy.data._data_class_creator.DataClassBase href "" "omnipy.data._data_class_creator.DataClassBase"
Subclassed by:
METHOD DESCRIPTION
default_value
filled
Source code in src/omnipy/components/tables/models.py 
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
class ColumnModel(Model[_ColumnT], Generic[_ColumnT, _ItemT]):
    @classmethod
    @functools.cache
    def default_value(cls) -> _ItemT:
        _TYPE_DEFAULT_ORDER = (None, float, int, str, list, dict, set)

        if not cls.is_nested_type():
            raise TypeError('ColumnModel type must be nested, with explicit inner '
                            'type. Current type: ' + str(cls.full_type()))

        inner_type = cls.inner_type(with_args=True)

        if is_union(inner_type):
            union_type = tuple(ensure_plain_type(_) for _ in get_args(inner_type))

            for _type in _TYPE_DEFAULT_ORDER:
                if _type is None and any(pyd.is_none_type(_) for _ in union_type):
                    return None
                elif _type in union_type:
                    if _type is float:
                        return float('nan')
                    else:
                        return _type()
        else:
            try:
                return inner_type()
            except Exception as e:
                raise TypeError(f'Unsupported type: {inner_type}') from e

        raise TypeError(f'Unsupported type: {inner_type}')

    @classmethod
    def filled(cls, value: _ItemT, length: int) -> Self:
        return cls(value for _ in range(length))

default_value cached classmethod 

default_value() -> _ItemT
Source code in src/omnipy/components/tables/models.py 
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
@classmethod
@functools.cache
def default_value(cls) -> _ItemT:
    _TYPE_DEFAULT_ORDER = (None, float, int, str, list, dict, set)

    if not cls.is_nested_type():
        raise TypeError('ColumnModel type must be nested, with explicit inner '
                        'type. Current type: ' + str(cls.full_type()))

    inner_type = cls.inner_type(with_args=True)

    if is_union(inner_type):
        union_type = tuple(ensure_plain_type(_) for _ in get_args(inner_type))

        for _type in _TYPE_DEFAULT_ORDER:
            if _type is None and any(pyd.is_none_type(_) for _ in union_type):
                return None
            elif _type in union_type:
                if _type is float:
                    return float('nan')
                else:
                    return _type()
    else:
        try:
            return inner_type()
        except Exception as e:
            raise TypeError(f'Unsupported type: {inner_type}') from e

    raise TypeError(f'Unsupported type: {inner_type}')

filled classmethod 

filled(value: _ItemT, length: int) -> Self
Source code in src/omnipy/components/tables/models.py 
185
186
187
@classmethod
def filled(cls, value: _ItemT, length: int) -> Self:
    return cls(value for _ in range(length))

ColumnWiseTableWithColNamesAndIndexModel

Bases: Model[dict[str, Mapping[str, JsonScalar]]]


              flowchart BT
              omnipy.components.tables.models.ColumnWiseTableWithColNamesAndIndexModel[ColumnWiseTableWithColNamesAndIndexModel]
              omnipy.data.model.Model[Model]
              omnipy.data._mixins.display.ModelDisplayMixin[ModelDisplayMixin]
              omnipy.data._mixins.display.BaseDisplayMixin[BaseDisplayMixin]
              omnipy.data._data_class_creator.DataClassBase[DataClassBase]

                              omnipy.data.model.Model --> omnipy.components.tables.models.ColumnWiseTableWithColNamesAndIndexModel
                                omnipy.data._mixins.display.ModelDisplayMixin --> omnipy.data.model.Model
                                omnipy.data._mixins.display.BaseDisplayMixin --> omnipy.data._mixins.display.ModelDisplayMixin
                

                omnipy.data._data_class_creator.DataClassBase --> omnipy.data.model.Model
                
                omnipy.util.pydantic.GenericModel --> omnipy.data.model.Model
                



              click omnipy.components.tables.models.ColumnWiseTableWithColNamesAndIndexModel href "" "omnipy.components.tables.models.ColumnWiseTableWithColNamesAndIndexModel"
              click omnipy.data.model.Model href "" "omnipy.data.model.Model"
              click omnipy.data._mixins.display.ModelDisplayMixin href "" "omnipy.data._mixins.display.ModelDisplayMixin"
              click omnipy.data._mixins.display.BaseDisplayMixin href "" "omnipy.data._mixins.display.BaseDisplayMixin"
              click omnipy.data._data_class_creator.DataClassBase href "" "omnipy.data._data_class_creator.DataClassBase"
Returned by: Subclassed by: Used by:
Source code in src/omnipy/components/tables/models.py 
374
375
class ColumnWiseTableWithColNamesAndIndexModel(Model[dict[str, Mapping[str, JsonScalar]]]):
    ...

ColumnWiseTableWithColNamesModel

Bases: _ColumnWiseTableWithColNamesMixin[_ColModelT, _ColModelItemT], _ColumnWiseTableWithColNamesModel[_ColModelT, _ColModelItemT], PrintableTable, Generic[_ColModelT, _ColModelItemT]


              flowchart BT
              omnipy.components.tables.models.ColumnWiseTableWithColNamesModel[ColumnWiseTableWithColNamesModel]
              omnipy.components.tables.models._ColumnWiseTableWithColNamesMixin[_ColumnWiseTableWithColNamesMixin]
              omnipy.components.tables.models._ColumnWiseTableWithColNamesModel[_ColumnWiseTableWithColNamesModel]
              omnipy.data.model.Model[Model]
              omnipy.data._mixins.display.ModelDisplayMixin[ModelDisplayMixin]
              omnipy.data._mixins.display.BaseDisplayMixin[BaseDisplayMixin]
              omnipy.data._data_class_creator.DataClassBase[DataClassBase]
              omnipy.components.tables.models.PrintableTable[PrintableTable]

                              omnipy.components.tables.models._ColumnWiseTableWithColNamesMixin --> omnipy.components.tables.models.ColumnWiseTableWithColNamesModel
                
                omnipy.components.tables.models._ColumnWiseTableWithColNamesModel --> omnipy.components.tables.models.ColumnWiseTableWithColNamesModel
                                omnipy.data.model.Model --> omnipy.components.tables.models._ColumnWiseTableWithColNamesModel
                                omnipy.data._mixins.display.ModelDisplayMixin --> omnipy.data.model.Model
                                omnipy.data._mixins.display.BaseDisplayMixin --> omnipy.data._mixins.display.ModelDisplayMixin
                

                omnipy.data._data_class_creator.DataClassBase --> omnipy.data.model.Model
                
                omnipy.util.pydantic.GenericModel --> omnipy.data.model.Model
                


                omnipy.components.tables.models.PrintableTable --> omnipy.components.tables.models.ColumnWiseTableWithColNamesModel
                


              click omnipy.components.tables.models.ColumnWiseTableWithColNamesModel href "" "omnipy.components.tables.models.ColumnWiseTableWithColNamesModel"
              click omnipy.components.tables.models._ColumnWiseTableWithColNamesMixin href "" "omnipy.components.tables.models._ColumnWiseTableWithColNamesMixin"
              click omnipy.components.tables.models._ColumnWiseTableWithColNamesModel href "" "omnipy.components.tables.models._ColumnWiseTableWithColNamesModel"
              click omnipy.data.model.Model href "" "omnipy.data.model.Model"
              click omnipy.data._mixins.display.ModelDisplayMixin href "" "omnipy.data._mixins.display.ModelDisplayMixin"
              click omnipy.data._mixins.display.BaseDisplayMixin href "" "omnipy.data._mixins.display.BaseDisplayMixin"
              click omnipy.data._data_class_creator.DataClassBase href "" "omnipy.data._data_class_creator.DataClassBase"
              click omnipy.components.tables.models.PrintableTable href "" "omnipy.components.tables.models.PrintableTable"

Represent tabular data as column names mapped to ordered value lists.

Each key is a column name and each value is the ordered sequence of cells for that column.

Subclassed by:
Source code in src/omnipy/components/tables/models.py 
587
588
589
590
591
592
593
594
595
596
597
598
class ColumnWiseTableWithColNamesModel(
        _ColumnWiseTableWithColNamesMixin[_ColModelT, _ColModelItemT],
        _ColumnWiseTableWithColNamesModel[_ColModelT, _ColModelItemT],
        PrintableTable,
        Generic[_ColModelT, _ColModelItemT],
):
    """Represent tabular data as column names mapped to ordered value lists.

    Each key is a column name and each value is the ordered sequence of cells for
    that column.
    """
    ...

ColumnWiseTableWithColNamesNoConvertModel

Bases: Model[dict[str, JsonScalarColumnModel]]


              flowchart BT
              omnipy.components.tables.models.ColumnWiseTableWithColNamesNoConvertModel[ColumnWiseTableWithColNamesNoConvertModel]
              omnipy.data.model.Model[Model]
              omnipy.data._mixins.display.ModelDisplayMixin[ModelDisplayMixin]
              omnipy.data._mixins.display.BaseDisplayMixin[BaseDisplayMixin]
              omnipy.data._data_class_creator.DataClassBase[DataClassBase]

                              omnipy.data.model.Model --> omnipy.components.tables.models.ColumnWiseTableWithColNamesNoConvertModel
                                omnipy.data._mixins.display.ModelDisplayMixin --> omnipy.data.model.Model
                                omnipy.data._mixins.display.BaseDisplayMixin --> omnipy.data._mixins.display.ModelDisplayMixin
                

                omnipy.data._data_class_creator.DataClassBase --> omnipy.data.model.Model
                
                omnipy.util.pydantic.GenericModel --> omnipy.data.model.Model
                



              click omnipy.components.tables.models.ColumnWiseTableWithColNamesNoConvertModel href "" "omnipy.components.tables.models.ColumnWiseTableWithColNamesNoConvertModel"
              click omnipy.data.model.Model href "" "omnipy.data.model.Model"
              click omnipy.data._mixins.display.ModelDisplayMixin href "" "omnipy.data._mixins.display.ModelDisplayMixin"
              click omnipy.data._mixins.display.BaseDisplayMixin href "" "omnipy.data._mixins.display.BaseDisplayMixin"
              click omnipy.data._data_class_creator.DataClassBase href "" "omnipy.data._data_class_creator.DataClassBase"
Source code in src/omnipy/components/tables/models.py 
635
636
class ColumnWiseTableWithColNamesNoConvertModel(Model[dict[str, JsonScalarColumnModel]]):
    ...

ConcatByAddArrayAdapterModel

Bases: Model[_ColumnT | IsItemSequenceLike[_ItemT] | Generator[_ItemT]], Generic[_ColumnT, _ItemT]


              flowchart BT
              omnipy.components.tables.models.ConcatByAddArrayAdapterModel[ConcatByAddArrayAdapterModel]
              omnipy.data.model.Model[Model]
              omnipy.data._mixins.display.ModelDisplayMixin[ModelDisplayMixin]
              omnipy.data._mixins.display.BaseDisplayMixin[BaseDisplayMixin]
              omnipy.data._data_class_creator.DataClassBase[DataClassBase]

                              omnipy.data.model.Model --> omnipy.components.tables.models.ConcatByAddArrayAdapterModel
                                omnipy.data._mixins.display.ModelDisplayMixin --> omnipy.data.model.Model
                                omnipy.data._mixins.display.BaseDisplayMixin --> omnipy.data._mixins.display.ModelDisplayMixin
                

                omnipy.data._data_class_creator.DataClassBase --> omnipy.data.model.Model
                
                omnipy.util.pydantic.GenericModel --> omnipy.data.model.Model
                



              click omnipy.components.tables.models.ConcatByAddArrayAdapterModel href "" "omnipy.components.tables.models.ConcatByAddArrayAdapterModel"
              click omnipy.data.model.Model href "" "omnipy.data.model.Model"
              click omnipy.data._mixins.display.ModelDisplayMixin href "" "omnipy.data._mixins.display.ModelDisplayMixin"
              click omnipy.data._mixins.display.BaseDisplayMixin href "" "omnipy.data._mixins.display.BaseDisplayMixin"
              click omnipy.data._data_class_creator.DataClassBase href "" "omnipy.data._data_class_creator.DataClassBase"
Source code in src/omnipy/components/tables/models.py 
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
class ConcatByAddArrayAdapterModel(Model[_ColumnT | IsItemSequenceLike[_ItemT]
                                         | Generator[_ItemT]],
                                   Generic[_ColumnT, _ItemT]):
    _allowed_special_methods = frozenset({
        '__len__',
        '__length_hint__',
        '__getitem__',
        '__setitem__',
        '__delitem__',
        '__iter__',
        '__reversed__',
        '__contains__',
        '__copy__',
        '__deepcopy__',
        '__str__',
        '__format__',
    })

    @classmethod
    def _get_special_methods_info_dict(cls) -> dict[str, MethodInfo]:
        special_methods = super()._get_special_methods_info_dict()
        return {
            method_name: special_methods[method_name]
            for method_name in cls._allowed_special_methods
            if method_name in special_methods
        }

    @staticmethod
    def _as_item_list(values: _ColumnT) -> list[_ItemT]:
        return list(values)

    @classmethod
    def _concat_column_values(cls, left: _ColumnT, right: _ColumnT) -> _ColumnT:
        print(f'{cls.__name__}: default concat fallback via list conversion')
        return cls(cls._as_item_list(left) + cls._as_item_list(right)).content

    def __add__(self, other: object):
        other_content = self.__class__(other).content
        return self.__class__(self._concat_column_values(self.content, other_content))

    @classmethod
    @functools.cache
    def _get_column_cls(cls) -> type[_ColModelT]:
        type_variant = all_type_variants(cls.outer_type(with_args=True))
        assert len(type_variant) == 3, ('Expected exactly 3 type variants '
                                        'in ConcatByAddArrayAdapterModel type')
        return type_variant[0]

    @classmethod
    def _parse_data(
            cls, data: _ColumnT | IsItemSequenceLike[_ItemT] | Generator[_ItemT]) -> _ColumnT:
        column_cls = cls._get_column_cls()
        if isinstance(data, column_cls):
            return data
        else:
            return column_cls(list(data))

CsvTableModel

Bases: Chain3[SplitToLinesModel, SplitLinesToColumnsByCommaModel, RowWiseTableFirstRowAsColNamesModel], PrintableTable


              flowchart BT
              omnipy.components.tables.models.CsvTableModel[CsvTableModel]
              omnipy.components.general.models.Chain3[Chain3]
              omnipy.components.general.models._ChainMixin[_ChainMixin]
              omnipy.data.model.Model[Model]
              omnipy.data._mixins.display.ModelDisplayMixin[ModelDisplayMixin]
              omnipy.data._mixins.display.BaseDisplayMixin[BaseDisplayMixin]
              omnipy.data._data_class_creator.DataClassBase[DataClassBase]
              omnipy.components.tables.models.PrintableTable[PrintableTable]

                              omnipy.components.general.models.Chain3 --> omnipy.components.tables.models.CsvTableModel
                                omnipy.components.general.models._ChainMixin --> omnipy.components.general.models.Chain3
                
                omnipy.data.model.Model --> omnipy.components.general.models.Chain3
                                omnipy.data._mixins.display.ModelDisplayMixin --> omnipy.data.model.Model
                                omnipy.data._mixins.display.BaseDisplayMixin --> omnipy.data._mixins.display.ModelDisplayMixin
                

                omnipy.data._data_class_creator.DataClassBase --> omnipy.data.model.Model
                
                omnipy.util.pydantic.GenericModel --> omnipy.data.model.Model
                


                omnipy.components.tables.models.PrintableTable --> omnipy.components.tables.models.CsvTableModel
                


              click omnipy.components.tables.models.CsvTableModel href "" "omnipy.components.tables.models.CsvTableModel"
              click omnipy.components.general.models.Chain3 href "" "omnipy.components.general.models.Chain3"
              click omnipy.components.general.models._ChainMixin href "" "omnipy.components.general.models._ChainMixin"
              click omnipy.data.model.Model href "" "omnipy.data.model.Model"
              click omnipy.data._mixins.display.ModelDisplayMixin href "" "omnipy.data._mixins.display.ModelDisplayMixin"
              click omnipy.data._mixins.display.BaseDisplayMixin href "" "omnipy.data._mixins.display.BaseDisplayMixin"
              click omnipy.data._data_class_creator.DataClassBase href "" "omnipy.data._data_class_creator.DataClassBase"
              click omnipy.components.tables.models.PrintableTable href "" "omnipy.components.tables.models.PrintableTable"

Parse CSV text into row-wise records with header-derived keys.

Input is split into lines and comma-delimited columns, then transformed so the first row becomes the column-name header for subsequent rows.

Subclassed by:
Source code in src/omnipy/components/tables/models.py 
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
class CsvTableModel(
        Chain3[
            SplitToLinesModel,
            SplitLinesToColumnsByCommaModel,
            RowWiseTableFirstRowAsColNamesModel,
        ],
        PrintableTable,
):
    """Parse CSV text into row-wise records with header-derived keys.

    Input is split into lines and comma-delimited columns, then transformed so
    the first row becomes the column-name header for subsequent rows.
    """
    ...

CsvTableOfPydanticRecordsModel

Bases: Chain3[SplitToLinesModel, SplitLinesToColumnsByCommaModel, Model[list[PydanticRecordModel[_PydRecordT]]]], PrintableTable, Generic[_PydRecordT]


              flowchart BT
              omnipy.components.tables.models.CsvTableOfPydanticRecordsModel[CsvTableOfPydanticRecordsModel]
              omnipy.components.general.models.Chain3[Chain3]
              omnipy.components.general.models._ChainMixin[_ChainMixin]
              omnipy.data.model.Model[Model]
              omnipy.data._mixins.display.ModelDisplayMixin[ModelDisplayMixin]
              omnipy.data._mixins.display.BaseDisplayMixin[BaseDisplayMixin]
              omnipy.data._data_class_creator.DataClassBase[DataClassBase]
              omnipy.components.tables.models.PrintableTable[PrintableTable]

                              omnipy.components.general.models.Chain3 --> omnipy.components.tables.models.CsvTableOfPydanticRecordsModel
                                omnipy.components.general.models._ChainMixin --> omnipy.components.general.models.Chain3
                
                omnipy.data.model.Model --> omnipy.components.general.models.Chain3
                                omnipy.data._mixins.display.ModelDisplayMixin --> omnipy.data.model.Model
                                omnipy.data._mixins.display.BaseDisplayMixin --> omnipy.data._mixins.display.ModelDisplayMixin
                

                omnipy.data._data_class_creator.DataClassBase --> omnipy.data.model.Model
                
                omnipy.util.pydantic.GenericModel --> omnipy.data.model.Model
                


                omnipy.components.tables.models.PrintableTable --> omnipy.components.tables.models.CsvTableOfPydanticRecordsModel
                


              click omnipy.components.tables.models.CsvTableOfPydanticRecordsModel href "" "omnipy.components.tables.models.CsvTableOfPydanticRecordsModel"
              click omnipy.components.general.models.Chain3 href "" "omnipy.components.general.models.Chain3"
              click omnipy.components.general.models._ChainMixin href "" "omnipy.components.general.models._ChainMixin"
              click omnipy.data.model.Model href "" "omnipy.data.model.Model"
              click omnipy.data._mixins.display.ModelDisplayMixin href "" "omnipy.data._mixins.display.ModelDisplayMixin"
              click omnipy.data._mixins.display.BaseDisplayMixin href "" "omnipy.data._mixins.display.BaseDisplayMixin"
              click omnipy.data._data_class_creator.DataClassBase href "" "omnipy.data._data_class_creator.DataClassBase"
              click omnipy.components.tables.models.PrintableTable href "" "omnipy.components.tables.models.PrintableTable"

Parse CSV text into validated Pydantic records.

The model applies CSV column splitting and validates each parsed row against the configured Pydantic record schema.

Source code in src/omnipy/components/tables/models.py 
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
class CsvTableOfPydanticRecordsModel(
        Chain3[SplitToLinesModel,
               SplitLinesToColumnsByCommaModel,
               Model[list[PydanticRecordModel[_PydRecordT]]]],
        PrintableTable,
        Generic[_PydRecordT],
):
    """Parse CSV text into validated Pydantic records.

    The model applies CSV column splitting and validates each parsed row against
    the configured Pydantic record schema.
    """
    ...

IterRow

Bases: Mapping[str, _ColModelT], Generic[_ColModelT, _ColModelItemT]


              flowchart BT
              omnipy.components.tables.models.IterRow[IterRow]

              

              click omnipy.components.tables.models.IterRow href "" "omnipy.components.tables.models.IterRow"
METHOD DESCRIPTION
__init__
ATTRIBUTE DESCRIPTION
row_number

TYPE: int

Source code in src/omnipy/components/tables/models.py 
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
class IterRow(Mapping[str, _ColModelT], Generic[_ColModelT, _ColModelItemT]):
    def __init__(
        self,
        content: Mapping[str, _ColModelT | IsItemSequenceLike[_ColModelItemT]],
    ) -> None:
        self._content = {
            key: value.content if is_model_instance(value) else value
            for key, value in content.items()
        }
        self.row_number: int = -1

    @override
    def __getitem__(self, key) -> _ColModelItemT:  # type: ignore[override]
        if key not in self._content:
            raise KeyError(f'Key {key} is not a column name')
        if self.row_number == -1:
            raise KeyError('Row number not set')
        return self._content[key][self.row_number]

    @override
    def __iter__(self) -> Iterator[str]:
        return iter(self._content)

    def __len__(self) -> int:
        return len(self._content)

    def __eq__(self, other: object) -> bool:
        if isinstance(other, IterRow):
            return self._content == other._content and self.row_number == other.row_number
        return False

    def __str__(self) -> str:
        arg_str = ', '.join(f'{repr(key)}: {repr(self[key])}' for key in self._content.keys())
        return f'{self.__class__.__name__}({arg_str})'

row_number instance-attribute 

row_number: int = -1

__init__ 

__init__(content: Mapping[str, _ColModelT | IsItemSequenceLike[_ColModelItemT]]) -> None
Source code in src/omnipy/components/tables/models.py 
216
217
218
219
220
221
222
223
224
def __init__(
    self,
    content: Mapping[str, _ColModelT | IsItemSequenceLike[_ColModelItemT]],
) -> None:
    self._content = {
        key: value.content if is_model_instance(value) else value
        for key, value in content.items()
    }
    self.row_number: int = -1

IteratingPydanticRecordsModel

Bases: _ColumnWiseTableWithColNamesMixin, PydanticRecordModelBase[_PydBaseModelT, _ColWiseTableModelT, RowWiseTableModel], PrintableTable, Generic[_PydBaseModelT, _ColWiseTableModelT, _ColModelT, _ColModelItemT]


              flowchart BT
              omnipy.components.tables.models.IteratingPydanticRecordsModel[IteratingPydanticRecordsModel]
              omnipy.components.tables.models._ColumnWiseTableWithColNamesMixin[_ColumnWiseTableWithColNamesMixin]
              omnipy.components.tables.models.PydanticRecordModelBase[PydanticRecordModelBase]
              omnipy.data.model.Model[Model]
              omnipy.data._mixins.display.ModelDisplayMixin[ModelDisplayMixin]
              omnipy.data._mixins.display.BaseDisplayMixin[BaseDisplayMixin]
              omnipy.data._data_class_creator.DataClassBase[DataClassBase]
              omnipy.components.tables.models.PrintableTable[PrintableTable]

                              omnipy.components.tables.models._ColumnWiseTableWithColNamesMixin --> omnipy.components.tables.models.IteratingPydanticRecordsModel
                
                omnipy.components.tables.models.PydanticRecordModelBase --> omnipy.components.tables.models.IteratingPydanticRecordsModel
                                omnipy.data.model.Model --> omnipy.components.tables.models.PydanticRecordModelBase
                                omnipy.data._mixins.display.ModelDisplayMixin --> omnipy.data.model.Model
                                omnipy.data._mixins.display.BaseDisplayMixin --> omnipy.data._mixins.display.ModelDisplayMixin
                

                omnipy.data._data_class_creator.DataClassBase --> omnipy.data.model.Model
                
                omnipy.util.pydantic.GenericModel --> omnipy.data.model.Model
                


                omnipy.components.tables.models.PrintableTable --> omnipy.components.tables.models.IteratingPydanticRecordsModel
                


              click omnipy.components.tables.models.IteratingPydanticRecordsModel href "" "omnipy.components.tables.models.IteratingPydanticRecordsModel"
              click omnipy.components.tables.models._ColumnWiseTableWithColNamesMixin href "" "omnipy.components.tables.models._ColumnWiseTableWithColNamesMixin"
              click omnipy.components.tables.models.PydanticRecordModelBase href "" "omnipy.components.tables.models.PydanticRecordModelBase"
              click omnipy.data.model.Model href "" "omnipy.data.model.Model"
              click omnipy.data._mixins.display.ModelDisplayMixin href "" "omnipy.data._mixins.display.ModelDisplayMixin"
              click omnipy.data._mixins.display.BaseDisplayMixin href "" "omnipy.data._mixins.display.BaseDisplayMixin"
              click omnipy.data._data_class_creator.DataClassBase href "" "omnipy.data._data_class_creator.DataClassBase"
              click omnipy.components.tables.models.PrintableTable href "" "omnipy.components.tables.models.PrintableTable"

Validate every row in a table against a parameterized Pydantic model.

Validated values are merged into a column-wise table representation while preserving row ordering.

Source code in src/omnipy/components/tables/models.py 
 915
 916
 917
 918
 919
 920
 921
 922
 923
 924
 925
 926
 927
 928
 929
 930
 931
 932
 933
 934
 935
 936
 937
 938
 939
 940
 941
 942
 943
 944
 945
 946
 947
 948
 949
 950
 951
 952
 953
 954
 955
 956
 957
 958
 959
 960
 961
 962
 963
 964
 965
 966
 967
 968
 969
 970
 971
 972
 973
 974
 975
 976
 977
 978
 979
 980
 981
 982
 983
 984
 985
 986
 987
 988
 989
 990
 991
 992
 993
 994
 995
 996
 997
 998
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
class IteratingPydanticRecordsModel(
        _ColumnWiseTableWithColNamesMixin,
        PydanticRecordModelBase[
            _PydBaseModelT,
            _ColWiseTableModelT,
            RowWiseTableModel,
        ],
        PrintableTable,
        Generic[_PydBaseModelT, _ColWiseTableModelT, _ColModelT, _ColModelItemT],
):
    """Validate every row in a table against a parameterized Pydantic model.

    Validated values are merged into a column-wise table representation while
    preserving row ordering.
    """
    @classmethod
    def _validate_over_all_rows(
        cls,
        input_model: ColumnWiseTableWithColNamesModel | RowWiseTableModel,
        output_model: ColumnWiseTableWithColNamesModel,
        pyd_model: type[pyd.BaseModel],
        to_row_dict_func: Callable[[_ColModelT], dict[str, JsonScalar]] | None = None,
    ):
        new_cols = set()

        def _init_col(
            content: dict[str, _ColModelT],
            pyd_model: type[pyd.BaseModel],
            key: str,
        ) -> None:
            if key in new_cols:
                return

            col_len: int = len(input_model)
            # if key not in content:
            content[key] = [pyd_model.__fields__[key].get_default()] * col_len
            # else:
            #     assert len(content[key]) == col_len, \
            #         (f'Incorrect number of rows in {key} column: '
            #          f'{len(content[key])} != {col_len}')
            #     content[key] = [_ for _ in content[key]]

            new_cols.add(key)

        content = output_model.content
        # content = output_model
        for key, field in pyd_model.__fields__.items():
            if field.required and key not in content:
                _init_col(content, pyd_model, key)

        for i, row in enumerate(input_model):
            row_dict = to_row_dict_func(row) if to_row_dict_func else row
            values, _fields_set, error = pyd.validate_model(pyd_model, row_dict)
            if error:
                raise error

            for key, validated_val in values.items():
                if key not in content:
                    _init_col(content, pyd_model, key)

                if key in new_cols:
                    is_changed_val = True
                else:
                    is_changed_val = row_dict[key] != validated_val
                    # else:
                    #     is_changed_val = True

                if is_changed_val:
                    _, prepared_val = prepare_value_for_validation_if_dataset_or_model(
                        validated_val)
                    try:
                        content[key][i] = prepared_val
                    except (TypeError, AssertionError, ValueError, ValidationError):
                        _init_col(content, pyd_model, key)
                        content[key][i] = prepared_val
        output_model.validate_content()

    @override
    @classmethod
    def _validate_record_model_with_col_names(
        cls,
        pyd_model: type[pyd.BaseModel],
        data: ColumnWiseTableWithColNamesModel,
        header_names: tuple[str, ...],
    ) -> pyd.BaseModel | ColumnWiseTableWithColNamesModel:
        cls._validate_over_all_rows(input_model=data, output_model=data, pyd_model=pyd_model)
        return data

    @override
    @classmethod
    def _validate_record_model_without_col_names(
        cls,
        pyd_model: type[pyd.BaseModel],
        data: RowWiseTableModel,
        data_type: type[_DataWithColNamesModelT],
        header_names: tuple[str, ...],
    ) -> pyd.BaseModel | ColumnWiseTableWithColNamesModel:
        output = data_type()
        cls._validate_over_all_rows(
            input_model=data,
            output_model=output,
            pyd_model=pyd_model,
            to_row_dict_func=lambda row: dict(zip(header_names, row)),
        )
        return output

JsonMaxLevel1ColumnModel

Bases: ColumnModel[list[JsonMaxLevel1Types], JsonMaxLevel1Types]


              flowchart BT
              omnipy.components.tables.models.JsonMaxLevel1ColumnModel[JsonMaxLevel1ColumnModel]
              omnipy.components.tables.models.ColumnModel[ColumnModel]
              omnipy.data.model.Model[Model]
              omnipy.data._mixins.display.ModelDisplayMixin[ModelDisplayMixin]
              omnipy.data._mixins.display.BaseDisplayMixin[BaseDisplayMixin]
              omnipy.data._data_class_creator.DataClassBase[DataClassBase]

                              omnipy.components.tables.models.ColumnModel --> omnipy.components.tables.models.JsonMaxLevel1ColumnModel
                                omnipy.data.model.Model --> omnipy.components.tables.models.ColumnModel
                                omnipy.data._mixins.display.ModelDisplayMixin --> omnipy.data.model.Model
                                omnipy.data._mixins.display.BaseDisplayMixin --> omnipy.data._mixins.display.ModelDisplayMixin
                

                omnipy.data._data_class_creator.DataClassBase --> omnipy.data.model.Model
                
                omnipy.util.pydantic.GenericModel --> omnipy.data.model.Model
                




              click omnipy.components.tables.models.JsonMaxLevel1ColumnModel href "" "omnipy.components.tables.models.JsonMaxLevel1ColumnModel"
              click omnipy.components.tables.models.ColumnModel href "" "omnipy.components.tables.models.ColumnModel"
              click omnipy.data.model.Model href "" "omnipy.data.model.Model"
              click omnipy.data._mixins.display.ModelDisplayMixin href "" "omnipy.data._mixins.display.ModelDisplayMixin"
              click omnipy.data._mixins.display.BaseDisplayMixin href "" "omnipy.data._mixins.display.BaseDisplayMixin"
              click omnipy.data._data_class_creator.DataClassBase href "" "omnipy.data._data_class_creator.DataClassBase"

Column model for JSON values nested at most one level deep.

Subclassed by:
Source code in src/omnipy/components/tables/models.py 
203
204
205
206
class JsonMaxLevel1ColumnModel(ColumnModel[list[JsonMaxLevel1Types], JsonMaxLevel1Types]):
    """Column model for JSON values nested at most one level deep."""

    ...

JsonMaxLevel1ColumnWiseTableWithColNamesModel

Bases: ColumnWiseTableWithColNamesModel[JsonMaxLevel1ColumnModel, JsonMaxLevel1Types]


              flowchart BT
              omnipy.components.tables.models.JsonMaxLevel1ColumnWiseTableWithColNamesModel[JsonMaxLevel1ColumnWiseTableWithColNamesModel]
              omnipy.components.tables.models.ColumnWiseTableWithColNamesModel[ColumnWiseTableWithColNamesModel]
              omnipy.components.tables.models._ColumnWiseTableWithColNamesMixin[_ColumnWiseTableWithColNamesMixin]
              omnipy.components.tables.models._ColumnWiseTableWithColNamesModel[_ColumnWiseTableWithColNamesModel]
              omnipy.data.model.Model[Model]
              omnipy.data._mixins.display.ModelDisplayMixin[ModelDisplayMixin]
              omnipy.data._mixins.display.BaseDisplayMixin[BaseDisplayMixin]
              omnipy.data._data_class_creator.DataClassBase[DataClassBase]
              omnipy.components.tables.models.PrintableTable[PrintableTable]

                              omnipy.components.tables.models.ColumnWiseTableWithColNamesModel --> omnipy.components.tables.models.JsonMaxLevel1ColumnWiseTableWithColNamesModel
                                omnipy.components.tables.models._ColumnWiseTableWithColNamesMixin --> omnipy.components.tables.models.ColumnWiseTableWithColNamesModel
                
                omnipy.components.tables.models._ColumnWiseTableWithColNamesModel --> omnipy.components.tables.models.ColumnWiseTableWithColNamesModel
                                omnipy.data.model.Model --> omnipy.components.tables.models._ColumnWiseTableWithColNamesModel
                                omnipy.data._mixins.display.ModelDisplayMixin --> omnipy.data.model.Model
                                omnipy.data._mixins.display.BaseDisplayMixin --> omnipy.data._mixins.display.ModelDisplayMixin
                

                omnipy.data._data_class_creator.DataClassBase --> omnipy.data.model.Model
                
                omnipy.util.pydantic.GenericModel --> omnipy.data.model.Model
                


                omnipy.components.tables.models.PrintableTable --> omnipy.components.tables.models.ColumnWiseTableWithColNamesModel
                



              click omnipy.components.tables.models.JsonMaxLevel1ColumnWiseTableWithColNamesModel href "" "omnipy.components.tables.models.JsonMaxLevel1ColumnWiseTableWithColNamesModel"
              click omnipy.components.tables.models.ColumnWiseTableWithColNamesModel href "" "omnipy.components.tables.models.ColumnWiseTableWithColNamesModel"
              click omnipy.components.tables.models._ColumnWiseTableWithColNamesMixin href "" "omnipy.components.tables.models._ColumnWiseTableWithColNamesMixin"
              click omnipy.components.tables.models._ColumnWiseTableWithColNamesModel href "" "omnipy.components.tables.models._ColumnWiseTableWithColNamesModel"
              click omnipy.data.model.Model href "" "omnipy.data.model.Model"
              click omnipy.data._mixins.display.ModelDisplayMixin href "" "omnipy.data._mixins.display.ModelDisplayMixin"
              click omnipy.data._mixins.display.BaseDisplayMixin href "" "omnipy.data._mixins.display.BaseDisplayMixin"
              click omnipy.data._data_class_creator.DataClassBase href "" "omnipy.data._data_class_creator.DataClassBase"
              click omnipy.components.tables.models.PrintableTable href "" "omnipy.components.tables.models.PrintableTable"

Column-wise table whose cells allow JSON nesting up to one level.

Source code in src/omnipy/components/tables/models.py 
610
611
612
613
614
615
616
class JsonMaxLevel1ColumnWiseTableWithColNamesModel(ColumnWiseTableWithColNamesModel[
        JsonMaxLevel1ColumnModel,
        JsonMaxLevel1Types,
]):
    """Column-wise table whose cells allow JSON nesting up to one level."""

    ...

JsonMaxLevel2ColumnModel

Bases: ColumnModel[list[JsonMaxLevel2Types], JsonMaxLevel2Types]


              flowchart BT
              omnipy.components.tables.models.JsonMaxLevel2ColumnModel[JsonMaxLevel2ColumnModel]
              omnipy.components.tables.models.ColumnModel[ColumnModel]
              omnipy.data.model.Model[Model]
              omnipy.data._mixins.display.ModelDisplayMixin[ModelDisplayMixin]
              omnipy.data._mixins.display.BaseDisplayMixin[BaseDisplayMixin]
              omnipy.data._data_class_creator.DataClassBase[DataClassBase]

                              omnipy.components.tables.models.ColumnModel --> omnipy.components.tables.models.JsonMaxLevel2ColumnModel
                                omnipy.data.model.Model --> omnipy.components.tables.models.ColumnModel
                                omnipy.data._mixins.display.ModelDisplayMixin --> omnipy.data.model.Model
                                omnipy.data._mixins.display.BaseDisplayMixin --> omnipy.data._mixins.display.ModelDisplayMixin
                

                omnipy.data._data_class_creator.DataClassBase --> omnipy.data.model.Model
                
                omnipy.util.pydantic.GenericModel --> omnipy.data.model.Model
                




              click omnipy.components.tables.models.JsonMaxLevel2ColumnModel href "" "omnipy.components.tables.models.JsonMaxLevel2ColumnModel"
              click omnipy.components.tables.models.ColumnModel href "" "omnipy.components.tables.models.ColumnModel"
              click omnipy.data.model.Model href "" "omnipy.data.model.Model"
              click omnipy.data._mixins.display.ModelDisplayMixin href "" "omnipy.data._mixins.display.ModelDisplayMixin"
              click omnipy.data._mixins.display.BaseDisplayMixin href "" "omnipy.data._mixins.display.BaseDisplayMixin"
              click omnipy.data._data_class_creator.DataClassBase href "" "omnipy.data._data_class_creator.DataClassBase"

Column model for JSON values nested at most two levels deep.

Subclassed by:
Source code in src/omnipy/components/tables/models.py 
209
210
211
212
class JsonMaxLevel2ColumnModel(ColumnModel[list[JsonMaxLevel2Types], JsonMaxLevel2Types]):
    """Column model for JSON values nested at most two levels deep."""

    ...

JsonMaxLevel2ColumnWiseTableWithColNamesModel

Bases: ColumnWiseTableWithColNamesModel[JsonMaxLevel2ColumnModel, JsonMaxLevel2Types]


              flowchart BT
              omnipy.components.tables.models.JsonMaxLevel2ColumnWiseTableWithColNamesModel[JsonMaxLevel2ColumnWiseTableWithColNamesModel]
              omnipy.components.tables.models.ColumnWiseTableWithColNamesModel[ColumnWiseTableWithColNamesModel]
              omnipy.components.tables.models._ColumnWiseTableWithColNamesMixin[_ColumnWiseTableWithColNamesMixin]
              omnipy.components.tables.models._ColumnWiseTableWithColNamesModel[_ColumnWiseTableWithColNamesModel]
              omnipy.data.model.Model[Model]
              omnipy.data._mixins.display.ModelDisplayMixin[ModelDisplayMixin]
              omnipy.data._mixins.display.BaseDisplayMixin[BaseDisplayMixin]
              omnipy.data._data_class_creator.DataClassBase[DataClassBase]
              omnipy.components.tables.models.PrintableTable[PrintableTable]

                              omnipy.components.tables.models.ColumnWiseTableWithColNamesModel --> omnipy.components.tables.models.JsonMaxLevel2ColumnWiseTableWithColNamesModel
                                omnipy.components.tables.models._ColumnWiseTableWithColNamesMixin --> omnipy.components.tables.models.ColumnWiseTableWithColNamesModel
                
                omnipy.components.tables.models._ColumnWiseTableWithColNamesModel --> omnipy.components.tables.models.ColumnWiseTableWithColNamesModel
                                omnipy.data.model.Model --> omnipy.components.tables.models._ColumnWiseTableWithColNamesModel
                                omnipy.data._mixins.display.ModelDisplayMixin --> omnipy.data.model.Model
                                omnipy.data._mixins.display.BaseDisplayMixin --> omnipy.data._mixins.display.ModelDisplayMixin
                

                omnipy.data._data_class_creator.DataClassBase --> omnipy.data.model.Model
                
                omnipy.util.pydantic.GenericModel --> omnipy.data.model.Model
                


                omnipy.components.tables.models.PrintableTable --> omnipy.components.tables.models.ColumnWiseTableWithColNamesModel
                



              click omnipy.components.tables.models.JsonMaxLevel2ColumnWiseTableWithColNamesModel href "" "omnipy.components.tables.models.JsonMaxLevel2ColumnWiseTableWithColNamesModel"
              click omnipy.components.tables.models.ColumnWiseTableWithColNamesModel href "" "omnipy.components.tables.models.ColumnWiseTableWithColNamesModel"
              click omnipy.components.tables.models._ColumnWiseTableWithColNamesMixin href "" "omnipy.components.tables.models._ColumnWiseTableWithColNamesMixin"
              click omnipy.components.tables.models._ColumnWiseTableWithColNamesModel href "" "omnipy.components.tables.models._ColumnWiseTableWithColNamesModel"
              click omnipy.data.model.Model href "" "omnipy.data.model.Model"
              click omnipy.data._mixins.display.ModelDisplayMixin href "" "omnipy.data._mixins.display.ModelDisplayMixin"
              click omnipy.data._mixins.display.BaseDisplayMixin href "" "omnipy.data._mixins.display.BaseDisplayMixin"
              click omnipy.data._data_class_creator.DataClassBase href "" "omnipy.data._data_class_creator.DataClassBase"
              click omnipy.components.tables.models.PrintableTable href "" "omnipy.components.tables.models.PrintableTable"

Column-wise table whose cells allow JSON nesting up to two levels.

Source code in src/omnipy/components/tables/models.py 
619
620
621
622
623
624
625
class JsonMaxLevel2ColumnWiseTableWithColNamesModel(ColumnWiseTableWithColNamesModel[
        JsonMaxLevel2ColumnModel,
        JsonMaxLevel2Types,
]):
    """Column-wise table whose cells allow JSON nesting up to two levels."""

    ...

JsonScalarColumnModel

Bases: ColumnModel[list[JsonScalar], JsonScalar]


              flowchart BT
              omnipy.components.tables.models.JsonScalarColumnModel[JsonScalarColumnModel]
              omnipy.components.tables.models.ColumnModel[ColumnModel]
              omnipy.data.model.Model[Model]
              omnipy.data._mixins.display.ModelDisplayMixin[ModelDisplayMixin]
              omnipy.data._mixins.display.BaseDisplayMixin[BaseDisplayMixin]
              omnipy.data._data_class_creator.DataClassBase[DataClassBase]

                              omnipy.components.tables.models.ColumnModel --> omnipy.components.tables.models.JsonScalarColumnModel
                                omnipy.data.model.Model --> omnipy.components.tables.models.ColumnModel
                                omnipy.data._mixins.display.ModelDisplayMixin --> omnipy.data.model.Model
                                omnipy.data._mixins.display.BaseDisplayMixin --> omnipy.data._mixins.display.ModelDisplayMixin
                

                omnipy.data._data_class_creator.DataClassBase --> omnipy.data.model.Model
                
                omnipy.util.pydantic.GenericModel --> omnipy.data.model.Model
                




              click omnipy.components.tables.models.JsonScalarColumnModel href "" "omnipy.components.tables.models.JsonScalarColumnModel"
              click omnipy.components.tables.models.ColumnModel href "" "omnipy.components.tables.models.ColumnModel"
              click omnipy.data.model.Model href "" "omnipy.data.model.Model"
              click omnipy.data._mixins.display.ModelDisplayMixin href "" "omnipy.data._mixins.display.ModelDisplayMixin"
              click omnipy.data._mixins.display.BaseDisplayMixin href "" "omnipy.data._mixins.display.BaseDisplayMixin"
              click omnipy.data._data_class_creator.DataClassBase href "" "omnipy.data._data_class_creator.DataClassBase"

Column model whose cells are JSON scalar values.

Subclassed by: Used by:
Source code in src/omnipy/components/tables/models.py 
190
191
192
193
class JsonScalarColumnModel(ColumnModel[list[JsonScalar], JsonScalar]):
    """Column model whose cells are JSON scalar values."""

    ...

JsonScalarColumnWiseTableWithColNamesModel

Bases: ColumnWiseTableWithColNamesModel[JsonScalarColumnModel, JsonScalar]


              flowchart BT
              omnipy.components.tables.models.JsonScalarColumnWiseTableWithColNamesModel[JsonScalarColumnWiseTableWithColNamesModel]
              omnipy.components.tables.models.ColumnWiseTableWithColNamesModel[ColumnWiseTableWithColNamesModel]
              omnipy.components.tables.models._ColumnWiseTableWithColNamesMixin[_ColumnWiseTableWithColNamesMixin]
              omnipy.components.tables.models._ColumnWiseTableWithColNamesModel[_ColumnWiseTableWithColNamesModel]
              omnipy.data.model.Model[Model]
              omnipy.data._mixins.display.ModelDisplayMixin[ModelDisplayMixin]
              omnipy.data._mixins.display.BaseDisplayMixin[BaseDisplayMixin]
              omnipy.data._data_class_creator.DataClassBase[DataClassBase]
              omnipy.components.tables.models.PrintableTable[PrintableTable]

                              omnipy.components.tables.models.ColumnWiseTableWithColNamesModel --> omnipy.components.tables.models.JsonScalarColumnWiseTableWithColNamesModel
                                omnipy.components.tables.models._ColumnWiseTableWithColNamesMixin --> omnipy.components.tables.models.ColumnWiseTableWithColNamesModel
                
                omnipy.components.tables.models._ColumnWiseTableWithColNamesModel --> omnipy.components.tables.models.ColumnWiseTableWithColNamesModel
                                omnipy.data.model.Model --> omnipy.components.tables.models._ColumnWiseTableWithColNamesModel
                                omnipy.data._mixins.display.ModelDisplayMixin --> omnipy.data.model.Model
                                omnipy.data._mixins.display.BaseDisplayMixin --> omnipy.data._mixins.display.ModelDisplayMixin
                

                omnipy.data._data_class_creator.DataClassBase --> omnipy.data.model.Model
                
                omnipy.util.pydantic.GenericModel --> omnipy.data.model.Model
                


                omnipy.components.tables.models.PrintableTable --> omnipy.components.tables.models.ColumnWiseTableWithColNamesModel
                



              click omnipy.components.tables.models.JsonScalarColumnWiseTableWithColNamesModel href "" "omnipy.components.tables.models.JsonScalarColumnWiseTableWithColNamesModel"
              click omnipy.components.tables.models.ColumnWiseTableWithColNamesModel href "" "omnipy.components.tables.models.ColumnWiseTableWithColNamesModel"
              click omnipy.components.tables.models._ColumnWiseTableWithColNamesMixin href "" "omnipy.components.tables.models._ColumnWiseTableWithColNamesMixin"
              click omnipy.components.tables.models._ColumnWiseTableWithColNamesModel href "" "omnipy.components.tables.models._ColumnWiseTableWithColNamesModel"
              click omnipy.data.model.Model href "" "omnipy.data.model.Model"
              click omnipy.data._mixins.display.ModelDisplayMixin href "" "omnipy.data._mixins.display.ModelDisplayMixin"
              click omnipy.data._mixins.display.BaseDisplayMixin href "" "omnipy.data._mixins.display.BaseDisplayMixin"
              click omnipy.data._data_class_creator.DataClassBase href "" "omnipy.data._data_class_creator.DataClassBase"
              click omnipy.components.tables.models.PrintableTable href "" "omnipy.components.tables.models.PrintableTable"

Column-wise table whose cells are JSON scalar values.

Subclassed by: Used by:
Source code in src/omnipy/components/tables/models.py 
601
602
603
604
605
606
607
class JsonScalarColumnWiseTableWithColNamesModel(ColumnWiseTableWithColNamesModel[
        JsonScalarColumnModel,
        JsonScalar,
]):
    """Column-wise table whose cells are JSON scalar values."""

    ...

PrintableTable

Mark table-like models as printable in Omnipy rendering flows.

This mixin is intentionally behavior-free and is used only as a semantic marker for models that should be treated as table outputs.

Subclassed by:
Source code in src/omnipy/components/tables/models.py 
251
252
253
254
255
256
257
258
class PrintableTable:
    """Mark table-like models as printable in Omnipy rendering flows.

    This mixin is intentionally behavior-free and is used only as a semantic marker
    for models that should be treated as table outputs.
    """

    ...

PydanticRecordModel

Bases: PydanticRecordModelBase[_PydBaseModelT, dict[str, JsonScalar], list[JsonScalar]], Generic[_PydBaseModelT]


              flowchart BT
              omnipy.components.tables.models.PydanticRecordModel[PydanticRecordModel]
              omnipy.components.tables.models.PydanticRecordModelBase[PydanticRecordModelBase]
              omnipy.data.model.Model[Model]
              omnipy.data._mixins.display.ModelDisplayMixin[ModelDisplayMixin]
              omnipy.data._mixins.display.BaseDisplayMixin[BaseDisplayMixin]
              omnipy.data._data_class_creator.DataClassBase[DataClassBase]

                              omnipy.components.tables.models.PydanticRecordModelBase --> omnipy.components.tables.models.PydanticRecordModel
                                omnipy.data.model.Model --> omnipy.components.tables.models.PydanticRecordModelBase
                                omnipy.data._mixins.display.ModelDisplayMixin --> omnipy.data.model.Model
                                omnipy.data._mixins.display.BaseDisplayMixin --> omnipy.data._mixins.display.ModelDisplayMixin
                

                omnipy.data._data_class_creator.DataClassBase --> omnipy.data.model.Model
                
                omnipy.util.pydantic.GenericModel --> omnipy.data.model.Model
                




              click omnipy.components.tables.models.PydanticRecordModel href "" "omnipy.components.tables.models.PydanticRecordModel"
              click omnipy.components.tables.models.PydanticRecordModelBase href "" "omnipy.components.tables.models.PydanticRecordModelBase"
              click omnipy.data.model.Model href "" "omnipy.data.model.Model"
              click omnipy.data._mixins.display.ModelDisplayMixin href "" "omnipy.data._mixins.display.ModelDisplayMixin"
              click omnipy.data._mixins.display.BaseDisplayMixin href "" "omnipy.data._mixins.display.BaseDisplayMixin"
              click omnipy.data._data_class_creator.DataClassBase href "" "omnipy.data._data_class_creator.DataClassBase"

Validate a single record against a parameterized Pydantic model.

Input may be provided either as a dictionary keyed by field names or as an ordered list aligned with model headers.

Subclassed by:
Source code in src/omnipy/components/tables/models.py 
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
class PydanticRecordModel(
        PydanticRecordModelBase[
            _PydBaseModelT,
            dict[str, JsonScalar],
            list[JsonScalar],
        ],
        Generic[_PydBaseModelT],
):
    """Validate a single record against a parameterized Pydantic model.

    Input may be provided either as a dictionary keyed by field names or as an
    ordered list aligned with model headers.
    """
    @override
    @classmethod
    def _validate_record_model_with_col_names(
        cls,
        pyd_model: type[pyd.BaseModel],
        data: dict[str, JsonScalar],
        header_names: tuple[str, ...],
    ) -> pyd.BaseModel | dict[str, JsonScalar]:
        return pyd_model(**data)

    @override
    @classmethod
    def _validate_record_model_without_col_names(
        cls,
        pyd_model: type[pyd.BaseModel],
        data: list[JsonScalar],
        data_type: type[_DataWithColNamesModelT],
        header_names: tuple[str, ...],
    ) -> pyd.BaseModel | dict[str, JsonScalar]:
        return pyd_model(**dict(zip(header_names, data)))

PydanticRecordModelBase

Bases: Model[TypeVarStore[_PydBaseModelT] | _DataWithColNamesModelT | _DataWithoutColNamesModelT], Generic[_PydBaseModelT, _DataWithColNamesModelT, _DataWithoutColNamesModelT]


              flowchart BT
              omnipy.components.tables.models.PydanticRecordModelBase[PydanticRecordModelBase]
              omnipy.data.model.Model[Model]
              omnipy.data._mixins.display.ModelDisplayMixin[ModelDisplayMixin]
              omnipy.data._mixins.display.BaseDisplayMixin[BaseDisplayMixin]
              omnipy.data._data_class_creator.DataClassBase[DataClassBase]

                              omnipy.data.model.Model --> omnipy.components.tables.models.PydanticRecordModelBase
                                omnipy.data._mixins.display.ModelDisplayMixin --> omnipy.data.model.Model
                                omnipy.data._mixins.display.BaseDisplayMixin --> omnipy.data._mixins.display.ModelDisplayMixin
                

                omnipy.data._data_class_creator.DataClassBase --> omnipy.data.model.Model
                
                omnipy.util.pydantic.GenericModel --> omnipy.data.model.Model
                



              click omnipy.components.tables.models.PydanticRecordModelBase href "" "omnipy.components.tables.models.PydanticRecordModelBase"
              click omnipy.data.model.Model href "" "omnipy.data.model.Model"
              click omnipy.data._mixins.display.ModelDisplayMixin href "" "omnipy.data._mixins.display.ModelDisplayMixin"
              click omnipy.data._mixins.display.BaseDisplayMixin href "" "omnipy.data._mixins.display.BaseDisplayMixin"
              click omnipy.data._data_class_creator.DataClassBase href "" "omnipy.data._data_class_creator.DataClassBase"

Validate tabular record data against a parameterized Pydantic schema.

Subclasses define how named-column and positional inputs are transformed into validated records, while this base class handles schema/header lookup and dispatching.

Subclassed by:
Source code in src/omnipy/components/tables/models.py 
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
class PydanticRecordModelBase(
        Model[TypeVarStore[_PydBaseModelT] | _DataWithColNamesModelT | _DataWithoutColNamesModelT],
        Generic[_PydBaseModelT, _DataWithColNamesModelT, _DataWithoutColNamesModelT],
        metaclass=PydanticRecordModelMetaclass,
):
    """Validate tabular record data against a parameterized Pydantic schema.

    Subclasses define how named-column and positional inputs are transformed into
    validated records, while this base class handles schema/header lookup and
    dispatching.
    """
    @classmethod
    @abstractmethod
    def _validate_record_model_with_col_names(
        cls,
        pyd_model: type[pyd.BaseModel],
        data: _DataWithColNamesModelT,
        header_names: tuple[str, ...],
    ) -> pyd.BaseModel | _DataWithColNamesModelT:
        ...

    @classmethod
    @abstractmethod
    def _validate_record_model_without_col_names(
        cls,
        pyd_model: type[pyd.BaseModel],
        data: _DataWithoutColNamesModelT,
        output_type: type[_DataWithColNamesModelT],
        header_names: tuple[str, ...],
    ) -> pyd.BaseModel | _DataWithColNamesModelT:
        ...

    @override
    @classmethod
    def _parse_data(  # type: ignore[override]
        cls,
        data: _DataWithColNamesModelT | _DataWithoutColNamesModelT,
    ) -> pyd.BaseModel | _DataWithColNamesModelT:
        pyd_model, data_with_col_names_type, header_names, num_required_fields = cls.header_info
        content = data.content if is_model_instance(data) else data
        if isinstance(content, dict) or is_pure_pydantic_model(content):
            # cls._validate_and_set_value(data)
            data_with_col_names = cast(_DataWithColNamesModelT, data)
            return cls._validate_record_model_with_col_names(
                pyd_model,
                data_with_col_names,
                header_names,
            )

        if isinstance(content, list):
            if isinstance(data, RowWiseTableModel):
                num_data_cols = len(content[0]) if len(content) > 0 else 0
            else:
                num_data_cols = len(content)

            assert len(header_names) >= num_data_cols >= num_required_fields, \
                (f'Incorrect number of data elements: '
                 f'{len(header_names)} >= {num_data_cols} >= {num_required_fields}')

            data_without_col_names = cast(_DataWithoutColNamesModelT, data)
            return cls._validate_record_model_without_col_names(
                pyd_model,
                data_without_col_names,
                data_with_col_names_type,
                header_names,
            )
        else:
            raise TypeError(f'Unsupported data type: {type(data)}')

PydanticRecordModelMetaclass

Bases: ModelMetaclass


              flowchart BT
              omnipy.components.tables.models.PydanticRecordModelMetaclass[PydanticRecordModelMetaclass]
              omnipy.data.model.ModelMetaclass[ModelMetaclass]
              omnipy.data._data_class_creator.DataClassBaseMeta[DataClassBaseMeta]

                              omnipy.data.model.ModelMetaclass --> omnipy.components.tables.models.PydanticRecordModelMetaclass
                                omnipy.data._data_class_creator.DataClassBaseMeta --> omnipy.data.model.ModelMetaclass
                
                omnipy.util.pydantic.ModelMetaclass --> omnipy.data.model.ModelMetaclass
                



              click omnipy.components.tables.models.PydanticRecordModelMetaclass href "" "omnipy.components.tables.models.PydanticRecordModelMetaclass"
              click omnipy.data.model.ModelMetaclass href "" "omnipy.data.model.ModelMetaclass"
              click omnipy.data._data_class_creator.DataClassBaseMeta href "" "omnipy.data._data_class_creator.DataClassBaseMeta"

Compute and cache schema-derived header metadata for record models.

The metaclass resolves the parameterized Pydantic model and exposes reusable header information through :attr:header_info.

METHOD DESCRIPTION
__init__
ATTRIBUTE DESCRIPTION
header_info

Return cached header metadata for the current record model type.

TYPE: _HeaderInfo

Source code in src/omnipy/components/tables/models.py 
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
class PydanticRecordModelMetaclass(ModelMetaclass):
    """Compute and cache schema-derived header metadata for record models.

    The metaclass resolves the parameterized Pydantic model and exposes reusable
    header information through :attr:`header_info`.
    """
    def __init__(cls, *args, **kwargs) -> None:
        super().__init__(*args, **kwargs)
        cls._header_info: _HeaderInfo | None = None

    @property
    def header_info(cls) -> _HeaderInfo:
        """Return cached header metadata for the current record model type.

        Returns:
            _HeaderInfo: The Pydantic model class, ordered header names, and the
                number of required leading fields.

        Raises:
            ValueError: If required fields appear after optional fields in the
                underlying Pydantic model definition.
        """
        if cls._header_info is None:
            type_args = get_args(cast(type[Model], cls).outer_type(with_args=True))
            type_var_store = type_args[0]
            pydantic_model = get_args(type_var_store)[0]
            if hasattr(pydantic_model, '__pydantic_model__'):
                pydantic_model = pydantic_model.__pydantic_model__

            data_with_col_names_type = type_args[1]
            headers = pydantic_model.__fields__

            num_required_fields = -1
            for i, header_field in enumerate(headers.values()):
                if not header_field.required:
                    if num_required_fields == -1:
                        num_required_fields = i
                    continue
                elif num_required_fields != -1 and i > num_required_fields:
                    raise ValueError('Required fields must not come after optional fields')

            if num_required_fields == -1:
                num_required_fields = len(headers)

            cls._header_info = _HeaderInfo(
                pydantic_model,
                data_with_col_names_type,
                tuple(headers.keys()),
                num_required_fields,
            )
        return cls._header_info

header_info property 

header_info: _HeaderInfo

Return cached header metadata for the current record model type.

RETURNS DESCRIPTION
_HeaderInfo

The Pydantic model class, ordered header names, and the number of required leading fields.

TYPE: _HeaderInfo

RAISES DESCRIPTION
ValueError

If required fields appear after optional fields in the underlying Pydantic model definition.

__init__ 

__init__(*args, **kwargs) -> None
Source code in src/omnipy/components/tables/models.py 
730
731
732
def __init__(cls, *args, **kwargs) -> None:
    super().__init__(*args, **kwargs)
    cls._header_info: _HeaderInfo | None = None

RowWiseTableFirstRowAsColNamesModel

Bases: _RowWiseColNamesMixin, _RowWiseTableFirstRowAsColNamesModel, PrintableTable


              flowchart BT
              omnipy.components.tables.models.RowWiseTableFirstRowAsColNamesModel[RowWiseTableFirstRowAsColNamesModel]
              omnipy.components.tables.models._RowWiseColNamesMixin[_RowWiseColNamesMixin]
              omnipy.components.tables.models._RowWiseTableFirstRowAsColNamesModel[_RowWiseTableFirstRowAsColNamesModel]
              omnipy.data.model.Model[Model]
              omnipy.data._mixins.display.ModelDisplayMixin[ModelDisplayMixin]
              omnipy.data._mixins.display.BaseDisplayMixin[BaseDisplayMixin]
              omnipy.data._data_class_creator.DataClassBase[DataClassBase]
              omnipy.components.tables.models.PrintableTable[PrintableTable]

                              omnipy.components.tables.models._RowWiseColNamesMixin --> omnipy.components.tables.models.RowWiseTableFirstRowAsColNamesModel
                
                omnipy.components.tables.models._RowWiseTableFirstRowAsColNamesModel --> omnipy.components.tables.models.RowWiseTableFirstRowAsColNamesModel
                                omnipy.data.model.Model --> omnipy.components.tables.models._RowWiseTableFirstRowAsColNamesModel
                                omnipy.data._mixins.display.ModelDisplayMixin --> omnipy.data.model.Model
                                omnipy.data._mixins.display.BaseDisplayMixin --> omnipy.data._mixins.display.ModelDisplayMixin
                

                omnipy.data._data_class_creator.DataClassBase --> omnipy.data.model.Model
                
                omnipy.util.pydantic.GenericModel --> omnipy.data.model.Model
                


                omnipy.components.tables.models.PrintableTable --> omnipy.components.tables.models.RowWiseTableFirstRowAsColNamesModel
                


              click omnipy.components.tables.models.RowWiseTableFirstRowAsColNamesModel href "" "omnipy.components.tables.models.RowWiseTableFirstRowAsColNamesModel"
              click omnipy.components.tables.models._RowWiseColNamesMixin href "" "omnipy.components.tables.models._RowWiseColNamesMixin"
              click omnipy.components.tables.models._RowWiseTableFirstRowAsColNamesModel href "" "omnipy.components.tables.models._RowWiseTableFirstRowAsColNamesModel"
              click omnipy.data.model.Model href "" "omnipy.data.model.Model"
              click omnipy.data._mixins.display.ModelDisplayMixin href "" "omnipy.data._mixins.display.ModelDisplayMixin"
              click omnipy.data._mixins.display.BaseDisplayMixin href "" "omnipy.data._mixins.display.BaseDisplayMixin"
              click omnipy.data._data_class_creator.DataClassBase href "" "omnipy.data._data_class_creator.DataClassBase"
              click omnipy.components.tables.models.PrintableTable href "" "omnipy.components.tables.models.PrintableTable"

Represent row-wise data where the first row defines the header.

The first row is interpreted as column names and subsequent rows are mapped to dictionaries keyed by those names.

Returned by: Subclassed by: Used by:
Source code in src/omnipy/components/tables/models.py 
698
699
700
701
702
703
704
705
706
707
708
class RowWiseTableFirstRowAsColNamesModel(
        _RowWiseColNamesMixin,
        _RowWiseTableFirstRowAsColNamesModel,
        PrintableTable,
):
    """Represent row-wise data where the first row defines the header.

    The first row is interpreted as column names and subsequent rows are mapped to
    dictionaries keyed by those names.
    """
    ...

RowWiseTableModel

Bases: Model[list[list[JsonScalar]]]


              flowchart BT
              omnipy.components.tables.models.RowWiseTableModel[RowWiseTableModel]
              omnipy.data.model.Model[Model]
              omnipy.data._mixins.display.ModelDisplayMixin[ModelDisplayMixin]
              omnipy.data._mixins.display.BaseDisplayMixin[BaseDisplayMixin]
              omnipy.data._data_class_creator.DataClassBase[DataClassBase]

                              omnipy.data.model.Model --> omnipy.components.tables.models.RowWiseTableModel
                                omnipy.data._mixins.display.ModelDisplayMixin --> omnipy.data.model.Model
                                omnipy.data._mixins.display.BaseDisplayMixin --> omnipy.data._mixins.display.ModelDisplayMixin
                

                omnipy.data._data_class_creator.DataClassBase --> omnipy.data.model.Model
                
                omnipy.util.pydantic.GenericModel --> omnipy.data.model.Model
                



              click omnipy.components.tables.models.RowWiseTableModel href "" "omnipy.components.tables.models.RowWiseTableModel"
              click omnipy.data.model.Model href "" "omnipy.data.model.Model"
              click omnipy.data._mixins.display.ModelDisplayMixin href "" "omnipy.data._mixins.display.ModelDisplayMixin"
              click omnipy.data._mixins.display.BaseDisplayMixin href "" "omnipy.data._mixins.display.BaseDisplayMixin"
              click omnipy.data._data_class_creator.DataClassBase href "" "omnipy.data._data_class_creator.DataClassBase"

Represent row-wise tabular data without explicit column names.

Each row is stored as an ordered list of JSON scalar values where column identity is positional.

Subclassed by: Used by:
Source code in src/omnipy/components/tables/models.py 
278
279
280
281
282
283
284
class RowWiseTableModel(Model[list[list[JsonScalar]]]):
    """Represent row-wise tabular data without explicit column names.

    Each row is stored as an ordered list of JSON scalar values where column
    identity is positional.
    """
    ...

RowWiseTableWithColNamesModel

Bases: _RowWiseColNamesMixin, _RowWiseTableWithColNamesModel, PrintableTable


              flowchart BT
              omnipy.components.tables.models.RowWiseTableWithColNamesModel[RowWiseTableWithColNamesModel]
              omnipy.components.tables.models._RowWiseColNamesMixin[_RowWiseColNamesMixin]
              omnipy.components.tables.models._RowWiseTableWithColNamesModel[_RowWiseTableWithColNamesModel]
              omnipy.data.model.Model[Model]
              omnipy.data._mixins.display.ModelDisplayMixin[ModelDisplayMixin]
              omnipy.data._mixins.display.BaseDisplayMixin[BaseDisplayMixin]
              omnipy.data._data_class_creator.DataClassBase[DataClassBase]
              omnipy.components.tables.models.PrintableTable[PrintableTable]

                              omnipy.components.tables.models._RowWiseColNamesMixin --> omnipy.components.tables.models.RowWiseTableWithColNamesModel
                
                omnipy.components.tables.models._RowWiseTableWithColNamesModel --> omnipy.components.tables.models.RowWiseTableWithColNamesModel
                                omnipy.data.model.Model --> omnipy.components.tables.models._RowWiseTableWithColNamesModel
                                omnipy.data._mixins.display.ModelDisplayMixin --> omnipy.data.model.Model
                                omnipy.data._mixins.display.BaseDisplayMixin --> omnipy.data._mixins.display.ModelDisplayMixin
                

                omnipy.data._data_class_creator.DataClassBase --> omnipy.data.model.Model
                
                omnipy.util.pydantic.GenericModel --> omnipy.data.model.Model
                


                omnipy.components.tables.models.PrintableTable --> omnipy.components.tables.models.RowWiseTableWithColNamesModel
                


              click omnipy.components.tables.models.RowWiseTableWithColNamesModel href "" "omnipy.components.tables.models.RowWiseTableWithColNamesModel"
              click omnipy.components.tables.models._RowWiseColNamesMixin href "" "omnipy.components.tables.models._RowWiseColNamesMixin"
              click omnipy.components.tables.models._RowWiseTableWithColNamesModel href "" "omnipy.components.tables.models._RowWiseTableWithColNamesModel"
              click omnipy.data.model.Model href "" "omnipy.data.model.Model"
              click omnipy.data._mixins.display.ModelDisplayMixin href "" "omnipy.data._mixins.display.ModelDisplayMixin"
              click omnipy.data._mixins.display.BaseDisplayMixin href "" "omnipy.data._mixins.display.BaseDisplayMixin"
              click omnipy.data._data_class_creator.DataClassBase href "" "omnipy.data._data_class_creator.DataClassBase"
              click omnipy.components.tables.models.PrintableTable href "" "omnipy.components.tables.models.PrintableTable"

Represent row-wise tabular data keyed by column name.

Each row is stored as a dictionary from column names to JSON scalar values. Column-wise inputs are normalized to this row-wise structure.

Subclassed by: Used by:
Source code in src/omnipy/components/tables/models.py 
337
338
339
340
341
342
343
344
345
346
347
class RowWiseTableWithColNamesModel(
        _RowWiseColNamesMixin,
        _RowWiseTableWithColNamesModel,
        PrintableTable,
):
    """Represent row-wise tabular data keyed by column name.

    Each row is stored as a dictionary from column names to JSON scalar values.
    Column-wise inputs are normalized to this row-wise structure.
    """
    ...

RowWiseTableWithColNamesNoConvertModel

Bases: Model[list[dict[str, JsonScalar]]]


              flowchart BT
              omnipy.components.tables.models.RowWiseTableWithColNamesNoConvertModel[RowWiseTableWithColNamesNoConvertModel]
              omnipy.data.model.Model[Model]
              omnipy.data._mixins.display.ModelDisplayMixin[ModelDisplayMixin]
              omnipy.data._mixins.display.BaseDisplayMixin[BaseDisplayMixin]
              omnipy.data._data_class_creator.DataClassBase[DataClassBase]

                              omnipy.data.model.Model --> omnipy.components.tables.models.RowWiseTableWithColNamesNoConvertModel
                                omnipy.data._mixins.display.ModelDisplayMixin --> omnipy.data.model.Model
                                omnipy.data._mixins.display.BaseDisplayMixin --> omnipy.data._mixins.display.ModelDisplayMixin
                

                omnipy.data._data_class_creator.DataClassBase --> omnipy.data.model.Model
                
                omnipy.util.pydantic.GenericModel --> omnipy.data.model.Model
                



              click omnipy.components.tables.models.RowWiseTableWithColNamesNoConvertModel href "" "omnipy.components.tables.models.RowWiseTableWithColNamesNoConvertModel"
              click omnipy.data.model.Model href "" "omnipy.data.model.Model"
              click omnipy.data._mixins.display.ModelDisplayMixin href "" "omnipy.data._mixins.display.ModelDisplayMixin"
              click omnipy.data._mixins.display.BaseDisplayMixin href "" "omnipy.data._mixins.display.BaseDisplayMixin"
              click omnipy.data._data_class_creator.DataClassBase href "" "omnipy.data._data_class_creator.DataClassBase"

Store row-wise table records exactly as provided.

Unlike conversion-enabled table models, this model keeps incoming row-wise data unchanged and does not convert column-wise structures.

Source code in src/omnipy/components/tables/models.py 
350
351
352
353
354
355
356
357
class RowWiseTableWithColNamesNoConvertModel(Model[list[dict[str, JsonScalar]]]):
    """Store row-wise table records exactly as provided.

    Unlike conversion-enabled table models, this model keeps incoming row-wise data
    unchanged and does not convert column-wise structures.
    """

    ...

TableOfPydanticRecordsModel

Bases: Chain3[SplitToLinesModel, SplitLinesToColumnsModel, Model[list[PydanticRecordModel[_PydRecordT]]]], PrintableTable, Generic[_PydRecordT]


              flowchart BT
              omnipy.components.tables.models.TableOfPydanticRecordsModel[TableOfPydanticRecordsModel]
              omnipy.components.general.models.Chain3[Chain3]
              omnipy.components.general.models._ChainMixin[_ChainMixin]
              omnipy.data.model.Model[Model]
              omnipy.data._mixins.display.ModelDisplayMixin[ModelDisplayMixin]
              omnipy.data._mixins.display.BaseDisplayMixin[BaseDisplayMixin]
              omnipy.data._data_class_creator.DataClassBase[DataClassBase]
              omnipy.components.tables.models.PrintableTable[PrintableTable]

                              omnipy.components.general.models.Chain3 --> omnipy.components.tables.models.TableOfPydanticRecordsModel
                                omnipy.components.general.models._ChainMixin --> omnipy.components.general.models.Chain3
                
                omnipy.data.model.Model --> omnipy.components.general.models.Chain3
                                omnipy.data._mixins.display.ModelDisplayMixin --> omnipy.data.model.Model
                                omnipy.data._mixins.display.BaseDisplayMixin --> omnipy.data._mixins.display.ModelDisplayMixin
                

                omnipy.data._data_class_creator.DataClassBase --> omnipy.data.model.Model
                
                omnipy.util.pydantic.GenericModel --> omnipy.data.model.Model
                


                omnipy.components.tables.models.PrintableTable --> omnipy.components.tables.models.TableOfPydanticRecordsModel
                


              click omnipy.components.tables.models.TableOfPydanticRecordsModel href "" "omnipy.components.tables.models.TableOfPydanticRecordsModel"
              click omnipy.components.general.models.Chain3 href "" "omnipy.components.general.models.Chain3"
              click omnipy.components.general.models._ChainMixin href "" "omnipy.components.general.models._ChainMixin"
              click omnipy.data.model.Model href "" "omnipy.data.model.Model"
              click omnipy.data._mixins.display.ModelDisplayMixin href "" "omnipy.data._mixins.display.ModelDisplayMixin"
              click omnipy.data._mixins.display.BaseDisplayMixin href "" "omnipy.data._mixins.display.BaseDisplayMixin"
              click omnipy.data._data_class_creator.DataClassBase href "" "omnipy.data._data_class_creator.DataClassBase"
              click omnipy.components.tables.models.PrintableTable href "" "omnipy.components.tables.models.PrintableTable"

Parse delimited text into validated Pydantic records.

The model chains line splitting, column splitting, and per-row record validation into one parsing pipeline.

Subclassed by:
Source code in src/omnipy/components/tables/models.py 
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
class TableOfPydanticRecordsModel(
        Chain3[SplitToLinesModel,
               SplitLinesToColumnsModel,
               Model[list[PydanticRecordModel[_PydRecordT]]]],
        PrintableTable,
        Generic[_PydRecordT],
):
    """Parse delimited text into validated Pydantic records.

    The model chains line splitting, column splitting, and per-row record
    validation into one parsing pipeline.
    """
    ...

TsvTableModel

Bases: Chain3[SplitToLinesModel, SplitLinesToColumnsModel, RowWiseTableFirstRowAsColNamesModel], PrintableTable


              flowchart BT
              omnipy.components.tables.models.TsvTableModel[TsvTableModel]
              omnipy.components.general.models.Chain3[Chain3]
              omnipy.components.general.models._ChainMixin[_ChainMixin]
              omnipy.data.model.Model[Model]
              omnipy.data._mixins.display.ModelDisplayMixin[ModelDisplayMixin]
              omnipy.data._mixins.display.BaseDisplayMixin[BaseDisplayMixin]
              omnipy.data._data_class_creator.DataClassBase[DataClassBase]
              omnipy.components.tables.models.PrintableTable[PrintableTable]

                              omnipy.components.general.models.Chain3 --> omnipy.components.tables.models.TsvTableModel
                                omnipy.components.general.models._ChainMixin --> omnipy.components.general.models.Chain3
                
                omnipy.data.model.Model --> omnipy.components.general.models.Chain3
                                omnipy.data._mixins.display.ModelDisplayMixin --> omnipy.data.model.Model
                                omnipy.data._mixins.display.BaseDisplayMixin --> omnipy.data._mixins.display.ModelDisplayMixin
                

                omnipy.data._data_class_creator.DataClassBase --> omnipy.data.model.Model
                
                omnipy.util.pydantic.GenericModel --> omnipy.data.model.Model
                


                omnipy.components.tables.models.PrintableTable --> omnipy.components.tables.models.TsvTableModel
                


              click omnipy.components.tables.models.TsvTableModel href "" "omnipy.components.tables.models.TsvTableModel"
              click omnipy.components.general.models.Chain3 href "" "omnipy.components.general.models.Chain3"
              click omnipy.components.general.models._ChainMixin href "" "omnipy.components.general.models._ChainMixin"
              click omnipy.data.model.Model href "" "omnipy.data.model.Model"
              click omnipy.data._mixins.display.ModelDisplayMixin href "" "omnipy.data._mixins.display.ModelDisplayMixin"
              click omnipy.data._mixins.display.BaseDisplayMixin href "" "omnipy.data._mixins.display.BaseDisplayMixin"
              click omnipy.data._data_class_creator.DataClassBase href "" "omnipy.data._data_class_creator.DataClassBase"
              click omnipy.components.tables.models.PrintableTable href "" "omnipy.components.tables.models.PrintableTable"

Parse TSV text into row-wise records with header-derived keys.

Input is split into lines and tab-delimited columns, then transformed so the first row becomes the column-name header for subsequent rows.

Subclassed by:
Source code in src/omnipy/components/tables/models.py 
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
class TsvTableModel(
        Chain3[
            SplitToLinesModel,
            SplitLinesToColumnsModel,
            RowWiseTableFirstRowAsColNamesModel,
        ],
        PrintableTable,
):
    """Parse TSV text into row-wise records with header-derived keys.

    Input is split into lines and tab-delimited columns, then transformed so the
    first row becomes the column-name header for subsequent rows.
    """
    ...