arize 8.0.0b1__py3-none-any.whl → 8.0.0b2__py3-none-any.whl

arize/ml/batch_validation/validator.py

@@ -39,8 +39,70 @@ from arize.constants.ml import (
     MIN_PREDICTION_ID_LEN,
     MODEL_MAPPING_CONFIG,
 )
+from arize.exceptions.base import (
+    InvalidDataFrameIndex,
+    InvalidFieldTypeConversion,
+    ValidationError,
+)
+from arize.exceptions.types import (
+    InvalidFieldTypeLlmConfig,
+    InvalidFieldTypePromptTemplates,
+    InvalidType,
+    InvalidTypeColumns,
+    InvalidTypeFeatures,
+    InvalidTypeShapValues,
+    InvalidTypeTags,
+    InvalidValueEmbeddingRawDataTooLong,
+    InvalidValueEmbeddingVectorDimensionality,
+)
+from arize.exceptions.values import (
+    InvalidBoundingBoxesCategories,
+    InvalidBoundingBoxesCoordinates,
+    InvalidBoundingBoxesScores,
+    InvalidMultiClassActScoreValue,
+    InvalidMultiClassClassNameLength,
+    InvalidMultiClassPredScoreValue,
+    InvalidMultiClassThresholdClasses,
+    InvalidNumClassesMultiClassMap,
+    InvalidPolygonCategories,
+    InvalidPolygonCoordinates,
+    InvalidPolygonScores,
+    InvalidRankingCategoryValue,
+    InvalidRankValue,
+    InvalidRecord,
+    InvalidStringLengthInColumn,
+    InvalidTagLength,
+    InvalidValueMissingValue,
+    InvalidValueTimestamp,
+)
 from arize.logging import get_truncation_warning_message
-from arize.ml.batch_validation import errors as err
+from arize.ml.batch_validation.errors import (
+    DuplicateColumnsInDataframe,
+    InvalidBatchId,
+    InvalidColumnNameEmptyString,
+    InvalidEnvironment,
+    InvalidFieldTypeEmbeddingFeatures,
+    InvalidFieldTypePromptResponse,
+    InvalidModelId,
+    InvalidModelType,
+    InvalidModelTypeAndMetricsCombination,
+    InvalidModelVersion,
+    InvalidNumberOfEmbeddings,
+    InvalidPredActColumnNamesForModelType,
+    InvalidPredActCVColumnNamesForModelType,
+    InvalidSchemaType,
+    InvalidShapSuffix,
+    MissingColumns,
+    MissingCVPredAct,
+    MissingPredictionIdColumnForDelayedRecords,
+    MissingPreprodAct,
+    MissingPreprodPredActNumericAndCategorical,
+    MissingReqPredActColumnNamesForMultiClass,
+    MissingRequiredColumnsForRankingModel,
+    MissingRequiredColumnsMetricsValidation,
+    MultipleCVPredAct,
+    ReservedColumns,
+)
 from arize.ml.types import (
     CATEGORICAL_MODEL_TYPES,
     NUMERIC_MODEL_TYPES,
@@ -74,8 +136,8 @@ class Validator:
         schema: BaseSchema,
         model_version: str | None = None,
         batch_id: str | None = None,
-    ) -> list[err.ValidationError]:
-        """Validate required checks for schema, environment, and DataFrame structure."""
+    ) -> list[ValidationError]:
+        """Validate required checks for schema, environment, and :class:`pandas.DataFrame` structure."""
         general_checks = chain(
             Validator._check_valid_schema_type(schema, environment),
             Validator._check_field_convertible_to_str(
@@ -115,7 +177,7 @@ class Validator:
         metric_families: list[Metrics] | None = None,
         model_version: str | None = None,
         batch_id: str | None = None,
-    ) -> list[err.ValidationError]:
+    ) -> list[ValidationError]:
         """Validate parameters including model type, environment, and schema consistency."""
         # general checks
         general_checks = chain(
@@ -223,7 +285,7 @@ class Validator:
         model_type: ModelTypes,
         schema: BaseSchema,
         pyarrow_schema: pa.Schema,
-    ) -> list[err.ValidationError]:
+    ) -> list[ValidationError]:
         """Validate column data types against expected types for the schema."""
         column_types = dict(
             zip(pyarrow_schema.names, pyarrow_schema.types, strict=True)
@@ -323,7 +385,7 @@ class Validator:
         environment: Environments,
         schema: BaseSchema,
         model_type: ModelTypes,
-    ) -> list[err.ValidationError]:
+    ) -> list[ValidationError]:
         """Validate data values including ranges, formats, and consistency checks."""
         # ASSUMPTION: at this point the param and type checks should have passed.
         # This function may crash if that is not true, e.g. if columns are missing
@@ -444,15 +506,15 @@ class Validator:
     @staticmethod
     def _check_column_names_for_empty_strings(
         schema: BaseSchema,
-    ) -> list[err.InvalidColumnNameEmptyString]:
+    ) -> list[InvalidColumnNameEmptyString]:
         if "" in schema.get_used_columns():
-            return [err.InvalidColumnNameEmptyString()]
+            return [InvalidColumnNameEmptyString()]
         return []
 
     @staticmethod
     def _check_field_convertible_to_str(
         model_id: object, model_version: object, batch_id: object
-    ) -> list[err.InvalidFieldTypeConversion]:
+    ) -> list[InvalidFieldTypeConversion]:
         # converting to a set first makes the checks run a lot faster
         wrong_fields = []
         if model_id is not None and not isinstance(model_id, str):
@@ -472,61 +534,59 @@ class Validator:
                 wrong_fields.append("batch_id")
 
         if wrong_fields:
-            return [err.InvalidFieldTypeConversion(wrong_fields, "string")]
+            return [InvalidFieldTypeConversion(wrong_fields, "string")]
         return []
 
     @staticmethod
     def _check_field_type_embedding_features_column_names(
         schema: Schema,
-    ) -> list[err.InvalidFieldTypeEmbeddingFeatures]:
+    ) -> list[InvalidFieldTypeEmbeddingFeatures]:
         if schema.embedding_feature_column_names is not None:
             if not isinstance(schema.embedding_feature_column_names, dict):
-                return [err.InvalidFieldTypeEmbeddingFeatures()]
+                return [InvalidFieldTypeEmbeddingFeatures()]
             for k, v in schema.embedding_feature_column_names.items():
                 if not isinstance(k, str) or not isinstance(
                     v, EmbeddingColumnNames
                 ):
-                    return [err.InvalidFieldTypeEmbeddingFeatures()]
+                    return [InvalidFieldTypeEmbeddingFeatures()]
         return []
 
     @staticmethod
     def _check_field_type_prompt_response(
         schema: Schema,
-    ) -> list[err.InvalidFieldTypePromptResponse]:
+    ) -> list[InvalidFieldTypePromptResponse]:
         errors = []
         if schema.prompt_column_names is not None and not isinstance(
             schema.prompt_column_names, (str, EmbeddingColumnNames)
         ):
-            errors.append(
-                err.InvalidFieldTypePromptResponse("prompt_column_names")
-            )
+            errors.append(InvalidFieldTypePromptResponse("prompt_column_names"))
         if schema.response_column_names is not None and not isinstance(
             schema.response_column_names, (str, EmbeddingColumnNames)
         ):
             errors.append(
-                err.InvalidFieldTypePromptResponse("response_column_names")
+                InvalidFieldTypePromptResponse("response_column_names")
             )
         return errors
 
     @staticmethod
     def _check_field_type_prompt_templates(
         schema: Schema,
-    ) -> list[err.InvalidFieldTypePromptTemplates]:
+    ) -> list[InvalidFieldTypePromptTemplates]:
         if schema.prompt_template_column_names is not None and not isinstance(
             schema.prompt_template_column_names, PromptTemplateColumnNames
         ):
-            return [err.InvalidFieldTypePromptTemplates()]
+            return [InvalidFieldTypePromptTemplates()]
         return []
 
     @staticmethod
     def _check_field_type_llm_config(
         dataframe: pd.DataFrame,
         schema: Schema,
-    ) -> list[err.InvalidFieldTypeLlmConfig | err.InvalidTypeColumns]:
+    ) -> list[InvalidFieldTypeLlmConfig | InvalidTypeColumns]:
         if schema.llm_config_column_names is None:
             return []
         if not isinstance(schema.llm_config_column_names, LLMConfigColumnNames):
