great_expectations.expectations.core.expect_column_quantile_values_to_be_between

Module Contents

Classes

ExpectColumnQuantileValuesToBeBetween(configuration: Optional[ExpectationConfiguration] = None)

Expect specific provided column quantiles to be between provided minimum and maximum values.

class great_expectations.expectations.core.expect_column_quantile_values_to_be_between.ExpectColumnQuantileValuesToBeBetween(configuration: Optional[ExpectationConfiguration] = None)

Bases: great_expectations.expectations.expectation.ColumnExpectation

Expect specific provided column quantiles to be between provided minimum and maximum values.

quantile_ranges must be a dictionary with two keys:

  • quantiles: (list of float) increasing ordered list of desired quantile values

  • value_ranges: (list of lists): Each element in this list consists of a list with two values, a lower and upper bound (inclusive) for the corresponding quantile.

For each provided range:

  • min_value and max_value are both inclusive.

  • If min_value is None, then max_value is treated as an upper bound only

  • If max_value is None, then min_value is treated as a lower bound only

The length of the quantiles list and quantile_values list must be equal.

For example:

# my_df.my_col = [1,2,2,3,3,3,4]
>>> my_df.expect_column_quantile_values_to_be_between(
    "my_col",
    {
        "quantiles": [0., 0.333, 0.6667, 1.],
        "value_ranges": [[0,1], [2,3], [3,4], [4,5]]
    }
)
{
  "success": True,
    "result": {
      "observed_value": {
        "quantiles: [0., 0.333, 0.6667, 1.],
        "values": [1, 2, 3, 4],
      }
      "element_count": 7,
      "missing_count": 0,
      "missing_percent": 0.0,
      "details": {
        "success_details": [true, true, true, true]
      }
    }
  }
}

expect_column_quantile_values_to_be_between can be computationally intensive for large datasets.

expect_column_quantile_values_to_be_between is a column_aggregate_expectation.

Parameters
  • column (str) – The column name.

  • quantile_ranges (dictionary) – Quantiles and associated value ranges for the column. See above for details.

  • allow_relative_error (boolean) – Whether to allow relative error in quantile communications on backends that support or require it.

Other Parameters
  • result_format (str or None) – Which output mode to use: BOOLEAN_ONLY, BASIC, COMPLETE, or SUMMARY. For more detail, see result_format.

  • include_config (boolean) – If True, then include the expectation config as part of the result object. For more detail, see include_config.

  • catch_exceptions (boolean or None) – If True, then catch exceptions and include them as part of the result object. For more detail, see catch_exceptions.

  • meta (dict or None) – A JSON-serializable dictionary (nesting allowed) that will be included in the output without modification. For more detail, see meta.

Returns

An ExpectationSuiteValidationResult

Exact fields vary depending on the values passed to result_format and include_config, catch_exceptions, and meta.

Notes

These fields in the result object are customized for this expectation: :: details.success_details

See also

expect_column_min_to_be_between

expect_column_max_to_be_between

expect_column_median_to_be_between

library_metadata
metric_dependencies = ['column.quantile_values']
success_keys = ['quantile_ranges', 'allow_relative_error']
default_kwarg_values
validate_configuration(self, configuration: Optional[ExpectationConfiguration])
classmethod _prescriptive_renderer(cls, configuration=None, result=None, language=None, runtime_configuration=None, **kwargs)
classmethod _diagnostic_observed_value_renderer(cls, configuration=None, result=None, language=None, runtime_configuration=None, **kwargs)
classmethod _descriptive_quantile_table_renderer(cls, configuration=None, result=None, language=None, runtime_configuration=None, **kwargs)
get_validation_dependencies(self, configuration: Optional[ExpectationConfiguration] = None, execution_engine: Optional[ExecutionEngine] = None, runtime_configuration: Optional[dict] = None)

Returns the result format and metrics required to validate this Expectation using the provided result format.

_validate(self, configuration: ExpectationConfiguration, metrics: Dict, runtime_configuration: dict = None, execution_engine: ExecutionEngine = None)