paguro.validation.vcol

paguro.vcol

Constructor for a ValidColumn validator.

You can construct a ValidColumn validator using vcol in 3 different ways:

Call: using vcol as a function vcol()
Dot Name: chaining your column name to the vcol object: vcol.your_column_name()
By DataType: specifying the dtype you expect your column to have: vcol.Integer()

Note

Call is the most general way of using vcol, it allows you to create any ValidColumn that you can create using dot name and by data type

The only difference is that when using call vcol(), you are free to specify (or not specify!) the parameters: name and dtype. Using Dot Name the column name will be set to the attribute that you pass. By DataType the dtype will be set to the one specified by the method, (i.e. vcol.Int64() will set the dtype=polars.Int64, vcol.Integer() will allow the dtype to be any of the polars integer dtypes).

If you want to specify validation constraints for the fields in a struct column you must use vcol.Struct().

Let’s see in more details the three different ways and what parameters you can pass to specify the constraints for your column.

Call¶

Call

Use the vcol as a function to construct a ValidColumn.

Parameters:¶

name: str | Collection[str] | Selector | None = None¶

The column name.

dtype: IntoDataType | None = None¶

The expected column data type:

a polars datatype
python types:
int: all the polars integers (signed) float: all the polars floats str: polars string

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Dot Name¶

pg.vcol.your_column_name()

By DataType¶

Nested

Struct

Struct valid column constructor.

Parameters:¶

*validators: FieldsValidators¶

ValidColumn or ValidFrame validators for the fields of the struct column. Think of the struct column as a frame itself.

name: str | Collection[str] | Selector | None = None¶

The column name.

dtype: pl.Struct | type[pl.Struct] | None = Struct¶

The expected column data type: you can pass a fully defined Stuct, the default is the Struct base with no fields specified.

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.Struct()
   ...: )
   ...: 
ValidColumn:Struct(fields=None, name=None, dtype=[Struct], required=True, allow_nulls=False, unique=False, constraints=set())

In [2]: print(
   ...:     pg.vcol.Struct(pg.vcol("field", ge=1))
   ...: )
   ...: 
ValidColumn:Struct(
	fields=Validation(
		valid_columns=ValidColumnList(
			ValidColumn(name='field', dtype=None, required=True, allow_nulls=False, unique=False, constraints={'ge'})
		),
		valid_frames=None,
	),
	name=None, dtype=[Struct], required=True, allow_nulls=False, unique=False, constraints=set(
)

In [3]: print(
   ...:     pg.vcol.Struct(pg.vcol.Struct(pg.vcol("field", ge=1)))
   ...: )
   ...: 
ValidColumn:Struct(
	fields=Validation(
		valid_columns=ValidColumnList(
			ValidColumn:Struct(
				fields=Validation(
					valid_columns=ValidColumnList(
						ValidColumn(name='field', dtype=None, required=True, allow_nulls=False, unique=False, constraints={'ge'})
					),
					valid_frames=None,
				),
				name=None, dtype=[Struct], required=True, allow_nulls=False, unique=False, constraints=set(
			)
		),
		valid_frames=None,
	),
	name=None, dtype=[Struct], required=True, allow_nulls=False, unique=False, constraints=set(
)

Array

Array valid column constructor.

Parameters:¶

name: str | Collection[str] | Selector | None = None¶

inner: PolarsDataType | PythonDataType | None = None¶

shape: int | tuple[int, ...] | None = None¶

contains: Any | None = None¶

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.Array()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[Array], required=True, allow_nulls=False, unique=False, constraints=set())

List

List valid column constructor.

Parameters:¶

name: str | Collection[str] | Selector | None = None¶

inner: PolarsDataType | PythonDataType | None = None¶

contains: Any | None = None¶

len_ge: int | None = None¶

len_gt: int | None = None¶

len_le: int | None = None¶

len_lt: int | None = None¶

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.List()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[List], required=True, allow_nulls=False, unique=False, constraints=set())

Temporal

Date

paguro.vcol.Date(name: str | Collection[str] | TypeAliasForwardRef('Selector') | None = None, *, required: bool | 'dynamic' = True, allow_nulls: bool = False, unique: bool = False, **constraints: Any) → ValidDate

Date valid column constructor.

Parameters:¶

name: str | Collection[str] | TypeAliasForwardRef('Selector') | None = None¶

The column name.

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.Date()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[Date], required=True, allow_nulls=False, unique=False, constraints=set())