-            return [err.InvalidFieldTypeLlmConfig()]
+            return [InvalidFieldTypeLlmConfig()]
         col = schema.llm_config_column_names.params_column_name
         # We check the types if the columns are in the dataframe.
         # If the columns are reflected in the schema but not present
@@ -545,7 +605,7 @@ class Validator:
             )
         ):
             return [
-                err.InvalidTypeColumns(
+                InvalidTypeColumns(
                     wrong_type_columns=[col],
                     expected_types=[
                         "Dict[str, (bool, int, float, string or list[str])]"
@@ -557,9 +617,9 @@ class Validator:
     @staticmethod
     def _check_invalid_index(
         dataframe: pd.DataFrame,
-    ) -> list[err.InvalidDataFrameIndex]:
+    ) -> list[InvalidDataFrameIndex]:
         if (dataframe.index != dataframe.reset_index(drop=True).index).any():
-            return [err.InvalidDataFrameIndex()]
+            return [InvalidDataFrameIndex()]
         return []
 
     # ----------------
@@ -571,7 +631,7 @@ class Validator:
         model_type: ModelTypes,
         metric_families: list[Metrics] | None,
         schema: Schema,
-    ) -> list[err.ValidationError]:
+    ) -> list[ValidationError]:
         if metric_families is None:
             return []
 
@@ -597,7 +657,7 @@ class Validator:
         if not valid_combination:
             # Model type + metrics combination is not valid.
             return [
-                err.InvalidModelTypeAndMetricsCombination(
+                InvalidModelTypeAndMetricsCombination(
                     model_type,
                     metric_families,
                     suggested_model_metric_combinations,
@@ -606,7 +666,7 @@ class Validator:
         if missing_columns:
             # For this model type, the schema is missing columns required for the requested metrics.
             return [
-                err.MissingRequiredColumnsMetricsValidation(
+                MissingRequiredColumnsMetricsValidation(
                     model_type, metric_families, missing_columns
                 )
             ]
@@ -674,7 +734,7 @@ class Validator:
     @staticmethod
     def _check_existence_prediction_id_column_delayed_schema(
         schema: Schema, model_type: ModelTypes
-    ) -> list[err.MissingPredictionIdColumnForDelayedRecords]:
+    ) -> list[MissingPredictionIdColumnForDelayedRecords]:
         if schema.prediction_id_column_name is not None:
             return []
         # TODO: Revise logic once prediction_label column addition (for generative models)
@@ -683,7 +743,7 @@ class Validator:
             # We skip GENERATIVE model types since they are assigned a default
             # prediction label column with values equal 1
             return [
-                err.MissingPredictionIdColumnForDelayedRecords(
+                MissingPredictionIdColumnForDelayedRecords(
                     schema.has_actual_columns(),
                     schema.has_feature_importance_columns(),
                 )
@@ -705,7 +765,7 @@ class Validator:
     def _check_missing_columns(
         dataframe: pd.DataFrame,
         schema: BaseSchema,
-    ) -> list[err.MissingColumns]:
+    ) -> list[MissingColumns]:
         if isinstance(schema, CorpusSchema):
             return Validator._check_missing_columns_corpus_schema(
                 dataframe, schema
@@ -718,7 +778,7 @@ class Validator:
     def _check_missing_columns_schema(
         dataframe: pd.DataFrame,
         schema: Schema,
-    ) -> list[err.MissingColumns]:
+    ) -> list[MissingColumns]:
         # converting to a set first makes the checks run a lot faster
         existing_columns = set(dataframe.columns)
         missing_columns = []
@@ -901,14 +961,14 @@ class Validator:
             )
 
         if missing_columns:
-            return [err.MissingColumns(missing_columns)]
+            return [MissingColumns(missing_columns)]
         return []
 
     @staticmethod
     def _check_missing_columns_corpus_schema(
         dataframe: pd.DataFrame,
         schema: CorpusSchema,
-    ) -> list[err.MissingColumns]:
+    ) -> list[MissingColumns]:
         # converting to a set first makes the checks run a lot faster
         existing_columns = set(dataframe.columns)
         missing_columns = []
@@ -958,19 +1018,19 @@ class Validator:
                     schema.document_text_embedding_column_names.link_to_data_column_name
                 )
         if missing_columns:
-            return [err.MissingColumns(missing_columns)]
+            return [MissingColumns(missing_columns)]
         return []
 
     @staticmethod
     def _check_valid_schema_type(
         schema: BaseSchema,
         environment: Environments,
-    ) -> list[err.InvalidSchemaType]:
+    ) -> list[InvalidSchemaType]:
         if environment == Environments.CORPUS and not (
             isinstance(schema, CorpusSchema)
         ):
             return [
-                err.InvalidSchemaType(
+                InvalidSchemaType(
                     schema_type=str(type(schema)), environment=environment
                 )
             ]
@@ -978,7 +1038,7 @@ class Validator:
             schema, CorpusSchema
         ):
             return [
-                err.InvalidSchemaType(
+                InvalidSchemaType(
                     schema_type=str(type(schema)), environment=environment
                 )
             ]
@@ -987,7 +1047,7 @@ class Validator:
     @staticmethod
     def _check_invalid_shap_suffix(
         schema: Schema,
-    ) -> list[err.InvalidShapSuffix]:
+    ) -> list[InvalidShapSuffix]:
         invalid_column_names = set()
 
         if schema.feature_column_names is not None:
@@ -1016,14 +1076,14 @@ class Validator:
                     invalid_column_names.add(col)
 
         if invalid_column_names:
-            return [err.InvalidShapSuffix(invalid_column_names)]
+            return [InvalidShapSuffix(invalid_column_names)]
         return []
 
     @staticmethod
     def _check_reserved_columns(
         schema: BaseSchema,
         model_type: ModelTypes,
-    ) -> list[err.ReservedColumns]:
+    ) -> list[ReservedColumns]:
         if isinstance(schema, CorpusSchema):
             return []
         if isinstance(schema, Schema):
@@ -1127,29 +1187,29 @@ class Validator:
                     )
 
             if reserved_columns:
-                return [err.ReservedColumns(reserved_columns)]
+                return [ReservedColumns(reserved_columns)]
         return []
 
     @staticmethod
     def _check_invalid_model_id(
         model_id: str | None,
-    ) -> list[err.InvalidModelId]:
+    ) -> list[InvalidModelId]:
         # assume it's been coerced to string beforehand
         if (not isinstance(model_id, str)) or len(model_id.strip()) == 0:
-            return [err.InvalidModelId()]
+            return [InvalidModelId()]
         return []
 
     @staticmethod
     def _check_invalid_model_version(
         model_version: str | None = None,
-    ) -> list[err.InvalidModelVersion]:
+    ) -> list[InvalidModelVersion]:
         if model_version is None:
             return []
         if (
             not isinstance(model_version, str)
             or len(model_version.strip()) == 0
         ):
-            return [err.InvalidModelVersion()]
+            return [InvalidModelVersion()]
 
         return []
 
@@ -1157,35 +1217,35 @@ class Validator:
     def _check_invalid_batch_id(
         batch_id: str | None,
         environment: Environments,
-    ) -> list[err.InvalidBatchId]:
+    ) -> list[InvalidBatchId]:
         # assume it's been coerced to string beforehand
         if environment in (Environments.VALIDATION,) and (
             (not isinstance(batch_id, str)) or len(batch_id.strip()) == 0
         ):
-            return [err.InvalidBatchId()]
+            return [InvalidBatchId()]
         return []
 
     @staticmethod
     def _check_invalid_model_type(
         model_type: ModelTypes,
-    ) -> list[err.InvalidModelType]:
+    ) -> list[InvalidModelType]:
         if model_type in (mt for mt in ModelTypes):
             return []
-        return [err.InvalidModelType()]
+        return [InvalidModelType()]
 
     @staticmethod
     def _check_invalid_environment(
         environment: Environments,
-    ) -> list[err.InvalidEnvironment]:
+    ) -> list[InvalidEnvironment]:
         if environment in (env for env in Environments):
             return []
-        return [err.InvalidEnvironment()]
+        return [InvalidEnvironment()]
 
     @staticmethod
     def _check_existence_preprod_pred_act_score_or_label(
         schema: Schema,
         environment: Environments,
-    ) -> list[err.MissingPreprodPredActNumericAndCategorical]:
+    ) -> list[MissingPreprodPredActNumericAndCategorical]:
         if environment in (Environments.VALIDATION, Environments.TRAINING) and (
             (
                 schema.prediction_label_column_name is None
@@ -1196,13 +1256,13 @@ class Validator:
                 and schema.actual_score_column_name is None
             )
         ):
