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