def validate_configuration(
self, configuration: Optional[ExpectationConfiguration]) -> None:
"""
Validates that a configuration has been set, and sets a configuration if it has yet to be set. Ensures that
necessary configuration arguments have been provided for the validation of the expectation.
Args:
configuration (OPTIONAL[ExpectationConfiguration]): \
An optional Expectation Configuration entry that will be used to configure the expectation
Returns:
None. Raises InvalidExpectationConfigurationError if the config is not validated successfully
"""
# Setting up a configuration
super().validate_configuration(configuration)
# Ensuring that a proper value has been provided
try:
assert ("value" in configuration.kwargs
), "An expected column count must be provided"
assert isinstance(
configuration.kwargs["value"],
(int, dict)), "Provided threshold must be an integer"
if isinstance(configuration.kwargs["value"], dict):
assert (
"$PARAMETER" in configuration.kwargs["value"]
), 'Evaluation Parameter dict for value kwarg must have "$PARAMETER" key.'
except AssertionError as e:
raise InvalidExpectationConfigurationError(str(e))
def validate_configuration(
self, configuration: Optional[ExpectationConfiguration]) -> None:
super().validate_configuration(configuration)
if configuration is None:
configuration = self.configuration
assert "strftime_format" in configuration.kwargs, "strftime_format is required"
strftime_format = configuration.kwargs["strftime_format"]
try:
if isinstance(strftime_format, dict):
assert (
"$PARAMETER" in strftime_format
), 'Evaluation Parameter dict for strftime_format kwarg must have "$PARAMETER" key.'
else:
datetime.strptime(
datetime.strftime(datetime.now(), strftime_format),
strftime_format,
)
except ValueError as e:
raise ValueError(
f"Unable to use provided strftime_format. {str(e)}")
except AssertionError as e:
raise InvalidExpectationConfigurationError(str(e))
def validate_configuration(
cls, configuration: Optional[ExpectationConfiguration]
) -> None:
"""
Validates that a configuration has been set, and sets a configuration if it has yet to be set. Ensures that
necessary configuration arguments have been provided for the validation of the expectation.
Args:
configuration (OPTIONAL[ExpectationConfiguration]): \
An optional Expectation Configuration entry that will be used to configure the expectation
Returns:
None. Raises InvalidExpectationConfigurationError if the config is not validated successfully
"""
# Setting up a configuration
super().validate_configuration(configuration)
if configuration is None:
configuration = cls.configuration
word = configuration.kwargs["word"]
try:
assert word is not None, "word must be provided"
assert isinstance(word, str), "word must be a string"
assert word.islower(), "word must be a lowercase string"
except AssertionError as e:
raise InvalidExpectationConfigurationError(str(e))
def validate_configuration(
self, configuration: Optional[ExpectationConfiguration]) -> bool:
"""
Validates that a configuration has been set, and sets a configuration if it has yet to be set. Ensures that
necessary configuration arguments have been provided for the validation of the expectation.
Args:
configuration (OPTIONAL[ExpectationConfiguration]): \
An optional Expectation Configuration entry that will be used to configure the expectation
Returns:
True if the configuration has been validated successfully. Otherwise, raises an exception
"""
# Setting up a configuration
super().validate_configuration(configuration)
# Ensuring that a proper value has been provided
try:
assert "column" in configuration.kwargs, "A column name must be provided"
assert isinstance(configuration.kwargs["column"],
str), "Column name must be a string"
assert (isinstance(configuration.kwargs.get("column_index"),
(int, dict))
or configuration.kwargs.get("column_index") is None
), "column_index must be an integer or None"
if isinstance(configuration.kwargs.get("column_index"), dict):
assert "$PARAMETER" in configuration.kwargs.get(
"column_index"
), 'Evaluation Parameter dict for column_index kwarg must have "$PARAMETER" key.'
except AssertionError as e:
raise InvalidExpectationConfigurationError(str(e))
return True
def validate_configuration(
self, configuration: Optional[ExpectationConfiguration]
) -> bool:
"""
Validates that a configuration has been set, and sets a configuration if it has yet to be set. Ensures that
necessary configuration arguments have been provided for the validation of the expectation.
Args:
configuration (OPTIONAL[ExpectationConfiguration]): \
An optional Expectation Configuration entry that will be used to configure the expectation
Returns:
True if the configuration has been validated successfully. Otherwise, raises an exception
"""
# Setting up a configuration
super().validate_configuration(configuration)
value = configuration.kwargs.get("value")
try:
assert value is not None, "An expected row count must be provided"
if not isinstance(value, (int, dict)):
raise ValueError("Provided row count must be an integer")
if isinstance(value, dict):
assert (
"$PARAMETER" in value
), 'Evaluation Parameter dict for value kwarg must have "$PARAMETER" key.'
except AssertionError as e:
raise InvalidExpectationConfigurationError(str(e))
return True
def validate_configuration(
self, configuration: Optional[ExpectationConfiguration]) -> None:
super().validate_configuration(configuration)
if configuration is None:
configuration = self.configuration
try:
assert ("column_A" in configuration.kwargs and "column_B"
in configuration.kwargs), "both columns must be provided"
except AssertionError as e:
raise InvalidExpectationConfigurationError(str(e))
def validate_configuration(
self, configuration: Optional[ExpectationConfiguration]) -> None:
super().validate_configuration(configuration)
try:
assert "like_pattern" in configuration.kwargs, "Must provide like_pattern"
assert isinstance(configuration.kwargs.get("like_pattern"),
(str, dict)), "like_pattern must be a string"
if isinstance(configuration.kwargs.get("like_pattern"), dict):
assert "$PARAMETER" in configuration.kwargs.get(
"like_pattern"
), 'Evaluation Parameter dict for like_pattern kwarg must have "$PARAMETER" key.'
except AssertionError as e:
raise InvalidExpectationConfigurationError(str(e))
def validate_configuration(
self, configuration: Optional[ExpectationConfiguration]) -> None:
super().validate_configuration(configuration)
if configuration is None:
configuration = self.configuration
try:
assert "regex" in configuration.kwargs, "regex is required"
assert isinstance(configuration.kwargs["regex"],
(str, dict)), "regex must be a string"
if isinstance(configuration.kwargs["regex"], dict):
assert (
"$PARAMETER" in configuration.kwargs["regex"]
), 'Evaluation Parameter dict for regex kwarg must have "$PARAMETER" key.'
except AssertionError as e:
raise InvalidExpectationConfigurationError(str(e))
def validate_configuration(
self, configuration: Optional[ExpectationConfiguration]) -> None:
super().validate_configuration(configuration)
try:
assert (
"column" in configuration.kwargs
), "'column' parameter is required for column map expectations"
if "mostly" in configuration.kwargs:
mostly = configuration.kwargs["mostly"]
assert isinstance(
mostly,
(int,
float)), "'mostly' parameter must be an integer or float"
assert 0 <= mostly <= 1, "'mostly' parameter must be between 0 and 1"
except AssertionError as e:
raise InvalidExpectationConfigurationError(str(e))
def validate_configuration(
self, configuration: Optional[ExpectationConfiguration]) -> None:
"""Validating that user has inputted a value set and that configuration has been initialized"""
super().validate_configuration(configuration)
try:
assert "value_set" in configuration.kwargs, "value_set is required"
assert isinstance(
configuration.kwargs["value_set"],
(list, set, dict)), "value_set must be a list or a set"
if isinstance(configuration.kwargs["value_set"], dict):
assert (
"$PARAMETER" in configuration.kwargs["value_set"]
), 'Evaluation Parameter dict for value_set kwarg must have "$PARAMETER" key'
except AssertionError as e:
raise InvalidExpectationConfigurationError(str(e))
def validate_configuration(
self, configuration: Optional[ExpectationConfiguration]) -> bool:
if not super().validate_configuration(configuration):
return False
try:
assert "value_set" in configuration.kwargs, "value_set is required"
assert (isinstance(configuration.kwargs["value_set"],
(list, set, dict))
or configuration.kwargs["value_set"] is None
), "value_set must be a list, set, or None"
if isinstance(configuration.kwargs["value_set"], dict):
assert (
"$PARAMETER" in configuration.kwargs["value_set"]
), 'Evaluation Parameter dict for value_set kwarg must have "$PARAMETER" key.'
except AssertionError as e:
raise InvalidExpectationConfigurationError(str(e))
return True
def validate_configuration(
self, configuration: Optional[ExpectationConfiguration]) -> None:
super().validate_configuration(configuration)
if configuration is None:
configuration = self.configuration
try:
assert ("value" in configuration.kwargs
), "The length parameter 'value' is required"
assert isinstance(
configuration.kwargs["value"],
(float, int, dict)), "given value must be numerical"
if isinstance(configuration.kwargs["value"], dict):
assert (
"$PARAMETER" in configuration.kwargs["value"]
), 'Evaluation Parameter dict for value kwarg must have "$PARAMETER" key.'
except AssertionError as e:
raise InvalidExpectationConfigurationError(str(e))
def validate_configuration(
self, configuration: Optional[ExpectationConfiguration]) -> None:
super().validate_configuration(configuration)
# supports extensibility by allowing value_set to not be provided in config but captured via child-class default_kwarg_values, e.g. parameterized expectations
value_set = configuration.kwargs.get(
"value_set") or self.default_kwarg_values.get("value_set")
try:
assert ("value_set" in configuration.kwargs
or value_set), "value_set is required"
assert isinstance(
value_set,
(list, set, dict)), "value_set must be a list, set, or dict"
if isinstance(value_set, dict):
assert (
"$PARAMETER" in value_set
), 'Evaluation Parameter dict for value_set kwarg must have "$PARAMETER" key.'
except AssertionError as e:
raise InvalidExpectationConfigurationError(str(e))
def validate_configuration(
cls, configuration: Optional[ExpectationConfiguration]) -> None:
"""
Validates that a configuration has been set, and sets a configuration if it has yet to be set. Ensures that
necessary configuration arguments have been provided for the validation of the expectation.
Args:
configuration (OPTIONAL[ExpectationConfiguration]): \
An optional Expectation Configuration entry that will be used to configure the expectation
Returns:
None. Raises InvalidExpectationConfigurationError if the config is not validated successfully
"""
# Setting up a configuration
super().validate_configuration(configuration)
if configuration is None:
configuration = cls.configuration
center_point = configuration.kwargs["center_point"]
range = configuration.kwargs["range"]
unit = configuration.kwargs["unit"]
projection = configuration.kwargs["projection"]
try:
assert (center_point is not None and range
is not None), "center_point and range must be specified"
assert (isinstance(center_point, tuple)
or isinstance(center_point, list)) and all(
isinstance(n, float) for n in center_point
), "center_point must be a tuple or list of lat/lon floats"
assert (center_point[0] >= -90 and center_point[0] <= 90) and (
center_point[1] >= -180 and center_point[1] <= 180
), "center_point must be a valid lat/lon pair"
assert isinstance(range,
(float, int)), "range must be a numeric value"
assert isinstance(unit, str) and unit in [
"miles",
"kilometers",
], "unit must be a string specifying miles or kilometers"
assert isinstance(projection, str) and projection in [
"fcc",
"pythagorean",
], "projection must be a string specifying fcc or pythagorean"
except AssertionError as e:
raise InvalidExpectationConfigurationError(str(e))
def validate_configuration(
self, configuration: Optional[ExpectationConfiguration]) -> None:
super().validate_configuration(configuration)
if configuration is None:
configuration = self.configuration
# supports extensibility by allowing value_set to not be provided in config but captured via child-class default_kwarg_values, e.g. parameterized expectations
regex = configuration.kwargs.get(
"regex") or self.default_kwarg_values.get("regex")
try:
assert "regex" in configuration.kwargs or regex, "regex is required"
assert isinstance(regex, (str, dict)), "regex must be a string"
if isinstance(regex, dict):
assert (
"$PARAMETER" in regex
), 'Evaluation Parameter dict for regex kwarg must have "$PARAMETER" key.'
except AssertionError as e:
raise InvalidExpectationConfigurationError(str(e))
def validate_configuration(
self, configuration: Optional[ExpectationConfiguration]) -> None:
super().validate_configuration(configuration)
try:
assert ("like_pattern_list"
in configuration.kwargs), "Must provide like_pattern_list"
assert isinstance(configuration.kwargs.get("like_pattern_list"),
(list, dict)), "like_pattern_list must be a list"
assert isinstance(
configuration.kwargs.get("like_pattern_list"), dict
) or (
len(configuration.kwargs.get("like_pattern_list")) > 0
), "At least one like_pattern must be supplied in the like_pattern_list."
if isinstance(configuration.kwargs.get("like_pattern_list"), dict):
assert "$PARAMETER" in configuration.kwargs.get(
"like_pattern_list"
), 'Evaluation Parameter dict for like_pattern_list kwarg must have "$PARAMETER" key.'
except AssertionError as e:
raise InvalidExpectationConfigurationError(str(e))
def validate_configuration(
self, configuration: Optional[ExpectationConfiguration]) -> None:
super().validate_configuration(configuration)
if configuration is None:
configuration = self.configuration
try:
assert "regex_list" in configuration.kwargs, "regex_list is required"
assert isinstance(
configuration.kwargs["regex_list"],
(list, dict)), "regex_list must be a list of regexes"
if (not isinstance(configuration.kwargs["regex_list"], dict)
and len(configuration.kwargs["regex_list"]) > 0):
for i in configuration.kwargs["regex_list"]:
assert isinstance(i,
str), "regexes in list must be strings"
if isinstance(configuration.kwargs["regex_list"], dict):
assert (
"$PARAMETER" in configuration.kwargs["regex_list"]
), 'Evaluation Parameter dict for regex_list kwarg must have "$PARAMETER" key.'
except AssertionError as e:
raise InvalidExpectationConfigurationError(str(e))
def validate_configuration(
self, configuration: Optional[ExpectationConfiguration]) -> bool:
"""
Validates that a configuration has been set, and sets a configuration if it has yet to be set. Ensures that
necessary configuration arguments have been provided for the validation of the expectation.
Args:
configuration (OPTIONAL[ExpectationConfiguration]): \
An optional Expectation Configuration entry that will be used to configure the expectation
Returns:
True if the configuration has been validated successfully. Otherwise, raises an exception
"""
# Setting up a configuration
super().validate_configuration(configuration)
if configuration is None:
configuration = self.configuration
try:
# Ensuring Z-score Threshold metric has been properly provided
assert ("threshold" in configuration.kwargs
), "A Z-score threshold must be provided"
assert isinstance(
configuration.kwargs["threshold"],
(float, int, dict)), "Provided threshold must be a number"
if isinstance(configuration.kwargs["threshold"], dict):
assert (
"$PARAMETER" in configuration.kwargs["threshold"]
), 'Evaluation Parameter dict for threshold kwarg must have "$PARAMETER" key.'
assert isinstance(
configuration.kwargs["double_sided"],
(bool, dict)), "Double sided parameter must be a boolean value"
if isinstance(configuration.kwargs["double_sided"], dict):
assert (
"$PARAMETER" in configuration.kwargs["double_sided"]
), 'Evaluation Parameter dict for double_sided kwarg must have "$PARAMETER" key.'
except AssertionError as e:
raise InvalidExpectationConfigurationError(str(e))
return True