-            return [err.MissingPreprodPredActNumericAndCategorical()]
+            return [MissingPreprodPredActNumericAndCategorical()]
         return []
 
     @staticmethod
     def _check_exactly_one_cv_column_type(
         schema: Schema, environment: Environments
-    ) -> list[err.MultipleCVPredAct | err.MissingCVPredAct]:
+    ) -> list[MultipleCVPredAct | MissingCVPredAct]:
         # Checks that the required prediction/actual columns are given in the schema depending on
         # the environment, for object detection models. There should be exactly one of
         # object detection, semantic segmentation, or instance segmentation columns.
@@ -1232,9 +1292,9 @@ class Validator:
             )
 
             if cv_types_count == 0:
-                return [err.MissingCVPredAct(environment)]
+                return [MissingCVPredAct(environment)]
             if cv_types_count > 1:
-                return [err.MultipleCVPredAct(environment)]
+                return [MultipleCVPredAct(environment)]
 
         elif environment in (
             Environments.TRAINING,
@@ -1265,16 +1325,16 @@ class Validator:
             )
 
             if cv_types_count == 0:
-                return [err.MissingCVPredAct(environment)]
+                return [MissingCVPredAct(environment)]
             if cv_types_count > 1:
-                return [err.MultipleCVPredAct(environment)]
+                return [MultipleCVPredAct(environment)]
 
         return []
 
     @staticmethod
     def _check_missing_object_detection_columns(
         schema: Schema, model_type: ModelTypes
-    ) -> list[err.InvalidPredActCVColumnNamesForModelType]:
+    ) -> list[InvalidPredActCVColumnNamesForModelType]:
         # Checks that models that are not Object Detection models don't have, in the schema, the
         # object detection, semantic segmentation, or instance segmentation dedicated prediction/actual
         # column names
@@ -1286,13 +1346,13 @@ class Validator:
             or schema.instance_segmentation_prediction_column_names is not None
             or schema.instance_segmentation_actual_column_names is not None
         ):
-            return [err.InvalidPredActCVColumnNamesForModelType(model_type)]
+            return [InvalidPredActCVColumnNamesForModelType(model_type)]
         return []
 
     @staticmethod
     def _check_missing_non_object_detection_columns(
         schema: Schema, model_type: ModelTypes
-    ) -> list[err.InvalidPredActColumnNamesForModelType]:
+    ) -> list[InvalidPredActColumnNamesForModelType]:
         # Checks that object detection models don't have, in the schema, the columns reserved for
         # other model types
         columns_to_check = (
@@ -1317,7 +1377,7 @@ class Validator:
                 "instance_segmentation_actual_column_names",
             ]
             return [
-                err.InvalidPredActColumnNamesForModelType(
+                InvalidPredActColumnNamesForModelType(
                     model_type, allowed_cols, wrong_cols
                 )
             ]
@@ -1326,7 +1386,7 @@ class Validator:
     @staticmethod
     def _check_missing_multi_class_columns(
         schema: Schema, model_type: ModelTypes
-    ) -> list[err.InvalidPredActColumnNamesForModelType]:
+    ) -> list[InvalidPredActColumnNamesForModelType]:
         # Checks that models that are not Multi Class models don't have, in the schema, the
         # multi class dedicated threshold column
         if (
@@ -1334,7 +1394,7 @@ class Validator:
             and schema.multi_class_threshold_scores_column_name is not None
         ):
             return [
-                err.InvalidPredActColumnNamesForModelType(
+                InvalidPredActColumnNamesForModelType(
                     model_type,
                     None,
                     [schema.multi_class_threshold_scores_column_name],
@@ -1345,7 +1405,7 @@ class Validator:
     @staticmethod
     def _check_existing_multi_class_columns(
         schema: Schema,
-    ) -> list[err.MissingReqPredActColumnNamesForMultiClass]:
+    ) -> list[MissingReqPredActColumnNamesForMultiClass]:
         # Checks that models that are Multi Class models have, in the schema, the
         # required prediction score or actual score columns
         if (
@@ -1355,13 +1415,13 @@ class Validator:
             schema.multi_class_threshold_scores_column_name is not None
             and schema.prediction_score_column_name is None
         ):
-            return [err.MissingReqPredActColumnNamesForMultiClass()]
+            return [MissingReqPredActColumnNamesForMultiClass()]
         return []
 
     @staticmethod
     def _check_missing_non_multi_class_columns(
         schema: Schema, model_type: ModelTypes
-    ) -> list[err.InvalidPredActColumnNamesForModelType]:
+    ) -> list[InvalidPredActColumnNamesForModelType]:
         # Checks that multi class models don't have, in the schema, the columns reserved for
         # other model types
         columns_to_check = (
@@ -1387,7 +1447,7 @@ class Validator:
                 "actual_score_column_name",
             ]
             return [
-                err.InvalidPredActColumnNamesForModelType(
+                InvalidPredActColumnNamesForModelType(
                     model_type, allowed_cols, wrong_cols
                 )
             ]
@@ -1397,17 +1457,17 @@ class Validator:
     def _check_existence_preprod_act(
         schema: Schema,
         environment: Environments,
-    ) -> list[err.MissingPreprodAct]:
+    ) -> list[MissingPreprodAct]:
         if environment in (Environments.VALIDATION, Environments.TRAINING) and (
             schema.actual_label_column_name is None
         ):
-            return [err.MissingPreprodAct()]
+            return [MissingPreprodAct()]
         return []
 
     @staticmethod
     def _check_existence_group_id_rank_category_relevance(
         schema: Schema,
-    ) -> list[err.MissingRequiredColumnsForRankingModel]:
+    ) -> list[MissingRequiredColumnsForRankingModel]:
         # prediction_group_id and rank columns are required as ranking prediction columns.
         ranking_prediction_cols = (
             schema.prediction_label_column_name,
@@ -1425,13 +1485,13 @@ class Validator:
         # If there is prediction information (not delayed actuals),
         # there must exist a rank and prediction group id columns
         if has_prediction_info and any(col is None for col in required):
-            return [err.MissingRequiredColumnsForRankingModel()]
+            return [MissingRequiredColumnsForRankingModel()]
         return []
 
     @staticmethod
     def _check_dataframe_for_duplicate_columns(
         schema: BaseSchema, dataframe: pd.DataFrame
-    ) -> list[err.DuplicateColumnsInDataframe]:
+    ) -> list[DuplicateColumnsInDataframe]:
         # Get the columns used in the schema
         schema_col_used = schema.get_used_columns()
         # Get the duplicated column names from the dataframe
@@ -1441,17 +1501,17 @@ class Validator:
             col for col in duplicate_columns if col in schema_col_used
         ]
         if schema_duplicate_cols:
-            return [err.DuplicateColumnsInDataframe(schema_duplicate_cols)]
+            return [DuplicateColumnsInDataframe(schema_duplicate_cols)]
         return []
 
     @staticmethod
     def _check_invalid_number_of_embeddings(
         schema: Schema,
-    ) -> list[err.InvalidNumberOfEmbeddings]:
+    ) -> list[InvalidNumberOfEmbeddings]:
         if schema.embedding_feature_column_names is not None:
             number_of_embeddings = len(schema.embedding_feature_column_names)
             if number_of_embeddings > MAX_NUMBER_OF_EMBEDDINGS:
-                return [err.InvalidNumberOfEmbeddings(number_of_embeddings)]
+                return [InvalidNumberOfEmbeddings(number_of_embeddings)]
         return []
 
     # -----------
@@ -1461,7 +1521,7 @@ class Validator:
     @staticmethod
     def _check_type_prediction_id(
         schema: Schema, column_types: dict[str, Any]
-    ) -> list[err.InvalidType]:
+    ) -> list[InvalidType]:
         col = schema.prediction_id_column_name
         if col in column_types:
             # should mirror server side
