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

arize/ml/batch_validation/validator.py

@@ -6,7 +6,10 @@ import logging
 import math
 from datetime import datetime, timedelta, timezone
 from itertools import chain
-from typing import Any
+from typing import TYPE_CHECKING, Any, cast
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
 
 import numpy as np
 import pandas as pd
@@ -39,8 +42,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,
@@ -53,6 +118,7 @@ from arize.ml.types import (
     ModelTypes,
     PromptTemplateColumnNames,
     Schema,
+    _normalize_column_names,
     segments_intersect,
 )
 from arize.utils.types import (
@@ -74,8 +140,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 +181,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 +289,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 +389,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
@@ -350,25 +416,25 @@ class Validator:
         if isinstance(schema, Schema):
             general_checks = chain(
                 general_checks,
-                Validator._check_value_timestamp(dataframe, schema),
-                Validator._check_id_field_str_length(
+                Validator._check_value_timestamp(dataframe, schema),  # type: ignore[arg-type]
+                Validator._check_id_field_str_length(  # type: ignore[arg-type]
                     dataframe,
                     "prediction_id_column_name",
                     schema.prediction_id_column_name,
                 ),
-                Validator._check_embedding_vectors_dimensionality(
+                Validator._check_embedding_vectors_dimensionality(  # type: ignore[arg-type]
                     dataframe, schema
                 ),
-                Validator._check_embedding_raw_data_characters(
+                Validator._check_embedding_raw_data_characters(  # type: ignore[arg-type]
                     dataframe, schema
                 ),
-                Validator._check_invalid_record_prod(
+                Validator._check_invalid_record_prod(  # type: ignore[arg-type]
                     dataframe, environment, schema, model_type
                 ),
-                Validator._check_invalid_record_preprod(
+                Validator._check_invalid_record_preprod(  # type: ignore[arg-type]
                     dataframe, environment, schema, model_type
                 ),
-                Validator._check_value_tag(dataframe, schema),
+                Validator._check_value_tag(dataframe, schema),  # type: ignore[arg-type]
             )
             if model_type == ModelTypes.RANKING:
                 r_checks = chain(
@@ -444,15 +510,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 +538,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]:
-        errors = []
+    ) -> list[InvalidFieldTypePromptResponse]:
+        errors: list[InvalidFieldTypePromptResponse] = []
         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 +609,7 @@ class Validator:
             )
         ):
             return [
-                err.InvalidTypeColumns(
+                InvalidTypeColumns(
                     wrong_type_columns=[col],
                     expected_types=[
                         "Dict[str, (bool, int, float, string or list[str])]"
@@ -557,9 +621,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 +635,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 +661,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 +670,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
                 )
             ]
@@ -619,7 +683,7 @@ class Validator:
         schema: Schema,
         required_columns_map: list[dict[str, Any]],
     ) -> tuple[bool, list[str], list[list[str]]]:
-        missing_columns = []
+        missing_columns: list[str] = []
         for item in required_columns_map:
             if model_type.name.lower() == item.get("external_model_type"):
                 is_valid_combination = False
@@ -674,7 +738,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 +747,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 +769,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 +782,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 = []
@@ -733,7 +797,9 @@ class Validator:
             missing_columns.extend(
                 [
                     col
-                    for col in schema.feature_column_names
+                    for col in _normalize_column_names(
+                        schema.feature_column_names
+                    )
                     if col not in existing_columns
                 ]
             )
@@ -768,7 +834,7 @@ class Validator:
             missing_columns.extend(
                 [
                     col
-                    for col in schema.tag_column_names
+                    for col in _normalize_column_names(schema.tag_column_names)
                     if col not in existing_columns
                 ]
             )
@@ -901,14 +967,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 +1024,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 +1044,7 @@ class Validator:
             schema, CorpusSchema
         ):
             return [
-                err.InvalidSchemaType(
+                InvalidSchemaType(
                     schema_type=str(type(schema)), environment=environment
                 )
             ]
@@ -987,26 +1053,23 @@ 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:
-            for col in schema.feature_column_names:
+            for col in _normalize_column_names(schema.feature_column_names):
                 if isinstance(col, str) and col.endswith("_shap"):
                     invalid_column_names.add(col)
 
         if schema.embedding_feature_column_names is not None:
             for emb_col_names in schema.embedding_feature_column_names.values():
-                for col in emb_col_names:
-                    if (
-                        col is not None
-                        and isinstance(col, str)
-                        and col.endswith("_shap")
-                    ):
+                cols_list = [c for c in emb_col_names if c is not None]
+                for col in cols_list:
+                    if col.endswith("_shap"):
                         invalid_column_names.add(col)
 
         if schema.tag_column_names is not None:
-            for col in schema.tag_column_names:
+            for col in _normalize_column_names(schema.tag_column_names):
                 if isinstance(col, str) and col.endswith("_shap"):
                     invalid_column_names.add(col)
 
@@ -1016,14 +1079,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 +1190,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 +1220,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 +1259,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 +1295,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 +1328,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 +1349,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 +1380,7 @@ class Validator:
                 "instance_segmentation_actual_column_names",
             ]
             return [
-                err.InvalidPredActColumnNamesForModelType(
+                InvalidPredActColumnNamesForModelType(
                     model_type, allowed_cols, wrong_cols
                 )
             ]
@@ -1326,7 +1389,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,9 +1397,9 @@ class Validator:
             and schema.multi_class_threshold_scores_column_name is not None
         ):
             return [
-                err.InvalidPredActColumnNamesForModelType(
+                InvalidPredActColumnNamesForModelType(
                     model_type,
-                    None,
+                    None,  # type: ignore[arg-type]
                     [schema.multi_class_threshold_scores_column_name],
                 )
             ]
@@ -1345,7 +1408,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 +1418,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,8 +1450,10 @@ class Validator:
                 "actual_score_column_name",
             ]
             return [
-                err.InvalidPredActColumnNamesForModelType(
-                    model_type, allowed_cols, wrong_cols
+                InvalidPredActColumnNamesForModelType(
+                    model_type,
+                    allowed_cols,
+                    wrong_cols,  # type: ignore[arg-type]
                 )
             ]
         return []
@@ -1397,17 +1462,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 +1490,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 +1506,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 +1526,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 +1539,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 +1550,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 +1566,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 +1577,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 = (
@@ -1529,13 +1594,13 @@ class Validator:
             )
             wrong_type_cols = [
                 col
-                for col in schema.feature_column_names
+                for col in _normalize_column_names(schema.feature_column_names)
                 if col in column_types
                 and column_types[col] not in allowed_datatypes
             ]
             if wrong_type_cols:
                 return [
-                    err.InvalidTypeFeatures(
+                    InvalidTypeFeatures(
                         wrong_type_cols,
                         expected_types=[
                             "float",
@@ -1551,7 +1616,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 +1664,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 +1692,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 = (
@@ -1643,13 +1708,13 @@ class Validator:
             )
             wrong_type_cols = [
                 col
-                for col in schema.tag_column_names
+                for col in _normalize_column_names(schema.tag_column_names)
                 if col in column_types
                 and column_types[col] not in allowed_datatypes
             ]
             if wrong_type_cols:
                 return [
-                    err.InvalidTypeTags(
+                    InvalidTypeTags(
                         wrong_type_cols, ["float", "int", "bool", "str"]
                     )
                 ]
@@ -1658,7 +1723,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 +1740,7 @@ class Validator:
             ]
             if wrong_type_cols:
                 return [
-                    err.InvalidTypeShapValues(
+                    InvalidTypeShapValues(
                         wrong_type_cols, expected_types=["float", "int"]
                     )
                 ]
@@ -1684,12 +1749,13 @@ 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),
             ("Actual labels", schema.actual_label_column_name),
         )
+        allowed_datatypes: tuple[Any, ...]
         if (
             model_type in CATEGORICAL_MODEL_TYPES
             or model_type == ModelTypes.GENERATIVE_LLM
@@ -1713,7 +1779,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 +1803,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 +1814,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 +1843,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 +1854,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 +1900,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 +1914,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 +1961,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 +1984,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 +2015,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 +2025,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 +2052,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 +2062,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 []
 
@@ -2011,10 +2077,8 @@ class Validator:
         )
         wrong_type_cols = []
         if schema.tag_column_names:
-            if (
-                LLM_RUN_METADATA_TOTAL_TOKEN_COUNT_TAG_NAME
-                in schema.tag_column_names
-            ) and (
+            tag_cols = _normalize_column_names(schema.tag_column_names)
+            if (LLM_RUN_METADATA_TOTAL_TOKEN_COUNT_TAG_NAME in tag_cols) and (
                 LLM_RUN_METADATA_TOTAL_TOKEN_COUNT_TAG_NAME in column_types
                 and column_types[LLM_RUN_METADATA_TOTAL_TOKEN_COUNT_TAG_NAME]
                 not in allowed_datatypes
@@ -2022,10 +2086,7 @@ class Validator:
                 wrong_type_cols.append(
                     schema.llm_run_metadata_column_names.total_token_count_column_name
                 )
-            if (
-                LLM_RUN_METADATA_PROMPT_TOKEN_COUNT_TAG_NAME
-                in schema.tag_column_names
-            ) and (
+            if (LLM_RUN_METADATA_PROMPT_TOKEN_COUNT_TAG_NAME in tag_cols) and (
                 LLM_RUN_METADATA_PROMPT_TOKEN_COUNT_TAG_NAME in column_types
                 and column_types[LLM_RUN_METADATA_PROMPT_TOKEN_COUNT_TAG_NAME]
                 not in allowed_datatypes
@@ -2034,8 +2095,7 @@ class Validator:
                     schema.llm_run_metadata_column_names.prompt_token_count_column_name
                 )
             if (
-                LLM_RUN_METADATA_RESPONSE_TOKEN_COUNT_TAG_NAME
-                in schema.tag_column_names
+                LLM_RUN_METADATA_RESPONSE_TOKEN_COUNT_TAG_NAME in tag_cols
             ) and (
                 LLM_RUN_METADATA_RESPONSE_TOKEN_COUNT_TAG_NAME in column_types
                 and column_types[LLM_RUN_METADATA_RESPONSE_TOKEN_COUNT_TAG_NAME]
@@ -2044,10 +2104,7 @@ class Validator:
                 wrong_type_cols.append(
                     schema.llm_run_metadata_column_names.response_token_count_column_name
                 )
-            if (
-                LLM_RUN_METADATA_RESPONSE_LATENCY_MS_TAG_NAME
-                in schema.tag_column_names
-            ) and (
+            if (LLM_RUN_METADATA_RESPONSE_LATENCY_MS_TAG_NAME in tag_cols) and (
                 LLM_RUN_METADATA_RESPONSE_LATENCY_MS_TAG_NAME in column_types
                 and column_types[LLM_RUN_METADATA_RESPONSE_LATENCY_MS_TAG_NAME]
                 not in allowed_datatypes
@@ -2059,8 +2116,8 @@ class Validator:
             # Return errors if there are any
             if wrong_type_cols:
                 return [
-                    err.InvalidTypeColumns(
-                        wrong_type_columns=wrong_type_cols,
+                    InvalidTypeColumns(
+                        wrong_type_columns=wrong_type_cols,  # type: ignore[arg-type]
                         expected_types=["int", "float"],
                     )
                 ]
@@ -2069,7 +2126,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 +2136,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 +2147,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 +2230,7 @@ class Validator:
 
         return (
             [
-                err.InvalidTypeColumns(
+                InvalidTypeColumns(
                     wrong_type_columns=wrong_type_cols,
                     expected_types=["List[List[float]]"],
                 )
@@ -2185,7 +2242,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 +2299,7 @@ class Validator:
 
         return (
             [
-                err.InvalidTypeColumns(
+                InvalidTypeColumns(
                     wrong_type_columns=wrong_type_cols,
                     expected_types=["List[str]"],
                 )
@@ -2254,7 +2311,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 +2354,7 @@ class Validator:
 
         return (
             [
-                err.InvalidTypeColumns(
+                InvalidTypeColumns(
                     wrong_type_columns=wrong_type_cols,
                     expected_types=["List[float]"],
                 )
@@ -2313,7 +2370,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 +2388,7 @@ class Validator:
 
         return (
             [
-                err.InvalidValueEmbeddingVectorDimensionality(
+                InvalidValueEmbeddingVectorDimensionality(
                     invalid_low_dim_vector_cols,
                     invalid_high_dim_vector_cols,
                 ),
@@ -2343,7 +2400,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 +2418,7 @@ class Validator:
 
         if invalid_long_string_data_cols:
             return [
-                err.InvalidValueEmbeddingRawDataTooLong(
+                InvalidValueEmbeddingRawDataTooLong(
                     invalid_long_string_data_cols
                 )
             ]
@@ -2377,20 +2434,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 +2469,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 +2481,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 +2503,7 @@ class Validator:
             .all()
         ):
             return [
-                err.InvalidStringLengthInColumn(
+                InvalidStringLengthInColumn(
                     schema_name=schema_name,
                     col_name=id_col_name,
                     min_length=MIN_DOCUMENT_ID_LEN,
@@ -2465,7 +2522,7 @@ class Validator:
             and len(dataframe)
         ):
             return True
-        return (
+        return bool(
             dataframe[col_name]
             .astype(str)
             .str.len()
@@ -2476,21 +2533,21 @@ 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 []
 
         wrong_tag_cols = []
         truncated_tag_cols = []
-        for col in schema.tag_column_names:
+        for col in _normalize_column_names(schema.tag_column_names):
             # This is to be defensive, validate_params should guarantee that this column is in
             # the dataframe, via _check_missing_columns, and return an error before reaching this
             # block if not
             # Checks max tag length when any values in a column are strings
             if (
                 col in dataframe.columns
-                and dataframe[col].map(type).eq(str).any()
-            ):  # type:ignore
+                and dataframe[col].map(type).eq(str).any()  # type: ignore[arg-type]
+            ):
                 max_tag_len = (
                     dataframe[col]
                     .apply(_check_value_string_length_helper)
@@ -2501,7 +2558,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 +2570,8 @@ class Validator:
     @staticmethod
     def _check_value_ranking_category(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> list[err.InvalidValueMissingValue | err.InvalidRankingCategoryValue]:
+    ) -> list[InvalidValueMissingValue | InvalidRankingCategoryValue]:
+        col: str | None
         if schema.relevance_labels_column_name is not None:
             col = schema.relevance_labels_column_name
         elif schema.attributions_column_name is not None:
@@ -2521,16 +2579,16 @@ class Validator:
         else:
             col = schema.actual_label_column_name
         if col is not None and col in dataframe.columns:
-            if dataframe[col].isnull().values.any():  # type: ignore
+            if dataframe[col].isnull().any():
                 # do not attach duplicated missing value error
                 # 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 +2596,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 +2633,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.
 
@@ -2601,7 +2659,11 @@ class Validator:
         invalid_pred_scores = {}
         lbound, ubound = (0, 1)
         invalid_actual_scores = False
-        errors = []
+        errors: list[
+            InvalidMultiClassClassNameLength
+            | InvalidMultiClassActScoreValue
+            | InvalidMultiClassPredScoreValue
+        ] = []
         for col in cols:
             if (
                 col is None
@@ -2649,21 +2711,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))  # type: ignore[arg-type]
         if invalid_actual_scores:
-            errors.append(err.InvalidMultiClassActScoreValue(col))
+            errors.append(InvalidMultiClassActScoreValue(col))  # type: ignore[arg-type, arg-type]
         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 +2745,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 +2755,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.
@@ -2706,11 +2764,9 @@ class Validator:
             # When a timestamp column has Date and NaN, pyarrow will be fine, but
             # pandas min/max will fail due to type incompatibility. So we check for
             # missing value first.
-            if dataframe[col].isnull().values.any():  # type: ignore
+            if dataframe[col].isnull().any():
                 return [
-                    err.InvalidValueMissingValue(
-                        "Prediction timestamp", "missing"
-                    )
+                    InvalidValueMissingValue("Prediction timestamp", "missing")
                 ]
 
             now_t = datetime.now(tz=timezone.utc)
@@ -2794,7 +2850,7 @@ class Validator:
                     )
                 )
             ):
-                return [err.InvalidValueTimestamp(timestamp_col_name=col)]
+                return [InvalidValueTimestamp(timestamp_col_name=col)]
 
         return []
 
@@ -2803,9 +2859,9 @@ class Validator:
     @staticmethod
     def _check_invalid_missing_values(
         dataframe: pd.DataFrame, schema: BaseSchema, model_type: ModelTypes
-    ) -> list[err.InvalidValueMissingValue]:
+    ) -> list[InvalidValueMissingValue]:
         errors = []
-        columns = ()
+        columns: tuple[tuple[str, str | None], ...] = ()
         if isinstance(schema, CorpusSchema):
             columns = (("Document ID", schema.document_id_column_name),)
         elif isinstance(schema, Schema):
@@ -2824,7 +2880,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 +2890,7 @@ class Validator:
                     and np.isinf(dataframe[col]).any()
                 ):
                     errors.append(
-                        err.InvalidValueMissingValue(
+                        InvalidValueMissingValue(
                             name, wrong_values="infinite", column=col
                         )
                     )
@@ -2850,7 +2906,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 +2950,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 +2998,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 +3006,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 +3020,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[arg-type]
 
     @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 +3038,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 +3049,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 +3060,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 +3071,8 @@ class Validator:
     @staticmethod
     def _check_type_ranking_category(
         schema: Schema, column_types: dict[str, Any]
-    ) -> list[err.InvalidType]:
+    ) -> list[InvalidType]:
+        col: str | None
         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 +3083,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 +3094,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 +3115,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 +3136,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 +3161,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 +3182,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 +3203,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 +3224,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 +3245,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 +3260,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 +3283,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):
@@ -3262,16 +3319,16 @@ class Validator:
             dataframe, vector_cols_to_check
         )
 
-        errors = []
+        errors: list[ValidationError] = []
         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(  # type: ignore[arg-type]
                     invalid_low_dim_vector_cols,
                     invalid_high_dim_vector_cols,
                 )
@@ -3291,7 +3348,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 +3358,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 +3376,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 +3386,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 +3405,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 +3415,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,8 +3434,9 @@ class Validator:
     @staticmethod
     def _check_type_document_columns(
         schema: CorpusSchema, column_types: dict[str, Any]
-    ) -> list[err.InvalidTypeColumns]:
+    ) -> list[InvalidTypeColumns]:
         invalid_types = []
+        allowed_datatypes: tuple[Any, ...]
         # Check document id
         col = schema.document_id_column_name
         if col in column_types:
@@ -3391,7 +3449,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 +3461,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 +3479,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 +3494,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 +3508,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 +3575,16 @@ 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")
-        for box in boxes:
+            raise InvalidBoundingBoxesCoordinates(reason="none_boxes")
+        # Type ignore: boxes comes from pandas Series, validated at runtime to be iterable
+        for box in boxes:  # type: ignore[attr-defined]
             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,25 +3593,26 @@ 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
+        len(box_coords) != 4  # type: ignore[arg-type]
         # Coordinates should be positive
-        or any(k < 0 for k in box_coords)
+        # Type ignore: box_coords validated at runtime to be iterable/indexable
+        or any(k < 0 for k in box_coords)  # type: ignore[attr-defined]
         # Coordinates represent the top-left & bottom-right corners of a box: x1 < x2
-        or box_coords[0] >= box_coords[2]
+        or box_coords[0] >= box_coords[2]  # type: ignore[index]
         # Coordinates represent the top-left & bottom-right corners of a box: y1 < y2
-        or box_coords[1] >= box_coords[3]
+        or box_coords[1] >= box_coords[3]  # type: ignore[index]
     ):
-        return err.InvalidBoundingBoxesCoordinates(
+        return InvalidBoundingBoxesCoordinates(
             reason="boxes_coordinates_wrong_format"
         )
     return None
@@ -3560,51 +3620,49 @@ 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"
-            )
-        for category in categories:
+            raise InvalidBoundingBoxesCategories(reason="none_category_list")
+        # Type ignore: categories validated at runtime to be iterable
+        for category in categories:  # type: ignore[attr-defined]
             # 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")
-        for score in scores:
+            raise InvalidBoundingBoxesScores(reason="none_score_list")
+        # Type ignore: scores validated at runtime to be iterable
+        for score in scores:  # type: ignore[attr-defined]
             # 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:
@@ -3623,30 +3681,31 @@ def _polygon_coordinates_wrong_format(
     # Basic validations
     if (
         # Coordinates should be a collection of more than 6 floats (3 pairs of x,y coordinates)
-        len(polygon_coords) < 6
+        len(polygon_coords) < 6  # type: ignore[arg-type]
         # Coordinates should be positive
-        or any(k < 0 for k in polygon_coords)
+        # Type ignore: polygon_coords validated at runtime to be iterable
+        or any(k < 0 for k in polygon_coords)  # type: ignore[arg-type, attr-defined]
         # Coordinates should be a collection of pairs of floats
-        or len(polygon_coords) % 2 != 0
+        or len(polygon_coords) % 2 != 0  # type: ignore[arg-type]
     ):
-        return err.InvalidPolygonCoordinates(
+        return InvalidPolygonCoordinates(
             reason="polygon_coordinates_wrong_format",
-            coordinates=polygon_coords,
+            coordinates=polygon_coords,  # type: ignore[arg-type]
         )
 
     # Convert flat list to list of points [(x1,y1), (x2,y2), ...]
+    coords_seq = cast("Sequence[float]", polygon_coords)
     points = [
-        (polygon_coords[i], polygon_coords[i + 1])
-        for i in range(0, len(polygon_coords), 2)
+        (coords_seq[i], coords_seq[i + 1]) for i in range(0, len(coords_seq), 2)
     ]
 
     # Check for repeated vertices
     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,
+                    coordinates=polygon_coords,  # type: ignore[arg-type]
                 )
 
     # Check for self-intersections
@@ -3665,9 +3724,9 @@ 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,
+                    coordinates=polygon_coords,  # type: ignore[arg-type]
                 )
 
     return None
@@ -3675,64 +3734,65 @@ 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")
-        for polygon in polygons:
+            raise InvalidPolygonCoordinates(reason="none_polygons")
+        # Type ignore: polygons validated at runtime to be iterable
+        for polygon in polygons:  # type: ignore[attr-defined]
             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")
-        for category in categories:
+            raise InvalidPolygonCategories(reason="none_category_list")
+        # Type ignore: categories validated at runtime to be iterable
+        for category in categories:  # type: ignore[attr-defined]
             # 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")
-        for score in scores:
+            raise InvalidPolygonScores(reason="none_score_list")
+        # Type ignore: scores validated at runtime to be iterable
+        for score in scores:  # type: ignore[attr-defined]
             # 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