DateTime

DateTime valid column constructor.

Parameters:¶

name: str | Collection[str] | Selector | None = None¶: The column name.

required

Whether there must be a column with the specified name in the target data.

allow_nulls

Whether the column is allowed to contain null values.

unique

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

constraints

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.DateTime()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[Datetime], required=True, allow_nulls=False, unique=False, constraints=set())

Duration

Duration valid column constructor.

Parameters:¶

name: str | Collection[str] | Selector | None = None¶

time_unit: TimeUnit | None = None¶

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.Duration()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[Duration], required=True, allow_nulls=False, unique=False, constraints=set())

Time

paguro.vcol.Time(name: str | Collection[str] | TypeAliasForwardRef('Selector') | None = None, *, required: bool | 'dynamic' = True, allow_nulls: bool = False, unique: bool = False, **constraints: Any) → ValidTime

Time valid column constructor.

Parameters:¶

name: str | Collection[str] | TypeAliasForwardRef('Selector') | None = None¶

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.Date()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[Date], required=True, allow_nulls=False, unique=False, constraints=set())

String

String valid column constructor.

Parameters:¶

name: str | Collection[str] | TypeAliasForwardRef('Selector') | None = None¶
contains: str | None = None¶
contains_any: str | None = None¶
starts_with: str | None = None¶
ends_with: str | None = None¶
len_chars_eq: int | None = None¶
len_chars_ge: int | None = None¶
len_chars_gt: int | None = None¶
len_chars_le: int | None = None¶
len_chars_lt: int | None = None¶

required

Whether there must be a column with the specified name in the target data.

allow_nulls

Whether the column is allowed to contain null values.

unique

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

constraints

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.String()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[String], required=True, allow_nulls=False, unique=False, constraints=set())

Enum

Enum valid column constructor.

Parameters:¶

name: str | Collection[str] | Selector | None = None¶

categories: pl.Series | Iterable[str] | type[enum.Enum] | None = None¶

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.Enum()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[Enum], required=True, allow_nulls=False, unique=False, constraints=set())

Categorical

paguro.vcol.Categorical(name: str | Collection[str] | TypeAliasForwardRef('Selector') | None = None, *, required: bool | 'dynamic' = True, allow_nulls: bool = False, unique: bool = False, **constraints: Any) → ValidCategorical

Categorical valid column constructor.

Parameters:¶

name: str | Collection[str] | TypeAliasForwardRef('Selector') | None = None¶

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.Categorical()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[Categorical], required=True, allow_nulls=False, unique=False, constraints=set())

Numeric

Integer

Integer valid column constructor.

Parameters:¶

name: str | Collection[str] | Selector | None = None¶

ge: int | float | decimal.Decimal | None = None¶

gt: int | float | decimal.Decimal | None = None¶

le: int | float | decimal.Decimal | None = None¶

lt: int | float | decimal.Decimal | None = None¶

is_between: IsBetweenTuple = None¶

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.Integer()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[Int128, Int64, Int32, Int16, Int8], required=True, allow_nulls=False, unique=False, constraints=set())

Int8

Int8 valid column constructor.

Parameters:¶

name: str | Collection[str] | Selector | None = None¶

ge: int | float | decimal.Decimal | None = None¶

gt: int | float | decimal.Decimal | None = None¶

le: int | float | decimal.Decimal | None = None¶

lt: int | float | decimal.Decimal | None = None¶

is_between: IsBetweenTuple = None¶

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.Int8()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[Int8], required=True, allow_nulls=False, unique=False, constraints=set())

Int16

Int16 valid column constructor.

Parameters:¶

name: str | Collection[str] | Selector | None = None¶

ge: int | float | decimal.Decimal | None = None¶

gt: int | float | decimal.Decimal | None = None¶

le: int | float | decimal.Decimal | None = None¶

lt: int | float | decimal.Decimal | None = None¶

is_between: IsBetweenTuple = None¶

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.Int16()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[Int16], required=True, allow_nulls=False, unique=False, constraints=set())