@@ -1474,7 +1534,7 @@ class Validator:
             )
             if column_types[col] not in allowed_datatypes:
                 return [
-                    err.InvalidType(
+                    InvalidType(
                         "Prediction IDs",
                         expected_types=["str", "int"],
                         found_data_type=column_types[col],
@@ -1485,7 +1545,7 @@ class Validator:
     @staticmethod
     def _check_type_timestamp(
         schema: Schema, column_types: dict[str, Any]
-    ) -> list[err.InvalidType]:
+    ) -> list[InvalidType]:
         col = schema.timestamp_column_name
         if col in column_types:
             # should mirror server side
@@ -1501,7 +1561,7 @@ class Validator:
                 and t not in allowed_datatypes
             ):
                 return [
-                    err.InvalidType(
+                    InvalidType(
                         "Prediction timestamp",
                         expected_types=["Date", "Timestamp", "int", "float"],
                         found_data_type=t,
@@ -1512,7 +1572,7 @@ class Validator:
     @staticmethod
     def _check_type_features(
         schema: Schema, column_types: dict[str, Any]
-    ) -> list[err.InvalidTypeFeatures]:
+    ) -> list[InvalidTypeFeatures]:
         if schema.feature_column_names is not None:
             # should mirror server side
             allowed_datatypes = (
@@ -1535,7 +1595,7 @@ class Validator:
             ]
             if wrong_type_cols:
                 return [
-                    err.InvalidTypeFeatures(
+                    InvalidTypeFeatures(
                         wrong_type_cols,
                         expected_types=[
                             "float",
@@ -1551,7 +1611,7 @@ class Validator:
     @staticmethod
     def _check_type_embedding_features(
         schema: Schema, column_types: dict[str, Any]
-    ) -> list[err.InvalidTypeFeatures]:
+    ) -> list[InvalidTypeFeatures]:
         if schema.embedding_feature_column_names is not None:
             # should mirror server side
             allowed_vector_datatypes = (
@@ -1599,20 +1659,20 @@ class Validator:
             wrong_type_embedding_errors = []
             if wrong_type_vector_columns:
                 wrong_type_embedding_errors.append(
-                    err.InvalidTypeFeatures(
+                    InvalidTypeFeatures(
                         wrong_type_vector_columns,
                         expected_types=["list[float], np.array[float]"],
                     )
                 )
             if wrong_type_data_columns:
                 wrong_type_embedding_errors.append(
-                    err.InvalidTypeFeatures(
+                    InvalidTypeFeatures(
                         wrong_type_data_columns, expected_types=["list[string]"]
                     )
                 )
             if wrong_type_link_to_data_columns:
                 wrong_type_embedding_errors.append(
-                    err.InvalidTypeFeatures(
+                    InvalidTypeFeatures(
                         wrong_type_link_to_data_columns,
                         expected_types=["string"],
                     )
@@ -1627,7 +1687,7 @@ class Validator:
     @staticmethod
     def _check_type_tags(
         schema: Schema, column_types: dict[str, Any]
-    ) -> list[err.InvalidTypeTags]:
+    ) -> list[InvalidTypeTags]:
         if schema.tag_column_names is not None:
             # should mirror server side
             allowed_datatypes = (
@@ -1649,7 +1709,7 @@ class Validator:
             ]
             if wrong_type_cols:
                 return [
-                    err.InvalidTypeTags(
+                    InvalidTypeTags(
                         wrong_type_cols, ["float", "int", "bool", "str"]
                     )
                 ]
@@ -1658,7 +1718,7 @@ class Validator:
     @staticmethod
     def _check_type_shap_values(
         schema: Schema, column_types: dict[str, Any]
-    ) -> list[err.InvalidTypeShapValues]:
+    ) -> list[InvalidTypeShapValues]:
         if schema.shap_values_column_names is not None:
             # should mirror server side
             allowed_datatypes = (
@@ -1675,7 +1735,7 @@ class Validator:
             ]
             if wrong_type_cols:
                 return [
-                    err.InvalidTypeShapValues(
+                    InvalidTypeShapValues(
                         wrong_type_cols, expected_types=["float", "int"]
                     )
                 ]
@@ -1684,7 +1744,7 @@ class Validator:
     @staticmethod
     def _check_type_pred_act_labels(
         model_type: ModelTypes, schema: Schema, column_types: dict[str, Any]
-    ) -> list[err.InvalidType]:
+    ) -> list[InvalidType]:
         errors = []
         columns = (
             ("Prediction labels", schema.prediction_label_column_name),
@@ -1713,7 +1773,7 @@ class Validator:
                     and column_types[col] not in allowed_datatypes
                 ):
                     errors.append(
-                        err.InvalidType(
+                        InvalidType(
                             name,
                             expected_types=["float", "int", "bool", "str"],
                             found_data_type=column_types[col],
@@ -1737,7 +1797,7 @@ class Validator:
                     and column_types[col] not in allowed_datatypes
                 ):
                     errors.append(
-                        err.InvalidType(
+                        InvalidType(
                             name,
                             expected_types=["float", "int"],
                             found_data_type=column_types[col],
@@ -1748,7 +1808,7 @@ class Validator:
     @staticmethod
     def _check_type_pred_act_scores(
         model_type: ModelTypes, schema: Schema, column_types: dict[str, Any]
-    ) -> list[err.InvalidType]:
+    ) -> list[InvalidType]:
         errors = []
         columns = (
             ("Prediction scores", schema.prediction_score_column_name),
@@ -1777,7 +1837,7 @@ class Validator:
                     and column_types[col] not in allowed_datatypes
                 ):
                     errors.append(
-                        err.InvalidType(
+                        InvalidType(
                             name,
                             expected_types=["float", "int"],
                             found_data_type=column_types[col],
@@ -1788,7 +1848,7 @@ class Validator:
     @staticmethod
     def _check_type_multi_class_pred_threshold_act_scores(
         schema: Schema, column_types: dict[str, Any]
-    ) -> list[err.InvalidType]:
+    ) -> list[InvalidType]:
         """Check type for prediction / threshold / actual scores for multiclass model.
 
         Expect the scores to be a list of pyarrow structs that contains field
@@ -1834,7 +1894,7 @@ class Validator:
                 and column_types[col] not in allowed_class_score_map_datatypes
             ):
                 errors.append(
-                    err.InvalidType(
+                    InvalidType(
                         name,
                         expected_types=[
                             "List[Dict{class_name: str, score: int}]",
@@ -1848,7 +1908,7 @@ class Validator:
     @staticmethod
     def _check_type_prompt_response(
         schema: Schema, column_types: dict[str, Any]
-    ) -> list[err.InvalidTypeColumns]:
+    ) -> list[InvalidTypeColumns]:
         fields_to_check = []
         if schema.prompt_column_names is not None:
             fields_to_check.append(schema.prompt_column_names)
@@ -1895,20 +1955,20 @@ class Validator:
         wrong_type_col_errors = []
         if wrong_type_vector_columns:
             wrong_type_col_errors.append(
-                err.InvalidTypeColumns(
+                InvalidTypeColumns(
                     wrong_type_vector_columns,
                     expected_types=["list[float], np.array[float]"],
                 )
             )
         if wrong_type_data_columns:
             wrong_type_col_errors.append(
-                err.InvalidTypeColumns(
+                InvalidTypeColumns(
                     wrong_type_data_columns, expected_types=["str, list[str]"]
                 )
             )
         if wrong_type_str_columns:
             wrong_type_col_errors.append(
-                err.InvalidTypeColumns(
+                InvalidTypeColumns(
                     wrong_type_str_columns, expected_types=["str"]
                 )
             )
@@ -1918,7 +1978,7 @@ class Validator:
     @staticmethod
     def _check_type_llm_prompt_templates(
         schema: Schema, column_types: dict[str, Any]
-    ) -> list[err.InvalidTypeColumns]:
+    ) -> list[InvalidTypeColumns]:
         if schema.prompt_template_column_names is None:
             return []
 
@@ -1949,7 +2009,7 @@ class Validator:
         # Return errors if any
         if wrong_type_cols:
             return [
-                err.InvalidTypeColumns(
+                InvalidTypeColumns(
                     wrong_type_columns=wrong_type_cols,
                     expected_types=["string"],
                 )
@@ -1959,7 +2019,7 @@ class Validator:
     @staticmethod
     def _check_type_llm_config(
         schema: Schema, column_types: dict[str, Any]
-    ) -> list[err.InvalidTypeColumns]:
+    ) -> list[InvalidTypeColumns]:
         if schema.llm_config_column_names is None:
             return []
 
@@ -1986,7 +2046,7 @@ class Validator:
         # Return errors if any
         if wrong_type_cols:
             return [
-                err.InvalidTypeColumns(
+                InvalidTypeColumns(
                     wrong_type_columns=wrong_type_cols,
                     expected_types=["string"],
                 )
@@ -1996,7 +2056,7 @@ class Validator:
     @staticmethod
     def _check_type_llm_run_metadata(
         schema: Schema, column_types: dict[str, Any]
-    ) -> list[err.InvalidTypeColumns]:
+    ) -> list[InvalidTypeColumns]:
         if schema.llm_run_metadata_column_names is None:
             return []
 
@@ -2059,7 +2119,7 @@ class Validator:
             # Return errors if there are any
             if wrong_type_cols:
                 return [
-                    err.InvalidTypeColumns(
+                    InvalidTypeColumns(
                         wrong_type_columns=wrong_type_cols,
                         expected_types=["int", "float"],
                     )
@@ -2069,7 +2129,7 @@ class Validator:
     @staticmethod
     def _check_type_retrieved_document_ids(
         schema: Schema, column_types: dict[str, Any]
-    ) -> list[err.InvalidType]:
+    ) -> list[InvalidType]:
         col = schema.retrieved_document_ids_column_name
         if col in column_types:
             # should mirror server side
@@ -2079,7 +2139,7 @@ class Validator:
             )
             if column_types[col] not in allowed_datatypes:
                 return [
-                    err.InvalidType(
+                    InvalidType(
                         "Retrieved Document IDs",
                         expected_types=["List[str]"],
                         found_data_type=column_types[col],
@@ -2090,7 +2150,7 @@ class Validator:
     @staticmethod
     def _check_type_image_segment_coordinates(
         schema: Schema, column_types: dict[str, Any]
-    ) -> list[err.InvalidTypeColumns]:
+    ) -> list[InvalidTypeColumns]:
         # should mirror server side
         allowed_coordinate_types = (
             pa.list_(pa.list_(pa.float64())),
@@ -2173,7 +2233,7 @@ class Validator:
 
         return (
             [
-                err.InvalidTypeColumns(
+                InvalidTypeColumns(
                     wrong_type_columns=wrong_type_cols,
                     expected_types=["List[List[float]]"],
                 )
@@ -2185,7 +2245,7 @@ class Validator:
     @staticmethod
     def _check_type_image_segment_categories(
         schema: Schema, column_types: dict[str, Any]
-    ) -> list[err.InvalidTypeColumns]:
+    ) -> list[InvalidTypeColumns]:
         # should mirror server side
         allowed_category_datatypes = (
             pa.list_(pa.string()),
@@ -2242,7 +2302,7 @@ class Validator:
 
         return (
             [
-                err.InvalidTypeColumns(
+                InvalidTypeColumns(
                     wrong_type_columns=wrong_type_cols,
                     expected_types=["List[str]"],
                 )
@@ -2254,7 +2314,7 @@ class Validator:
     @staticmethod
     def _check_type_image_segment_scores(
         schema: Schema, column_types: dict[str, Any]
-    ) -> list[err.InvalidTypeColumns]:
+    ) -> list[InvalidTypeColumns]:
         # should mirror server side
         allowed_score_datatypes = (
             pa.list_(pa.float64()),
@@ -2297,7 +2357,7 @@ class Validator:
 
         return (
             [
-                err.InvalidTypeColumns(
+                InvalidTypeColumns(
                     wrong_type_columns=wrong_type_cols,
                     expected_types=["List[float]"],
                 )
@@ -2313,7 +2373,7 @@ class Validator:
     @staticmethod
     def _check_embedding_vectors_dimensionality(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> list[err.ValidationError]:
+    ) -> list[ValidationError]:
         if schema.embedding_feature_column_names is None:
             return []
 
@@ -2331,7 +2391,7 @@ class Validator:
 
         return (
             [
-                err.InvalidValueEmbeddingVectorDimensionality(
+                InvalidValueEmbeddingVectorDimensionality(
                     invalid_low_dim_vector_cols,
                     invalid_high_dim_vector_cols,
                 ),
@@ -2343,7 +2403,7 @@ class Validator:
     @staticmethod
     def _check_embedding_raw_data_characters(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> list[err.ValidationError]:
+    ) -> list[ValidationError]:
         if schema.embedding_feature_column_names is None:
             return []
 
@@ -2361,7 +2421,7 @@ class Validator:
 
         if invalid_long_string_data_cols:
             return [
-                err.InvalidValueEmbeddingRawDataTooLong(
+                InvalidValueEmbeddingRawDataTooLong(
                     invalid_long_string_data_cols
                 )
             ]
@@ -2377,20 +2437,20 @@ class Validator:
     @staticmethod
     def _check_value_rank(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> list[err.InvalidRankValue]:
+    ) -> list[InvalidRankValue]:
         col = schema.rank_column_name
         lbound, ubound = (1, 100)
 
         if col is not None and col in dataframe.columns:
             rank_min_max = dataframe[col].agg(["min", "max"])
             if rank_min_max["min"] < lbound or rank_min_max["max"] > ubound:
-                return [err.InvalidRankValue(col, "1-100")]
+                return [InvalidRankValue(col, "1-100")]
         return []
 
     @staticmethod
     def _check_id_field_str_length(
         dataframe: pd.DataFrame, schema_name: str, id_col_name: str | None
-    ) -> list[err.ValidationError]:
+    ) -> list[ValidationError]:
         """Require prediction_id to be a string of length between MIN and MAX.
 
         Between MIN_PREDICTION_ID_LEN and MAX_PREDICTION_ID_LEN.
@@ -2412,7 +2472,7 @@ class Validator:
             .all()
         ):
             return [
-                err.InvalidStringLengthInColumn(
+                InvalidStringLengthInColumn(
                     schema_name=schema_name,
                     col_name=id_col_name,
                     min_length=MIN_PREDICTION_ID_LEN,
@@ -2424,7 +2484,7 @@ class Validator:
     @staticmethod
     def _check_document_id_field_str_length(
         dataframe: pd.DataFrame, schema_name: str, id_col_name: str | None
-    ) -> list[err.ValidationError]:
+    ) -> list[ValidationError]:
         """Require document id to be a string of length between MIN and MAX.
 
         Between MIN_DOCUMENT_ID_LEN and MAX_DOCUMENT_ID_LEN.
@@ -2446,7 +2506,7 @@ class Validator:
             .all()
         ):
             return [
-                err.InvalidStringLengthInColumn(
+                InvalidStringLengthInColumn(
                     schema_name=schema_name,
                     col_name=id_col_name,
                     min_length=MIN_DOCUMENT_ID_LEN,
@@ -2476,7 +2536,7 @@ class Validator:
     @staticmethod
     def _check_value_tag(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> list[err.InvalidTagLength]:
+    ) -> list[InvalidTagLength]:
         if schema.tag_column_names is None:
             return []
 
@@ -2501,7 +2561,7 @@ class Validator:
                 elif max_tag_len > MAX_TAG_LENGTH_TRUNCATION:
                     truncated_tag_cols.append(col)
         if wrong_tag_cols:
-            return [err.InvalidTagLength(wrong_tag_cols)]
+            return [InvalidTagLength(wrong_tag_cols)]
         if truncated_tag_cols:
             logger.warning(
                 get_truncation_warning_message(
@@ -2513,7 +2573,7 @@ class Validator:
     @staticmethod
     def _check_value_ranking_category(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> list[err.InvalidValueMissingValue | err.InvalidRankingCategoryValue]:
+    ) -> list[InvalidValueMissingValue | InvalidRankingCategoryValue]:
         if schema.relevance_labels_column_name is not None:
             col = schema.relevance_labels_column_name
         elif schema.attributions_column_name is not None:
@@ -2526,11 +2586,11 @@ class Validator:
                 # which would be caught by _check_value_missing
                 return []
             if dataframe[col].astype(str).str.len().min() == 0:
-                return [err.InvalidRankingCategoryValue(col)]
+                return [InvalidRankingCategoryValue(col)]
             # empty list
             not_null_filter = dataframe[col].notnull()
             if dataframe[not_null_filter][col].map(len).min() == 0:
-                return [err.InvalidValueMissingValue(col, "empty list")]
+                return [InvalidValueMissingValue(col, "empty list")]
             # no empty string in list
             if (
                 dataframe[not_null_filter][col]
@@ -2538,13 +2598,13 @@ class Validator:
                 .min()
                 == 0
             ):
-                return [err.InvalidRankingCategoryValue(col)]
+                return [InvalidRankingCategoryValue(col)]
         return []
 
     @staticmethod
     def _check_length_multi_class_maps(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> list[err.InvalidNumClassesMultiClassMap]:
+    ) -> list[InvalidNumClassesMultiClassMap]:
         # each entry in column is a list of dictionaries mapping class names and scores
         # validate length of list of dictionaries for each column
         invalid_cols = {}
@@ -2575,16 +2635,16 @@ class Validator:
             if invalid_num_classes:
                 invalid_cols[col] = invalid_num_classes
         if invalid_cols:
-            return [err.InvalidNumClassesMultiClassMap(invalid_cols)]
+            return [InvalidNumClassesMultiClassMap(invalid_cols)]
         return []
 
     @staticmethod
     def _check_classes_and_scores_values_in_multi_class_maps(
         dataframe: pd.DataFrame, schema: Schema
     ) -> list[
-        err.InvalidMultiClassClassNameLength
-        | err.InvalidMultiClassActScoreValue
-        | err.InvalidMultiClassPredScoreValue
+        InvalidMultiClassClassNameLength
+        | InvalidMultiClassActScoreValue
+        | InvalidMultiClassPredScoreValue
     ]:
         """Validate the class names and score values of dictionaries.
 
@@ -2649,21 +2709,17 @@ class Validator:
                     if invalid_scores_for_col:
                         invalid_pred_scores[col] = invalid_scores_for_col
         if invalid_class_names:
-            errors.append(
-                err.InvalidMultiClassClassNameLength(invalid_class_names)
-            )
+            errors.append(InvalidMultiClassClassNameLength(invalid_class_names))
         if invalid_pred_scores:
-            errors.append(
-                err.InvalidMultiClassPredScoreValue(invalid_pred_scores)
-            )
+            errors.append(InvalidMultiClassPredScoreValue(invalid_pred_scores))
         if invalid_actual_scores:
-            errors.append(err.InvalidMultiClassActScoreValue(col))
+            errors.append(InvalidMultiClassActScoreValue(col))
         return errors
 
     @staticmethod
     def _check_each_multi_class_pred_has_threshold(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> list[err.InvalidMultiClassThresholdClasses]:
+    ) -> list[InvalidMultiClassThresholdClasses]:
         """Validate threshold scores for Multi Class models.
 
         If threshold scores column is included in schema and dataframe, validate that
@@ -2687,7 +2743,7 @@ class Validator:
             pred_class_set = set(pred_classes)
             if pred_class_set != thresh_class_set:
                 return [
-                    err.InvalidMultiClassThresholdClasses(
+                    InvalidMultiClassThresholdClasses(
                         threshold_col, pred_class_set, thresh_class_set
                     )
                 ]
@@ -2697,7 +2753,7 @@ class Validator:
     def _check_value_timestamp(
         dataframe: pd.DataFrame,
         schema: Schema,
-    ) -> list[err.InvalidValueMissingValue | err.InvalidValueTimestamp]:
+    ) -> list[InvalidValueMissingValue | InvalidValueTimestamp]:
         # Due to the timing difference between checking this here and the data finally
         # hitting the same check on server side, there's a some chance for a false
         # result, i.e. the check here succeeds but the same check on server side fails.
@@ -2708,9 +2764,7 @@ class Validator:
             # missing value first.
             if dataframe[col].isnull().values.any():  # type: ignore
                 return [
-                    err.InvalidValueMissingValue(
-                        "Prediction timestamp", "missing"
-                    )
+                    InvalidValueMissingValue("Prediction timestamp", "missing")
                 ]
 
             now_t = datetime.now(tz=timezone.utc)
@@ -2794,7 +2848,7 @@ class Validator:
                     )
                 )
             ):
-                return [err.InvalidValueTimestamp(timestamp_col_name=col)]
+                return [InvalidValueTimestamp(timestamp_col_name=col)]
 
         return []
 
@@ -2803,7 +2857,7 @@ class Validator:
     @staticmethod
     def _check_invalid_missing_values(
         dataframe: pd.DataFrame, schema: BaseSchema, model_type: ModelTypes
-    ) -> list[err.InvalidValueMissingValue]:
+    ) -> list[InvalidValueMissingValue]:
         errors = []
         columns = ()
         if isinstance(schema, CorpusSchema):
@@ -2824,7 +2878,7 @@ class Validator:
             if col is not None and col in dataframe.columns:
                 if dataframe[col].isnull().any():
                     errors.append(
-                        err.InvalidValueMissingValue(
+                        InvalidValueMissingValue(
                             name, wrong_values="missing", column=col
                         )
                     )
@@ -2834,7 +2888,7 @@ class Validator:
                     and np.isinf(dataframe[col]).any()
                 ):
                     errors.append(
-                        err.InvalidValueMissingValue(
+                        InvalidValueMissingValue(
                             name, wrong_values="infinite", column=col
                         )
                     )
@@ -2850,7 +2904,7 @@ class Validator:
         environment: Environments,
         schema: Schema,
         model_type: ModelTypes,
-    ) -> list[err.InvalidRecord]:
+    ) -> list[InvalidRecord]:
         if environment in (Environments.VALIDATION, Environments.TRAINING):
             return []
 
@@ -2894,7 +2948,7 @@ class Validator:
         environment: Environments,
         schema: Schema,
         model_type: ModelTypes,
-    ) -> list[err.InvalidRecord]:
+    ) -> list[InvalidRecord]:
         """Validates there's not a single row in the dataframe with all nulls.
 
         Returns errors if any row has all of pred_label and pred_score evaluating to
@@ -2942,7 +2996,7 @@ class Validator:
     @staticmethod
     def _check_invalid_record_helper(
         dataframe: pd.DataFrame, column_names: list[str | None]
-    ) -> list[err.InvalidRecord]:
+    ) -> list[InvalidRecord]:
         """Check that there are no null values in a subset of columns.
 
         The column subset is computed from the input list of columns `column_names`
@@ -2950,7 +3004,7 @@ class Validator:
         null values are found.
 
         Returns:
-            List[err.InvalidRecord]: An error expressing the rows that are problematic
+            List[InvalidRecord]: An error expressing the rows that are problematic
 
         """
         columns_subset = [
@@ -2964,12 +3018,12 @@ class Validator:
         null_index = null_filter[null_filter].index.values
         if len(null_index) == 0:
             return []
-        return [err.InvalidRecord(columns_subset, null_index)]  # type: ignore
+        return [InvalidRecord(columns_subset, null_index)]  # type: ignore
 
     @staticmethod
     def _check_type_prediction_group_id(
         schema: Schema, column_types: dict[str, Any]
-    ) -> list[err.InvalidType]:
+    ) -> list[InvalidType]:
         col = schema.prediction_group_id_column_name
         if col in column_types:
             # should mirror server side
@@ -2982,7 +3036,7 @@ class Validator:
             )
             if column_types[col] not in allowed_datatypes:
                 return [
-                    err.InvalidType(
+                    InvalidType(
                         "prediction_group_ids",
                         expected_types=["str", "int"],
                         found_data_type=column_types[col],
@@ -2993,7 +3047,7 @@ class Validator:
     @staticmethod
     def _check_type_rank(
         schema: Schema, column_types: dict[str, Any]
-    ) -> list[err.InvalidType]:
+    ) -> list[InvalidType]:
         col = schema.rank_column_name
         if col in column_types:
             allowed_datatypes = (
@@ -3004,7 +3058,7 @@ class Validator:
             )
             if column_types[col] not in allowed_datatypes:
                 return [
-                    err.InvalidType(
+                    InvalidType(
                         "rank",
                         expected_types=["int"],
                         found_data_type=column_types[col],
@@ -3015,7 +3069,7 @@ class Validator:
     @staticmethod
     def _check_type_ranking_category(
         schema: Schema, column_types: dict[str, Any]
-    ) -> list[err.InvalidType]:
+    ) -> list[InvalidType]:
         if schema.relevance_labels_column_name is not None:
             col = schema.relevance_labels_column_name
         elif schema.attributions_column_name is not None:
@@ -3026,7 +3080,7 @@ class Validator:
             allowed_datatypes = (pa.list_(pa.string()), pa.string(), pa.null())
             if column_types[col] not in allowed_datatypes:
                 return [
-                    err.InvalidType(
+                    InvalidType(
                         "relevance labels column for ranking models",
                         expected_types=["list of string", "string"],
                         found_data_type=column_types[col],
@@ -3037,7 +3091,7 @@ class Validator:
     @staticmethod
     def _check_value_bounding_boxes_coordinates(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> list[err.InvalidBoundingBoxesCoordinates]:
+    ) -> list[InvalidBoundingBoxesCoordinates]:
         errors = []
         if schema.object_detection_prediction_column_names is not None:
             coords_col_name = schema.object_detection_prediction_column_names.bounding_boxes_coordinates_column_name  # noqa: E501
@@ -3058,7 +3112,7 @@ class Validator:
     @staticmethod
     def _check_value_bounding_boxes_categories(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> list[err.InvalidBoundingBoxesCategories]:
+    ) -> list[InvalidBoundingBoxesCategories]:
         errors = []
         if schema.object_detection_prediction_column_names is not None:
             cat_col_name = schema.object_detection_prediction_column_names.categories_column_name
@@ -3079,7 +3133,7 @@ class Validator:
     @staticmethod
     def _check_value_bounding_boxes_scores(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> list[err.InvalidBoundingBoxesScores]:
+    ) -> list[InvalidBoundingBoxesScores]:
         errors = []
         if schema.object_detection_prediction_column_names is not None:
             sc_col_name = schema.object_detection_prediction_column_names.scores_column_name
@@ -3104,7 +3158,7 @@ class Validator:
     @staticmethod
     def _check_value_semantic_segmentation_polygon_coordinates(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> list[err.InvalidPolygonCoordinates]:
+    ) -> list[InvalidPolygonCoordinates]:
         errors = []
         if schema.semantic_segmentation_prediction_column_names is not None:
             coords_col_name = schema.semantic_segmentation_prediction_column_names.polygon_coordinates_column_name  # noqa: E501
@@ -3125,7 +3179,7 @@ class Validator:
     @staticmethod
     def _check_value_semantic_segmentation_polygon_categories(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> list[err.InvalidPolygonCategories]:
+    ) -> list[InvalidPolygonCategories]:
         errors = []
         if schema.semantic_segmentation_prediction_column_names is not None:
             cat_col_name = schema.semantic_segmentation_prediction_column_names.categories_column_name
@@ -3146,7 +3200,7 @@ class Validator:
     @staticmethod
     def _check_value_instance_segmentation_polygon_coordinates(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> list[err.InvalidPolygonCoordinates]:
+    ) -> list[InvalidPolygonCoordinates]:
         errors = []
         if schema.instance_segmentation_prediction_column_names is not None:
             coords_col_name = schema.instance_segmentation_prediction_column_names.polygon_coordinates_column_name  # noqa: E501
@@ -3167,7 +3221,7 @@ class Validator:
     @staticmethod
     def _check_value_instance_segmentation_polygon_categories(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> list[err.InvalidPolygonCategories]:
+    ) -> list[InvalidPolygonCategories]:
         errors = []
         if schema.instance_segmentation_prediction_column_names is not None:
             cat_col_name = schema.instance_segmentation_prediction_column_names.categories_column_name
@@ -3188,7 +3242,7 @@ class Validator:
     @staticmethod
     def _check_value_instance_segmentation_polygon_scores(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> list[err.InvalidPolygonScores]:
+    ) -> list[InvalidPolygonScores]:
         errors = []
         if schema.instance_segmentation_prediction_column_names is not None:
             sc_col_name = schema.instance_segmentation_prediction_column_names.scores_column_name
@@ -3203,7 +3257,7 @@ class Validator:
     @staticmethod
     def _check_value_instance_segmentation_bbox_coordinates(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> list[err.InvalidBoundingBoxesCoordinates]:
+    ) -> list[InvalidBoundingBoxesCoordinates]:
         errors = []
         if schema.instance_segmentation_prediction_column_names is not None:
             coords_col_name = schema.instance_segmentation_prediction_column_names.bounding_boxes_coordinates_column_name  # noqa: E501
@@ -3226,7 +3280,7 @@ class Validator:
     @staticmethod
     def _check_value_prompt_response(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> list[err.ValidationError]:
+    ) -> list[ValidationError]:
         vector_cols_to_check = []
         text_cols_to_check = []
         if isinstance(schema.prompt_column_names, str):
@@ -3265,13 +3319,13 @@ class Validator:
         errors = []
         if invalid_long_string_data_cols:
             errors.append(
-                err.InvalidValueEmbeddingRawDataTooLong(
+                InvalidValueEmbeddingRawDataTooLong(
                     invalid_long_string_data_cols
                 )
             )
         if invalid_low_dim_vector_cols or invalid_high_dim_vector_cols:
             errors.append(
-                err.InvalidValueEmbeddingVectorDimensionality(
+                InvalidValueEmbeddingVectorDimensionality(
                     invalid_low_dim_vector_cols,
                     invalid_high_dim_vector_cols,
                 )
@@ -3291,7 +3345,7 @@ class Validator:
     @staticmethod
     def _check_value_llm_model_name(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> list[err.InvalidStringLengthInColumn]:
+    ) -> list[InvalidStringLengthInColumn]:
         if schema.llm_config_column_names is None:
             return []
         col = schema.llm_config_column_names.model_column_name
@@ -3301,7 +3355,7 @@ class Validator:
             )
             if max_len > MAX_LLM_MODEL_NAME_LENGTH:
                 return [
-                    err.InvalidStringLengthInColumn(
+                    InvalidStringLengthInColumn(
                         schema_name="llm_config_column_names.model_column_name",
                         col_name=col,
                         min_length=0,
@@ -3319,7 +3373,7 @@ class Validator:
     @staticmethod
     def _check_value_llm_prompt_template(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> list[err.InvalidStringLengthInColumn]:
+    ) -> list[InvalidStringLengthInColumn]:
         if schema.prompt_template_column_names is None:
             return []
         col = schema.prompt_template_column_names.template_column_name
@@ -3329,7 +3383,7 @@ class Validator:
             )
             if max_len > MAX_PROMPT_TEMPLATE_LENGTH:
                 return [
-                    err.InvalidStringLengthInColumn(
+                    InvalidStringLengthInColumn(
                         schema_name="prompt_template_column_names.template_column_name",
                         col_name=col,
                         min_length=0,
@@ -3348,7 +3402,7 @@ class Validator:
     @staticmethod
     def _check_value_llm_prompt_template_version(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> list[err.InvalidStringLengthInColumn]:
+    ) -> list[InvalidStringLengthInColumn]:
         if schema.prompt_template_column_names is None:
             return []
         col = schema.prompt_template_column_names.template_version_column_name
@@ -3358,7 +3412,7 @@ class Validator:
             )
             if max_len > MAX_PROMPT_TEMPLATE_VERSION_LENGTH:
                 return [
-                    err.InvalidStringLengthInColumn(
+                    InvalidStringLengthInColumn(
                         schema_name="prompt_template_column_names.template_version_column_name",
                         col_name=col,
                         min_length=0,
@@ -3377,7 +3431,7 @@ class Validator:
     @staticmethod
     def _check_type_document_columns(
         schema: CorpusSchema, column_types: dict[str, Any]
-    ) -> list[err.InvalidTypeColumns]:
+    ) -> list[InvalidTypeColumns]:
         invalid_types = []
         # Check document id
         col = schema.document_id_column_name
@@ -3391,7 +3445,7 @@ class Validator:
             )
             if column_types[col] not in allowed_datatypes:
                 invalid_types += [
-                    err.InvalidTypeColumns(
+                    InvalidTypeColumns(
                         wrong_type_columns=[col],
                         expected_types=["str", "int"],
                     )
@@ -3403,7 +3457,7 @@ class Validator:
             allowed_datatype = pa.string()
             if column_types[col] != allowed_datatype:
                 invalid_types += [
-                    err.InvalidTypeColumns(
+                    InvalidTypeColumns(
                         wrong_type_columns=[col],
                         expected_types=["str"],
                     )
@@ -3421,7 +3475,7 @@ class Validator:
             )
             if column_types[col] not in allowed_datatypes:
                 invalid_types += [
-                    err.InvalidTypeColumns(
+                    InvalidTypeColumns(
                         wrong_type_columns=[col],
                         expected_types=["list[float], np.array[float]"],
                     )
@@ -3436,7 +3490,7 @@ class Validator:
             )
             if column_types[col] not in allowed_datatypes:
                 invalid_types += [
-                    err.InvalidTypeColumns(
+                    InvalidTypeColumns(
                         wrong_type_columns=[col],
                         expected_types=["list[str]"],
                     )
@@ -3450,7 +3504,7 @@ class Validator:
             allowed_datatypes = (pa.string(),)
             if column_types[col] not in allowed_datatypes:
                 invalid_types += [
-                    err.InvalidTypeColumns(
+                    InvalidTypeColumns(
                         wrong_type_columns=[col],
                         expected_types=["str"],
                     )
@@ -3517,15 +3571,15 @@ def _check_value_raw_data_length_helper(
 
 def _check_value_bounding_boxes_coordinates_helper(
     coordinates_col: pd.Series,
-) -> err.InvalidBoundingBoxesCoordinates | None:
+) -> InvalidBoundingBoxesCoordinates | None:
     def check(boxes: object) -> None:
         # We allow for zero boxes. None coordinates list is not allowed (will break following tests:
         # 'NoneType is not iterable')
         if boxes is None:
-            raise err.InvalidBoundingBoxesCoordinates(reason="none_boxes")
+            raise InvalidBoundingBoxesCoordinates(reason="none_boxes")
         for box in boxes:
             if box is None or len(box) == 0:
-                raise err.InvalidBoundingBoxesCoordinates(
+                raise InvalidBoundingBoxesCoordinates(
                     reason="none_or_empty_box"
                 )
             error = _box_coordinates_wrong_format(box)
@@ -3534,14 +3588,14 @@ def _check_value_bounding_boxes_coordinates_helper(
 
     try:
         coordinates_col.apply(check)
-    except err.InvalidBoundingBoxesCoordinates as e:
+    except InvalidBoundingBoxesCoordinates as e:
         return e
     return None
 
 
 def _box_coordinates_wrong_format(
     box_coords: object,
-) -> err.InvalidBoundingBoxesCoordinates | None:
+) -> InvalidBoundingBoxesCoordinates | None:
     if (
         # Coordinates should be a collection of 4 floats
         len(box_coords) != 4
@@ -3552,7 +3606,7 @@ def _box_coordinates_wrong_format(
         # Coordinates represent the top-left & bottom-right corners of a box: y1 < y2
         or box_coords[1] >= box_coords[3]
     ):
-        return err.InvalidBoundingBoxesCoordinates(
+        return InvalidBoundingBoxesCoordinates(
             reason="boxes_coordinates_wrong_format"
         )
     return None
@@ -3560,51 +3614,47 @@ def _box_coordinates_wrong_format(
 
 def _check_value_bounding_boxes_categories_helper(
     categories_col: pd.Series,
-) -> err.InvalidBoundingBoxesCategories | None:
+) -> InvalidBoundingBoxesCategories | None:
     def check(categories: object) -> None:
         # We allow for zero boxes. None category list is not allowed (will break following tests:
         # 'NoneType is not iterable')
         if categories is None:
-            raise err.InvalidBoundingBoxesCategories(
-                reason="none_category_list"
-            )
+            raise InvalidBoundingBoxesCategories(reason="none_category_list")
         for category in categories:
             # Allow for empty string category, no None values
             if category is None:
-                raise err.InvalidBoundingBoxesCategories(reason="none_category")
+                raise InvalidBoundingBoxesCategories(reason="none_category")
 
     try:
         categories_col.apply(check)
-    except err.InvalidBoundingBoxesCategories as e:
+    except InvalidBoundingBoxesCategories as e:
         return e
     return None
 
 
 def _check_value_bounding_boxes_scores_helper(
     scores_col: pd.Series,
-) -> err.InvalidBoundingBoxesScores | None:
+) -> InvalidBoundingBoxesScores | None:
     def check(scores: object) -> None:
         # We allow for zero boxes. None confidence score list is not allowed (will break following tests:
         # 'NoneType is not iterable')
         if scores is None:
-            raise err.InvalidBoundingBoxesScores(reason="none_score_list")
+            raise InvalidBoundingBoxesScores(reason="none_score_list")
         for score in scores:
             # Confidence scores are between 0 and 1
             if score < 0 or score > 1:
-                raise err.InvalidBoundingBoxesScores(
-                    reason="scores_out_of_bounds"
-                )
+                raise InvalidBoundingBoxesScores(reason="scores_out_of_bounds")
 
     try:
         scores_col.apply(check)
-    except err.InvalidBoundingBoxesScores as e:
+    except InvalidBoundingBoxesScores as e:
         return e
     return None
 
 
 def _polygon_coordinates_wrong_format(
     polygon_coords: object,
-) -> err.InvalidPolygonCoordinates | None:
+) -> InvalidPolygonCoordinates | None:
     """Check if polygon coordinates are valid.
 
     Validates:
@@ -3629,7 +3679,7 @@ def _polygon_coordinates_wrong_format(
         # Coordinates should be a collection of pairs of floats
         or len(polygon_coords) % 2 != 0
     ):
-        return err.InvalidPolygonCoordinates(
+        return InvalidPolygonCoordinates(
             reason="polygon_coordinates_wrong_format",
             coordinates=polygon_coords,
         )
@@ -3644,7 +3694,7 @@ def _polygon_coordinates_wrong_format(
     for i in range(len(points)):
         for j in range(i + 1, len(points)):
             if points[i] == points[j]:
-                return err.InvalidPolygonCoordinates(
+                return InvalidPolygonCoordinates(
                     reason="polygon_coordinates_repeated_vertices",
                     coordinates=polygon_coords,
                 )
@@ -3665,7 +3715,7 @@ def _polygon_coordinates_wrong_format(
             if segments_intersect(
                 edges[i][0], edges[i][1], edges[j][0], edges[j][1]
             ):
-                return err.InvalidPolygonCoordinates(
+                return InvalidPolygonCoordinates(
                     reason="polygon_coordinates_self_intersecting_vertices",
                     coordinates=polygon_coords,
                 )
@@ -3675,64 +3725,62 @@ def _polygon_coordinates_wrong_format(
 
 def _check_value_polygon_coordinates_helper(
     coordinates_col: pd.Series,
-) -> err.InvalidPolygonCoordinates | None:
+) -> InvalidPolygonCoordinates | None:
     def check(polygons: object) -> None:
         # We allow for zero polygons. None coordinates list is not allowed (will break following tests:
         # 'NoneType is not iterable')
         if polygons is None:
-            raise err.InvalidPolygonCoordinates(reason="none_polygons")
+            raise InvalidPolygonCoordinates(reason="none_polygons")
         for polygon in polygons:
             if polygon is None or len(polygon) == 0:
-                raise err.InvalidPolygonCoordinates(
-                    reason="none_or_empty_polygon"
-                )
+                raise InvalidPolygonCoordinates(reason="none_or_empty_polygon")
             error = _polygon_coordinates_wrong_format(polygon)
             if error is not None:
                 raise error
 
     try:
         coordinates_col.apply(check)
-    except err.InvalidPolygonCoordinates as e:
+    except InvalidPolygonCoordinates as e:
         return e
     return None
 
 
 def _check_value_polygon_categories_helper(
     categories_col: pd.Series,
-) -> err.InvalidPolygonCategories | None:
+) -> InvalidPolygonCategories | None:
     def check(categories: object) -> None:
         # We allow for zero boxes. None category list is not allowed (will break following tests:
         # 'NoneType is not iterable')
         if categories is None:
-            raise err.InvalidPolygonCategories(reason="none_category_list")
+            raise InvalidPolygonCategories(reason="none_category_list")
         for category in categories:
             # Allow for empty string category, no None values
             if category is None:
-                raise err.InvalidPolygonCategories(reason="none_category")
+                raise InvalidPolygonCategories(reason="none_category")
 
     try:
         categories_col.apply(check)
-    except err.InvalidPolygonCategories as e:
+    except InvalidPolygonCategories as e:
         return e
     return None
 
 
 def _check_value_polygon_scores_helper(
     scores_col: pd.Series,
-) -> err.InvalidPolygonScores | None:
+) -> InvalidPolygonScores | None:
     def check(scores: object) -> None:
         # We allow for zero boxes. None confidence score list is not allowed (will break following tests:
         # 'NoneType is not iterable')
         if scores is None:
-            raise err.InvalidPolygonScores(reason="none_score_list")
+            raise InvalidPolygonScores(reason="none_score_list")
         for score in scores:
             # Confidence scores are between 0 and 1
             if score < 0 or score > 1:
-                raise err.InvalidPolygonScores(reason="scores_out_of_bounds")
+                raise InvalidPolygonScores(reason="scores_out_of_bounds")
 
     try:
         scores_col.apply(check)
-    except err.InvalidPolygonScores as e:
+    except InvalidPolygonScores as e:
         return e
     return None