Int32

Int32 valid column constructor.

Parameters:¶

name: str | Collection[str] | Selector | None = None¶

ge: int | float | decimal.Decimal | None = None¶

gt: int | float | decimal.Decimal | None = None¶

le: int | float | decimal.Decimal | None = None¶

lt: int | float | decimal.Decimal | None = None¶

is_between: IsBetweenTuple = None¶

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.Int32()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[Int32], required=True, allow_nulls=False, unique=False, constraints=set())

Int64

Int64 valid column constructor.

Parameters:¶

name: str | Collection[str] | Selector | None = None¶

ge: int | float | decimal.Decimal | None = None¶

gt: int | float | decimal.Decimal | None = None¶

le: int | float | decimal.Decimal | None = None¶

lt: int | float | decimal.Decimal | None = None¶

is_between: IsBetweenTuple = None¶

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.Int64()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[Int64], required=True, allow_nulls=False, unique=False, constraints=set())

Int128

Int128 valid column constructor.

Parameters:¶

name: str | Collection[str] | Selector | None = None¶

ge: int | float | decimal.Decimal | None = None¶

gt: int | float | decimal.Decimal | None = None¶

le: int | float | decimal.Decimal | None = None¶

lt: int | float | decimal.Decimal | None = None¶

is_between: IsBetweenTuple = None¶

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.Int64()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[Int64], required=True, allow_nulls=False, unique=False, constraints=set())

UInteger

UInteger valid column constructor.

Parameters:¶

name: str | Collection[str] | Selector | None = None¶

ge: int | float | decimal.Decimal | None = None¶

gt: int | float | decimal.Decimal | None = None¶

le: int | float | decimal.Decimal | None = None¶

lt: int | float | decimal.Decimal | None = None¶

is_between: IsBetweenTuple = None¶

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.UInteger()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[UInt32, UInt16, UInt8, UInt128, UInt64], required=True, allow_nulls=False, unique=False, constraints=set())

UInt8

UInt8 valid column constructor.

Parameters:¶

name: str | Collection[str] | Selector | None = None¶

ge: int | float | decimal.Decimal | None = None¶

gt: int | float | decimal.Decimal | None = None¶

le: int | float | decimal.Decimal | None = None¶

lt: int | float | decimal.Decimal | None = None¶

is_between: IsBetweenTuple = None¶

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.UInt8()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[UInt8], required=True, allow_nulls=False, unique=False, constraints=set())

UInt16

UInt16 valid column constructor.

Parameters:¶

name: str | Collection[str] | Selector | None = None¶

ge: int | float | decimal.Decimal | None = None¶

gt: int | float | decimal.Decimal | None = None¶

le: int | float | decimal.Decimal | None = None¶

lt: int | float | decimal.Decimal | None = None¶

is_between: IsBetweenTuple = None¶

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.UInt16()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[UInt16], required=True, allow_nulls=False, unique=False, constraints=set())

UInt32

UInt32 valid column constructor.

Parameters:¶

name: str | Collection[str] | Selector | None = None¶

ge: int | float | decimal.Decimal | None = None¶

gt: int | float | decimal.Decimal | None = None¶

le: int | float | decimal.Decimal | None = None¶

lt: int | float | decimal.Decimal | None = None¶

is_between: IsBetweenTuple = None¶

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.UInt32()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[UInt32], required=True, allow_nulls=False, unique=False, constraints=set())

UInt64

UInt64 valid column constructor.

Parameters:¶

name: str | Collection[str] | Selector | None = None¶

ge: int | float | decimal.Decimal | None = None¶

gt: int | float | decimal.Decimal | None = None¶

le: int | float | decimal.Decimal | None = None¶

lt: int | float | decimal.Decimal | None = None¶

is_between: IsBetweenTuple = None¶

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.UInt64()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[UInt64], required=True, allow_nulls=False, unique=False, constraints=set())

UInt128

UInt128 valid column constructor.

Parameters:¶

name: str | Collection[str] | Selector | None = None¶

ge: int | float | decimal.Decimal | None = None¶

gt: int | float | decimal.Decimal | None = None¶

le: int | float | decimal.Decimal | None = None¶

lt: int | float | decimal.Decimal | None = None¶

is_between: IsBetweenTuple = None¶

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.UInt128()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[UInt128], required=True, allow_nulls=False, unique=False, constraints=set())

Float

Float valid column constructor.

Parameters:¶

name: str | Collection[str] | Selector | None = None¶

ge: int | float | decimal.Decimal | None = None¶

gt: int | float | decimal.Decimal | None = None¶

le: int | float | decimal.Decimal | None = None¶

lt: int | float | decimal.Decimal | None = None¶

is_between: IsBetweenTuple = None¶

is_infinite: bool | None = None¶

is_nan: bool | None = None¶

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.Float()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[Float64, Float32], required=True, allow_nulls=False, unique=False, constraints=set())

Float32

Float32 valid column constructor.

Parameters:¶

name: str | Collection[str] | Selector | None = None¶

ge: int | float | decimal.Decimal | None = None¶

gt: int | float | decimal.Decimal | None = None¶

le: int | float | decimal.Decimal | None = None¶

lt: int | float | decimal.Decimal | None = None¶

is_between: IsBetweenTuple = None¶

is_infinite: bool | None = None¶

is_nan: bool | None = None¶

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.Float32()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[Float32], required=True, allow_nulls=False, unique=False, constraints=set())

Float64

Float64 valid column constructor.

Parameters:¶

name: str | Collection[str] | Selector | None = None¶

ge: int | float | decimal.Decimal | None = None¶

gt: int | float | decimal.Decimal | None = None¶

le: int | float | decimal.Decimal | None = None¶

lt: int | float | decimal.Decimal | None = None¶

is_between: IsBetweenTuple = None¶

is_infinite: bool | None = None¶

is_nan: bool | None = None¶

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.Float64()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[Float64], required=True, allow_nulls=False, unique=False, constraints=set())

Decimal

Decimal valid column constructor.

Parameters:¶

name: str | Collection[str] | Selector | None = None¶

precision: int | None = None¶

scale: int | None = 0¶

ge: int | float | decimal.Decimal | None = None¶

gt: int | float | decimal.Decimal | None = None¶

le: int | float | decimal.Decimal | None = None¶

lt: int | float | decimal.Decimal | None = None¶

is_between: IsBetweenTuple = None¶

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.Decimal()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[Decimal(precision=38, scale=0)], required=True, allow_nulls=False, unique=False, constraints=set())

Other

Binary

paguro.vcol.Binary(name: str | Collection[str] | TypeAliasForwardRef('Selector') | None = None, *, required: bool | 'dynamic' = True, allow_nulls: bool = False, unique: bool = False, **constraints: Any) → ValidBinary

Binary valid column constructor.

Parameters:¶

name: str | Collection[str] | TypeAliasForwardRef('Selector') | None = None¶

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.String()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[String], required=True, allow_nulls=False, unique=False, constraints=set())

Boolean

paguro.vcol.Boolean(name: str | Collection[str] | TypeAliasForwardRef('Selector') | None = None, *, required: bool | 'dynamic' = True, allow_nulls: bool = False, unique: bool = False, **constraints: Any) → ValidBoolean

Boolean valid column constructor.

Parameters:¶

name: str | Collection[str] | TypeAliasForwardRef('Selector') | None = None¶

The column name.

required: bool | 'dynamic' = True¶

Whether there must be a column with the specified name in the target data.

allow_nulls: bool = False¶

Whether the column is allowed to contain null values.

unique: bool = False¶

Whether the values in the column are unique: the number of unique values in the column equal the number of rows in the data.

Typically a useful check to have if the column uniquely identifies the rows of the data.

**constraints: Any¶

Constraints on the values of the column

Constraints can be passed in 2 alternative ways:

as name-Polars Expressions
Where the key is the custom name for the constraint (your choice) and the value the polars.all` expression. Within the validator all refers to the specified column.
pg.vcol("a", a_is_ge=pl.all().ge(1))
as method-argument
key: the name of the polars expression method value: the argument to pass in the polars expression
pg.vcol("a", ge=1)

Examples¶

In [1]: print(
   ...:     pg.vcol.String()
   ...: )
   ...: 
ValidColumn(name=None, dtype=[String], required=True, allow_nulls=False, unique=False, constraints=set())