arize 8.0.0a22__py3-none-any.whl → 8.0.0b0__py3-none-any.whl

arize/{models → ml}/batch_validation/validator.py

@@ -1,12 +1,15 @@
+"""Batch validation logic for ML model predictions and actuals."""
+
 from __future__ import annotations
 
-import datetime
 import logging
 import math
+from datetime import datetime, timedelta, timezone
 from itertools import chain
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
+from typing import Any
 
 import numpy as np
+import pandas as pd
 import pyarrow as pa
 
 from arize.constants.ml import (
@@ -37,8 +40,8 @@ from arize.constants.ml import (
     MODEL_MAPPING_CONFIG,
 )
 from arize.logging import get_truncation_warning_message
-from arize.models.batch_validation import errors as err
-from arize.types import (
+from arize.ml.batch_validation import errors as err
+from arize.ml.types import (
     CATEGORICAL_MODEL_TYPES,
     NUMERIC_MODEL_TYPES,
     BaseSchema,
@@ -50,28 +53,29 @@ from arize.types import (
     ModelTypes,
     PromptTemplateColumnNames,
     Schema,
+    segments_intersect,
+)
+from arize.utils.types import (
     is_dict_of,
     is_iterable_of,
-    segments_intersect,
 )
 
-if TYPE_CHECKING:
-    import pandas as pd
-
-
 logger = logging.getLogger(__name__)
 
 
 class Validator:
+    """Validator for batch data with schema and dataframe validation methods."""
+
     @staticmethod
     def validate_required_checks(
         dataframe: pd.DataFrame,
         model_id: str,
         environment: Environments,
         schema: BaseSchema,
-        model_version: Optional[str] = None,
-        batch_id: Optional[str] = None,
-    ) -> List[err.ValidationError]:
+        model_version: str | None = None,
+        batch_id: str | None = None,
+    ) -> list[err.ValidationError]:
+        """Validate required checks for schema, environment, and DataFrame structure."""
         general_checks = chain(
             Validator._check_valid_schema_type(schema, environment),
             Validator._check_field_convertible_to_str(
@@ -87,7 +91,7 @@ class Validator:
             schema, CorpusSchema
         ):
             return list(general_checks)
-        elif isinstance(schema, Schema):
+        if isinstance(schema, Schema):
             return list(
                 chain(
                     general_checks,
@@ -108,10 +112,11 @@ class Validator:
         model_type: ModelTypes,
         environment: Environments,
         schema: BaseSchema,
-        metric_families: Optional[List[Metrics]] = None,
-        model_version: Optional[str] = None,
-        batch_id: Optional[str] = None,
-    ) -> List[err.ValidationError]:
+        metric_families: list[Metrics] | None = None,
+        model_version: str | None = None,
+        batch_id: str | None = None,
+    ) -> list[err.ValidationError]:
+        """Validate parameters including model type, environment, and schema consistency."""
         # general checks
         general_checks = chain(
             Validator._check_column_names_for_empty_strings(schema),
@@ -125,7 +130,7 @@ class Validator:
         )
         if isinstance(schema, CorpusSchema):
             return list(general_checks)
-        elif isinstance(schema, Schema):
+        if isinstance(schema, Schema):
             general_checks = chain(
                 general_checks,
                 Validator._check_existence_prediction_id_column_delayed_schema(
@@ -153,7 +158,7 @@ class Validator:
                     ),
                 )
                 return list(chain(general_checks, num_checks))
-            elif model_type in CATEGORICAL_MODEL_TYPES:
+            if model_type in CATEGORICAL_MODEL_TYPES:
                 sc_checks = chain(
                     Validator._check_existence_preprod_pred_act_score_or_label(
                         schema, environment
@@ -166,7 +171,7 @@ class Validator:
                     ),
                 )
                 return list(chain(general_checks, sc_checks))
-            elif model_type == ModelTypes.GENERATIVE_LLM:
+            if model_type == ModelTypes.GENERATIVE_LLM:
                 gllm_checks = chain(
                     Validator._check_existence_preprod_act(schema, environment),
                     Validator._check_missing_object_detection_columns(
@@ -177,7 +182,7 @@ class Validator:
                     ),
                 )
                 return list(chain(general_checks, gllm_checks))
-            elif model_type == ModelTypes.RANKING:
+            if model_type == ModelTypes.RANKING:
                 r_checks = chain(
                     Validator._check_existence_group_id_rank_category_relevance(
                         schema
@@ -190,7 +195,7 @@ class Validator:
                     ),
                 )
                 return list(chain(general_checks, r_checks))
-            elif model_type == ModelTypes.OBJECT_DETECTION:
+            if model_type == ModelTypes.OBJECT_DETECTION:
                 od_checks = chain(
                     Validator._check_exactly_one_cv_column_type(
                         schema, environment
@@ -203,7 +208,7 @@ class Validator:
                     ),
                 )
                 return list(chain(general_checks, od_checks))
-            elif model_type == ModelTypes.MULTI_CLASS:
+            if model_type == ModelTypes.MULTI_CLASS:
                 multi_class_checks = chain(
                     Validator._check_existing_multi_class_columns(schema),
                     Validator._check_missing_non_multi_class_columns(
@@ -218,8 +223,11 @@ class Validator:
         model_type: ModelTypes,
         schema: BaseSchema,
         pyarrow_schema: pa.Schema,
-    ) -> List[err.ValidationError]:
-        column_types = dict(zip(pyarrow_schema.names, pyarrow_schema.types))
+    ) -> list[err.ValidationError]:
+        """Validate column data types against expected types for the schema."""
+        column_types = dict(
+            zip(pyarrow_schema.names, pyarrow_schema.types, strict=True)
+        )
 
         if isinstance(schema, CorpusSchema):
             return list(
@@ -227,7 +235,7 @@ class Validator:
                     Validator._check_type_document_columns(schema, column_types)
                 )
             )
-        elif isinstance(schema, Schema):
+        if isinstance(schema, Schema):
             general_checks = chain(
                 Validator._check_type_prediction_id(schema, column_types),
                 Validator._check_type_timestamp(schema, column_types),
@@ -271,7 +279,7 @@ class Validator:
                     ),
                 )
                 return list(chain(general_checks, gllm_checks))
-            elif model_type == ModelTypes.RANKING:
+            if model_type == ModelTypes.RANKING:
                 r_checks = chain(
                     Validator._check_type_prediction_group_id(
                         schema, column_types
@@ -285,7 +293,7 @@ class Validator:
                     ),
                 )
                 return list(chain(general_checks, r_checks))
-            elif model_type == ModelTypes.OBJECT_DETECTION:
+            if model_type == ModelTypes.OBJECT_DETECTION:
                 od_checks = chain(
                     Validator._check_type_image_segment_coordinates(
                         schema, column_types
@@ -298,7 +306,7 @@ class Validator:
                     ),
                 )
                 return list(chain(general_checks, od_checks))
-            elif model_type == ModelTypes.MULTI_CLASS:
+            if model_type == ModelTypes.MULTI_CLASS:
                 multi_class_checks = chain(
                     Validator._check_type_multi_class_pred_threshold_act_scores(
                         schema, column_types
@@ -315,7 +323,8 @@ class Validator:
         environment: Environments,
         schema: BaseSchema,
         model_type: ModelTypes,
-    ) -> List[err.ValidationError]:
+    ) -> list[err.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
         # or are of the wrong types.
@@ -338,7 +347,7 @@ class Validator:
                     ),
                 )
             )
-        elif isinstance(schema, Schema):
+        if isinstance(schema, Schema):
             general_checks = chain(
                 general_checks,
                 Validator._check_value_timestamp(dataframe, schema),
@@ -429,21 +438,21 @@ class Validator:
             return list(general_checks)
         return []
 
-    # ----------------------
-    # Minimum requred checks
-    # ----------------------
+    # -----------------------
+    # Minimum required checks
+    # -----------------------
     @staticmethod
     def _check_column_names_for_empty_strings(
         schema: BaseSchema,
-    ) -> List[err.InvalidColumnNameEmptyString]:
+    ) -> list[err.InvalidColumnNameEmptyString]:
         if "" in schema.get_used_columns():
             return [err.InvalidColumnNameEmptyString()]
         return []
 
     @staticmethod
     def _check_field_convertible_to_str(
-        model_id, model_version, batch_id
-    ) -> List[err.InvalidFieldTypeConversion]:
+        model_id: object, model_version: object, batch_id: object
+    ) -> list[err.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):
@@ -469,7 +478,7 @@ class Validator:
     @staticmethod
     def _check_field_type_embedding_features_column_names(
         schema: Schema,
-    ) -> List[err.InvalidFieldTypeEmbeddingFeatures]:
+    ) -> list[err.InvalidFieldTypeEmbeddingFeatures]:
         if schema.embedding_feature_column_names is not None:
             if not isinstance(schema.embedding_feature_column_names, dict):
                 return [err.InvalidFieldTypeEmbeddingFeatures()]
@@ -483,7 +492,7 @@ class Validator:
     @staticmethod
     def _check_field_type_prompt_response(
         schema: Schema,
-    ) -> List[err.InvalidFieldTypePromptResponse]:
+    ) -> list[err.InvalidFieldTypePromptResponse]:
         errors = []
         if schema.prompt_column_names is not None and not isinstance(
             schema.prompt_column_names, (str, EmbeddingColumnNames)
@@ -502,7 +511,7 @@ class Validator:
     @staticmethod
     def _check_field_type_prompt_templates(
         schema: Schema,
-    ) -> List[err.InvalidFieldTypePromptTemplates]:
+    ) -> list[err.InvalidFieldTypePromptTemplates]:
         if schema.prompt_template_column_names is not None and not isinstance(
             schema.prompt_template_column_names, PromptTemplateColumnNames
         ):
@@ -513,7 +522,7 @@ class Validator:
     def _check_field_type_llm_config(
         dataframe: pd.DataFrame,
         schema: Schema,
-    ) -> List[Union[err.InvalidFieldTypeLlmConfig, err.InvalidTypeColumns]]:
+    ) -> list[err.InvalidFieldTypeLlmConfig | err.InvalidTypeColumns]:
         if schema.llm_config_column_names is None:
             return []
         if not isinstance(schema.llm_config_column_names, LLMConfigColumnNames):
@@ -548,7 +557,7 @@ class Validator:
     @staticmethod
     def _check_invalid_index(
         dataframe: pd.DataFrame,
-    ) -> List[err.InvalidDataFrameIndex]:
+    ) -> list[err.InvalidDataFrameIndex]:
         if (dataframe.index != dataframe.reset_index(drop=True).index).any():
             return [err.InvalidDataFrameIndex()]
         return []
@@ -560,9 +569,9 @@ class Validator:
     @staticmethod
     def _check_model_type_and_metrics(
         model_type: ModelTypes,
-        metric_families: Optional[List[Metrics]],
+        metric_families: list[Metrics] | None,
         schema: Schema,
-    ) -> List[err.ValidationError]:
+    ) -> list[err.ValidationError]:
         if metric_families is None:
             return []
 
@@ -606,10 +615,10 @@ class Validator:
     @staticmethod
     def _check_model_mapping_combinations(
         model_type: ModelTypes,
-        metric_families: List[Metrics],
+        metric_families: list[Metrics],
         schema: Schema,
-        required_columns_map: List[Dict[str, Any]],
-    ) -> Tuple[bool, List[str], List[List[str]]]:
+        required_columns_map: list[dict[str, Any]],
+    ) -> tuple[bool, list[str], list[list[str]]]:
         missing_columns = []
         for item in required_columns_map:
             if model_type.name.lower() == item.get("external_model_type"):
@@ -625,10 +634,10 @@ class Validator:
                             metric_combinations.append(
                                 [metric.upper() for metric in metrics_list]
                             )
-                            if set(metrics_list) == set(
+                            if set(metrics_list) == {
                                 metric_family.name.lower()
                                 for metric_family in metric_families
-                            ):
+                            }:
                                 # This is a valid combination of model type + metrics.
                                 # Now validate that required columns are in the schema.
                                 is_valid_combination = True
@@ -665,10 +674,10 @@ class Validator:
     @staticmethod
     def _check_existence_prediction_id_column_delayed_schema(
         schema: Schema, model_type: ModelTypes
-    ) -> List[err.MissingPredictionIdColumnForDelayedRecords]:
+    ) -> list[err.MissingPredictionIdColumnForDelayedRecords]:
         if schema.prediction_id_column_name is not None:
             return []
-        # TODO: Revise logic once predicion_label column addition (for generative models)
+        # TODO: Revise logic once prediction_label column addition (for generative models)
         # is moved to beginning of log function
         if schema.is_delayed() and model_type is not ModelTypes.GENERATIVE_LLM:
             # We skip GENERATIVE model types since they are assigned a default
@@ -696,12 +705,12 @@ class Validator:
     def _check_missing_columns(
         dataframe: pd.DataFrame,
         schema: BaseSchema,
-    ) -> List[err.MissingColumns]:
+    ) -> list[err.MissingColumns]:
         if isinstance(schema, CorpusSchema):
             return Validator._check_missing_columns_corpus_schema(
                 dataframe, schema
             )
-        elif isinstance(schema, Schema):
+        if isinstance(schema, Schema):
             return Validator._check_missing_columns_schema(dataframe, schema)
         return []
 
@@ -709,7 +718,7 @@ class Validator:
     def _check_missing_columns_schema(
         dataframe: pd.DataFrame,
         schema: Schema,
-    ) -> List[err.MissingColumns]:
+    ) -> list[err.MissingColumns]:
         # converting to a set first makes the checks run a lot faster
         existing_columns = set(dataframe.columns)
         missing_columns = []
@@ -721,9 +730,13 @@ class Validator:
                     missing_columns.append(col)
 
         if schema.feature_column_names is not None:
-            for col in schema.feature_column_names:
-                if col not in existing_columns:
-                    missing_columns.append(col)
+            missing_columns.extend(
+                [
+                    col
+                    for col in schema.feature_column_names
+                    if col not in existing_columns
+                ]
+            )
 
         if schema.embedding_feature_column_names is not None:
             for (
@@ -752,44 +765,76 @@ class Validator:
                     )
 
         if schema.tag_column_names is not None:
-            for col in schema.tag_column_names:
-                if col not in existing_columns:
-                    missing_columns.append(col)
+            missing_columns.extend(
+                [
+                    col
+                    for col in schema.tag_column_names
+                    if col not in existing_columns
+                ]
+            )
 
         if schema.shap_values_column_names is not None:
-            for col in schema.shap_values_column_names.values():
-                if col not in existing_columns:
-                    missing_columns.append(col)
+            missing_columns.extend(
+                [
+                    col
+                    for col in schema.shap_values_column_names.values()
+                    if col not in existing_columns
+                ]
+            )
 
         if schema.object_detection_prediction_column_names is not None:
-            for col in schema.object_detection_prediction_column_names:
-                if col is not None and col not in existing_columns:
-                    missing_columns.append(col)
+            missing_columns.extend(
+                [
+                    col
+                    for col in schema.object_detection_prediction_column_names
+                    if col is not None and col not in existing_columns
+                ]
+            )
 
         if schema.object_detection_actual_column_names is not None:
-            for col in schema.object_detection_actual_column_names:
-                if col is not None and col not in existing_columns:
-                    missing_columns.append(col)
+            missing_columns.extend(
+                [
+                    col
+                    for col in schema.object_detection_actual_column_names
+                    if col is not None and col not in existing_columns
+                ]
+            )
 
         if schema.semantic_segmentation_prediction_column_names is not None:
-            for col in schema.semantic_segmentation_prediction_column_names:
-                if col is not None and col not in existing_columns:
-                    missing_columns.append(col)
+            missing_columns.extend(
+                [
+                    col
+                    for col in schema.semantic_segmentation_prediction_column_names
+                    if col is not None and col not in existing_columns
+                ]
+            )
 
         if schema.semantic_segmentation_actual_column_names is not None:
-            for col in schema.semantic_segmentation_actual_column_names:
-                if col is not None and col not in existing_columns:
-                    missing_columns.append(col)
+            missing_columns.extend(
+                [
+                    col
+                    for col in schema.semantic_segmentation_actual_column_names
+                    if col is not None and col not in existing_columns
+                ]
+            )
 
         if schema.instance_segmentation_prediction_column_names is not None:
-            for col in schema.instance_segmentation_prediction_column_names:
-                if col is not None and col not in existing_columns:
-                    missing_columns.append(col)
+            missing_columns.extend(
+                [
+                    col
+                    for col in schema.instance_segmentation_prediction_column_names
+                    if col is not None and col not in existing_columns
+                ]
+            )
 
         if schema.instance_segmentation_actual_column_names is not None:
-            for col in schema.instance_segmentation_actual_column_names:
-                if col is not None and col not in existing_columns:
-                    missing_columns.append(col)
+            missing_columns.extend(
+                [
+                    col
+                    for col in schema.instance_segmentation_actual_column_names
+                    if col is not None and col not in existing_columns
+                ]
+            )
 
         if schema.prompt_column_names is not None:
             if isinstance(schema.prompt_column_names, str):
@@ -838,14 +883,22 @@ class Validator:
                     )
 
         if schema.prompt_template_column_names is not None:
-            for col in schema.prompt_template_column_names:
-                if col is not None and col not in existing_columns:
-                    missing_columns.append(col)
+            missing_columns.extend(
+                [
+                    col
+                    for col in schema.prompt_template_column_names
+                    if col is not None and col not in existing_columns
+                ]
+            )
 
         if schema.llm_config_column_names is not None:
-            for col in schema.llm_config_column_names:
-                if col is not None and col not in existing_columns:
-                    missing_columns.append(col)
+            missing_columns.extend(
+                [
+                    col
+                    for col in schema.llm_config_column_names
+                    if col is not None and col not in existing_columns
+                ]
+            )
 
         if missing_columns:
             return [err.MissingColumns(missing_columns)]
@@ -855,7 +908,7 @@ class Validator:
     def _check_missing_columns_corpus_schema(
         dataframe: pd.DataFrame,
         schema: CorpusSchema,
-    ) -> List[err.MissingColumns]:
+    ) -> list[err.MissingColumns]:
         # converting to a set first makes the checks run a lot faster
         existing_columns = set(dataframe.columns)
         missing_columns = []
@@ -912,7 +965,7 @@ class Validator:
     def _check_valid_schema_type(
         schema: BaseSchema,
         environment: Environments,
-    ) -> List[err.InvalidSchemaType]:
+    ) -> list[err.InvalidSchemaType]:
         if environment == Environments.CORPUS and not (
             isinstance(schema, CorpusSchema)
         ):
@@ -934,7 +987,7 @@ class Validator:
     @staticmethod
     def _check_invalid_shap_suffix(
         schema: Schema,
-    ) -> List[err.InvalidShapSuffix]:
+    ) -> list[err.InvalidShapSuffix]:
         invalid_column_names = set()
 
         if schema.feature_column_names is not None:
@@ -970,10 +1023,10 @@ class Validator:
     def _check_reserved_columns(
         schema: BaseSchema,
         model_type: ModelTypes,
-    ) -> List[err.ReservedColumns]:
+    ) -> list[err.ReservedColumns]:
         if isinstance(schema, CorpusSchema):
             return []
-        elif isinstance(schema, Schema):
+        if isinstance(schema, Schema):
             reserved_columns = []
             column_counts = schema.get_used_columns_counts()
             if model_type == ModelTypes.GENERATIVE_LLM:
@@ -1079,8 +1132,8 @@ class Validator:
 
     @staticmethod
     def _check_invalid_model_id(
-        model_id: Optional[str],
-    ) -> List[err.InvalidModelId]:
+        model_id: str | None,
+    ) -> list[err.InvalidModelId]:
         # assume it's been coerced to string beforehand
         if (not isinstance(model_id, str)) or len(model_id.strip()) == 0:
             return [err.InvalidModelId()]
@@ -1088,8 +1141,8 @@ class Validator:
 
     @staticmethod
     def _check_invalid_model_version(
-        model_version: Optional[str] = None,
-    ) -> List[err.InvalidModelVersion]:
+        model_version: str | None = None,
+    ) -> list[err.InvalidModelVersion]:
         if model_version is None:
             return []
         if (
@@ -1102,9 +1155,9 @@ class Validator:
 
     @staticmethod
     def _check_invalid_batch_id(
-        batch_id: Optional[str],
+        batch_id: str | None,
         environment: Environments,
-    ) -> List[err.InvalidBatchId]:
+    ) -> list[err.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
@@ -1115,7 +1168,7 @@ class Validator:
     @staticmethod
     def _check_invalid_model_type(
         model_type: ModelTypes,
-    ) -> List[err.InvalidModelType]:
+    ) -> list[err.InvalidModelType]:
         if model_type in (mt for mt in ModelTypes):
             return []
         return [err.InvalidModelType()]
@@ -1123,7 +1176,7 @@ class Validator:
     @staticmethod
     def _check_invalid_environment(
         environment: Environments,
-    ) -> List[err.InvalidEnvironment]:
+    ) -> list[err.InvalidEnvironment]:
         if environment in (env for env in Environments):
             return []
         return [err.InvalidEnvironment()]
@@ -1132,7 +1185,7 @@ class Validator:
     def _check_existence_preprod_pred_act_score_or_label(
         schema: Schema,
         environment: Environments,
-    ) -> List[err.MissingPreprodPredActNumericAndCategorical]:
+    ) -> list[err.MissingPreprodPredActNumericAndCategorical]:
         if environment in (Environments.VALIDATION, Environments.TRAINING) and (
             (
                 schema.prediction_label_column_name is None
@@ -1149,7 +1202,7 @@ class Validator:
     @staticmethod
     def _check_exactly_one_cv_column_type(
         schema: Schema, environment: Environments
-    ) -> List[Union[err.MultipleCVPredAct, err.MissingCVPredAct]]:
+    ) -> list[err.MultipleCVPredAct | err.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.
@@ -1180,7 +1233,7 @@ class Validator:
 
             if cv_types_count == 0:
                 return [err.MissingCVPredAct(environment)]
-            elif cv_types_count > 1:
+            if cv_types_count > 1:
                 return [err.MultipleCVPredAct(environment)]
 
         elif environment in (
@@ -1213,7 +1266,7 @@ class Validator:
 
             if cv_types_count == 0:
                 return [err.MissingCVPredAct(environment)]
-            elif cv_types_count > 1:
+            if cv_types_count > 1:
                 return [err.MultipleCVPredAct(environment)]
 
         return []
@@ -1221,9 +1274,9 @@ class Validator:
     @staticmethod
     def _check_missing_object_detection_columns(
         schema: Schema, model_type: ModelTypes
-    ) -> List[err.InvalidPredActCVColumnNamesForModelType]:
+    ) -> list[err.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 prediciton/actual
+        # object detection, semantic segmentation, or instance segmentation dedicated prediction/actual
         # column names
         if (
             schema.object_detection_prediction_column_names is not None
@@ -1239,7 +1292,7 @@ class Validator:
     @staticmethod
     def _check_missing_non_object_detection_columns(
         schema: Schema, model_type: ModelTypes
-    ) -> List[err.InvalidPredActColumnNamesForModelType]:
+    ) -> list[err.InvalidPredActColumnNamesForModelType]:
         # Checks that object detection models don't have, in the schema, the columns reserved for
         # other model types
         columns_to_check = (
@@ -1253,10 +1306,7 @@ class Validator:
             schema.relevance_score_column_name,
             schema.relevance_labels_column_name,
         )
-        wrong_cols = []
-        for col in columns_to_check:
-            if col is not None:
-                wrong_cols.append(col)
+        wrong_cols = [col for col in columns_to_check if col is not None]
         if wrong_cols:
             allowed_cols = [
                 "object_detection_prediction_column_names",
@@ -1276,7 +1326,7 @@ class Validator:
     @staticmethod
     def _check_missing_multi_class_columns(
         schema: Schema, model_type: ModelTypes
-    ) -> List[err.InvalidPredActColumnNamesForModelType]:
+    ) -> list[err.InvalidPredActColumnNamesForModelType]:
         # Checks that models that are not Multi Class models don't have, in the schema, the
         # multi class dedicated threshold column
         if (
@@ -1295,7 +1345,7 @@ class Validator:
     @staticmethod
     def _check_existing_multi_class_columns(
         schema: Schema,
-    ) -> List[err.MissingReqPredActColumnNamesForMultiClass]:
+    ) -> list[err.MissingReqPredActColumnNamesForMultiClass]:
         # Checks that models that are Multi Class models have, in the schema, the
         # required prediction score or actual score columns
         if (
@@ -1311,7 +1361,7 @@ class Validator:
     @staticmethod
     def _check_missing_non_multi_class_columns(
         schema: Schema, model_type: ModelTypes
-    ) -> List[err.InvalidPredActColumnNamesForModelType]:
+    ) -> list[err.InvalidPredActColumnNamesForModelType]:
         # Checks that multi class models don't have, in the schema, the columns reserved for
         # other model types
         columns_to_check = (
@@ -1329,10 +1379,7 @@ class Validator:
             schema.instance_segmentation_prediction_column_names,
             schema.instance_segmentation_actual_column_names,
         )
-        wrong_cols = []
-        for col in columns_to_check:
-            if col is not None:
-                wrong_cols.append(col)
+        wrong_cols = [col for col in columns_to_check if col is not None]
         if wrong_cols:
             allowed_cols = [
                 "prediction_score_column_name",
@@ -1350,7 +1397,7 @@ class Validator:
     def _check_existence_preprod_act(
         schema: Schema,
         environment: Environments,
-    ) -> List[err.MissingPreprodAct]:
+    ) -> list[err.MissingPreprodAct]:
         if environment in (Environments.VALIDATION, Environments.TRAINING) and (
             schema.actual_label_column_name is None
         ):
@@ -1360,7 +1407,7 @@ class Validator:
     @staticmethod
     def _check_existence_group_id_rank_category_relevance(
         schema: Schema,
-    ) -> List[err.MissingRequiredColumnsForRankingModel]:
+    ) -> list[err.MissingRequiredColumnsForRankingModel]:
         # prediction_group_id and rank columns are required as ranking prediction columns.
         ranking_prediction_cols = (
             schema.prediction_label_column_name,
@@ -1384,7 +1431,7 @@ class Validator:
     @staticmethod
     def _check_dataframe_for_duplicate_columns(
         schema: BaseSchema, dataframe: pd.DataFrame
-    ) -> List[err.DuplicateColumnsInDataframe]:
+    ) -> list[err.DuplicateColumnsInDataframe]:
         # Get the columns used in the schema
         schema_col_used = schema.get_used_columns()
         # Get the duplicated column names from the dataframe
@@ -1400,7 +1447,7 @@ class Validator:
     @staticmethod
     def _check_invalid_number_of_embeddings(
         schema: Schema,
-    ) -> List[err.InvalidNumberOfEmbeddings]:
+    ) -> list[err.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:
@@ -1413,8 +1460,8 @@ class Validator:
 
     @staticmethod
     def _check_type_prediction_id(
-        schema: Schema, column_types: Dict[str, Any]
-    ) -> List[err.InvalidType]:
+        schema: Schema, column_types: dict[str, Any]
+    ) -> list[err.InvalidType]:
         col = schema.prediction_id_column_name
         if col in column_types:
             # should mirror server side
@@ -1437,8 +1484,8 @@ class Validator:
 
     @staticmethod
     def _check_type_timestamp(
-        schema: Schema, column_types: Dict[str, Any]
-    ) -> List[err.InvalidType]:
+        schema: Schema, column_types: dict[str, Any]
+    ) -> list[err.InvalidType]:
         col = schema.timestamp_column_name
         if col in column_types:
             # should mirror server side
@@ -1464,8 +1511,8 @@ class Validator:
 
     @staticmethod
     def _check_type_features(
-        schema: Schema, column_types: Dict[str, Any]
-    ) -> List[err.InvalidTypeFeatures]:
+        schema: Schema, column_types: dict[str, Any]
+    ) -> list[err.InvalidTypeFeatures]:
         if schema.feature_column_names is not None:
             # should mirror server side
             allowed_datatypes = (
@@ -1480,13 +1527,12 @@ class Validator:
                 pa.null(),
                 pa.list_(pa.string()),
             )
-            wrong_type_cols = []
-            for col in schema.feature_column_names:
-                if (
-                    col in column_types
-                    and column_types[col] not in allowed_datatypes
-                ):
-                    wrong_type_cols.append(col)
+            wrong_type_cols = [
+                col
+                for col in schema.feature_column_names
+                if col in column_types
+                and column_types[col] not in allowed_datatypes
+            ]
             if wrong_type_cols:
                 return [
                     err.InvalidTypeFeatures(
@@ -1504,8 +1550,8 @@ class Validator:
 
     @staticmethod
     def _check_type_embedding_features(
-        schema: Schema, column_types: Dict[str, Any]
-    ) -> List[err.InvalidTypeFeatures]:
+        schema: Schema, column_types: dict[str, Any]
+    ) -> list[err.InvalidTypeFeatures]:
         if schema.embedding_feature_column_names is not None:
             # should mirror server side
             allowed_vector_datatypes = (
@@ -1580,8 +1626,8 @@ class Validator:
 
     @staticmethod
     def _check_type_tags(
-        schema: Schema, column_types: Dict[str, Any]
-    ) -> List[err.InvalidTypeTags]:
+        schema: Schema, column_types: dict[str, Any]
+    ) -> list[err.InvalidTypeTags]:
         if schema.tag_column_names is not None:
             # should mirror server side
             allowed_datatypes = (
@@ -1595,13 +1641,12 @@ class Validator:
                 pa.int8(),
                 pa.null(),
             )
-            wrong_type_cols = []
-            for col in schema.tag_column_names:
-                if (
-                    col in column_types
-                    and column_types[col] not in allowed_datatypes
-                ):
-                    wrong_type_cols.append(col)
+            wrong_type_cols = [
+                col
+                for col in schema.tag_column_names
+                if col in column_types
+                and column_types[col] not in allowed_datatypes
+            ]
             if wrong_type_cols:
                 return [
                     err.InvalidTypeTags(
@@ -1612,8 +1657,8 @@ class Validator:
 
     @staticmethod
     def _check_type_shap_values(
-        schema: Schema, column_types: Dict[str, Any]
-    ) -> List[err.InvalidTypeShapValues]:
+        schema: Schema, column_types: dict[str, Any]
+    ) -> list[err.InvalidTypeShapValues]:
         if schema.shap_values_column_names is not None:
             # should mirror server side
             allowed_datatypes = (
@@ -1622,13 +1667,12 @@ class Validator:
                 pa.float32(),
                 pa.int32(),
             )
-            wrong_type_cols = []
-            for _, col in schema.shap_values_column_names.items():
-                if (
-                    col in column_types
-                    and column_types[col] not in allowed_datatypes
-                ):
-                    wrong_type_cols.append(col)
+            wrong_type_cols = [
+                col
+                for col in schema.shap_values_column_names.values()
+                if col in column_types
+                and column_types[col] not in allowed_datatypes
+            ]
             if wrong_type_cols:
                 return [
                     err.InvalidTypeShapValues(
@@ -1639,8 +1683,8 @@ class Validator:
 
     @staticmethod
     def _check_type_pred_act_labels(
-        model_type: ModelTypes, schema: Schema, column_types: Dict[str, Any]
-    ) -> List[err.InvalidType]:
+        model_type: ModelTypes, schema: Schema, column_types: dict[str, Any]
+    ) -> list[err.InvalidType]:
         errors = []
         columns = (
             ("Prediction labels", schema.prediction_label_column_name),
@@ -1703,8 +1747,8 @@ class Validator:
 
     @staticmethod
     def _check_type_pred_act_scores(
-        model_type: ModelTypes, schema: Schema, column_types: Dict[str, Any]
-    ) -> List[err.InvalidType]:
+        model_type: ModelTypes, schema: Schema, column_types: dict[str, Any]
+    ) -> list[err.InvalidType]:
         errors = []
         columns = (
             ("Prediction scores", schema.prediction_score_column_name),
@@ -1743,13 +1787,14 @@ class Validator:
 
     @staticmethod
     def _check_type_multi_class_pred_threshold_act_scores(
-        schema: Schema, column_types: Dict[str, Any]
-    ) -> List[err.InvalidType]:
-        """
-        Check type for prediction / threshold / actual scores for multiclass model
-        Expect the scores to be a list of pyarrow structs that contains field "class_name" and field "score
-        Where class_name is a string and score is a number
-        Example: '[{"class_name": "class1", "score": 0.1}, {"class_name": "class2", "score": 0.2}, ...]'
+        schema: Schema, column_types: dict[str, Any]
+    ) -> list[err.InvalidType]:
+        """Check type for prediction / threshold / actual scores for multiclass model.
+
+        Expect the scores to be a list of pyarrow structs that contains field
+        "class_name" and field "score", where class_name is a string and score
+        is a number.
+        Example: '[{"class_name": "class1", "score": 0.1}, ...]'
         """
         errors = []
         columns = (
@@ -1802,8 +1847,8 @@ class Validator:
 
     @staticmethod
     def _check_type_prompt_response(
-        schema: Schema, column_types: Dict[str, Any]
-    ) -> List[err.InvalidTypeColumns]:
+        schema: Schema, column_types: dict[str, Any]
+    ) -> list[err.InvalidTypeColumns]:
         fields_to_check = []
         if schema.prompt_column_names is not None:
             fields_to_check.append(schema.prompt_column_names)
@@ -1872,8 +1917,8 @@ class Validator:
 
     @staticmethod
     def _check_type_llm_prompt_templates(
-        schema: Schema, column_types: Dict[str, Any]
-    ) -> List[err.InvalidTypeColumns]:
+        schema: Schema, column_types: dict[str, Any]
+    ) -> list[err.InvalidTypeColumns]:
         if schema.prompt_template_column_names is None:
             return []
 
@@ -1913,8 +1958,8 @@ class Validator:
 
     @staticmethod
     def _check_type_llm_config(
-        schema: Schema, column_types: Dict[str, Any]
-    ) -> List[err.InvalidTypeColumns]:
+        schema: Schema, column_types: dict[str, Any]
+    ) -> list[err.InvalidTypeColumns]:
         if schema.llm_config_column_names is None:
             return []
 
@@ -1950,8 +1995,8 @@ class Validator:
 
     @staticmethod
     def _check_type_llm_run_metadata(
-        schema: Schema, column_types: Dict[str, Any]
-    ) -> List[err.InvalidTypeColumns]:
+        schema: Schema, column_types: dict[str, Any]
+    ) -> list[err.InvalidTypeColumns]:
         if schema.llm_run_metadata_column_names is None:
             return []
 
@@ -2023,8 +2068,8 @@ class Validator:
 
     @staticmethod
     def _check_type_retrieved_document_ids(
-        schema: Schema, column_types: Dict[str, Any]
-    ) -> List[err.InvalidType]:
+        schema: Schema, column_types: dict[str, Any]
+    ) -> list[err.InvalidType]:
         col = schema.retrieved_document_ids_column_name
         if col in column_types:
             # should mirror server side
@@ -2044,8 +2089,8 @@ class Validator:
 
     @staticmethod
     def _check_type_image_segment_coordinates(
-        schema: Schema, column_types: Dict[str, Any]
-    ) -> List[err.InvalidTypeColumns]:
+        schema: Schema, column_types: dict[str, Any]
+    ) -> list[err.InvalidTypeColumns]:
         # should mirror server side
         allowed_coordinate_types = (
             pa.list_(pa.list_(pa.float64())),
@@ -2090,9 +2135,8 @@ class Validator:
                 wrong_type_cols.append(coord_col)
 
         if schema.instance_segmentation_prediction_column_names is not None:
-            polygons_coord_col = (
-                schema.instance_segmentation_prediction_column_names.polygon_coordinates_column_name  # noqa: E501
-            )
+            inst_seg_pred = schema.instance_segmentation_prediction_column_names
+            polygons_coord_col = inst_seg_pred.polygon_coordinates_column_name
             if (
                 polygons_coord_col in column_types
                 and column_types[polygons_coord_col]
@@ -2101,7 +2145,7 @@ class Validator:
                 wrong_type_cols.append(polygons_coord_col)
 
             bbox_coord_col = (
-                schema.instance_segmentation_prediction_column_names.bounding_boxes_coordinates_column_name  # noqa: E501
+                inst_seg_pred.bounding_boxes_coordinates_column_name
             )
             if (
                 bbox_coord_col in column_types
@@ -2110,9 +2154,8 @@ class Validator:
                 wrong_type_cols.append(bbox_coord_col)
 
         if schema.instance_segmentation_actual_column_names is not None:
-            coord_col = (
-                schema.instance_segmentation_actual_column_names.polygon_coordinates_column_name  # noqa: E501
-            )
+            inst_seg_actual = schema.instance_segmentation_actual_column_names
+            coord_col = inst_seg_actual.polygon_coordinates_column_name
             if (
                 coord_col in column_types
                 and column_types[coord_col] not in allowed_coordinate_types
@@ -2120,7 +2163,7 @@ class Validator:
                 wrong_type_cols.append(coord_col)
 
             bbox_coord_col = (
-                schema.instance_segmentation_actual_column_names.bounding_boxes_coordinates_column_name  # noqa: E501
+                inst_seg_actual.bounding_boxes_coordinates_column_name
             )
             if (
                 bbox_coord_col in column_types
@@ -2141,8 +2184,8 @@ class Validator:
 
     @staticmethod
     def _check_type_image_segment_categories(
-        schema: Schema, column_types: Dict[str, Any]
-    ) -> List[err.InvalidTypeColumns]:
+        schema: Schema, column_types: dict[str, Any]
+    ) -> list[err.InvalidTypeColumns]:
         # should mirror server side
         allowed_category_datatypes = (
             pa.list_(pa.string()),
@@ -2210,8 +2253,8 @@ class Validator:
 
     @staticmethod
     def _check_type_image_segment_scores(
-        schema: Schema, column_types: Dict[str, Any]
-    ) -> List[err.InvalidTypeColumns]:
+        schema: Schema, column_types: dict[str, Any]
+    ) -> list[err.InvalidTypeColumns]:
         # should mirror server side
         allowed_score_datatypes = (
             pa.list_(pa.float64()),
@@ -2270,7 +2313,7 @@ class Validator:
     @staticmethod
     def _check_embedding_vectors_dimensionality(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> List[err.ValidationError]:
+    ) -> list[err.ValidationError]:
         if schema.embedding_feature_column_names is None:
             return []
 
@@ -2300,7 +2343,7 @@ class Validator:
     @staticmethod
     def _check_embedding_raw_data_characters(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> List[err.ValidationError]:
+    ) -> list[err.ValidationError]:
         if schema.embedding_feature_column_names is None:
             return []
 
@@ -2322,7 +2365,7 @@ class Validator:
                     invalid_long_string_data_cols
                 )
             ]
-        elif truncated_long_string_data_cols:
+        if truncated_long_string_data_cols:
             logger.warning(
                 get_truncation_warning_message(
                     "Embedding raw data fields",
@@ -2334,7 +2377,7 @@ class Validator:
     @staticmethod
     def _check_value_rank(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> List[err.InvalidRankValue]:
+    ) -> list[err.InvalidRankValue]:
         col = schema.rank_column_name
         lbound, ubound = (1, 100)
 
@@ -2346,11 +2389,11 @@ class Validator:
 
     @staticmethod
     def _check_id_field_str_length(
-        dataframe: pd.DataFrame, schema_name: str, id_col_name: Optional[str]
-    ) -> List[err.ValidationError]:
-        """
-        Require prediction_id to be a string of length between MIN_PREDICTION_ID_LEN
-        and MAX_PREDICTION_ID_LEN
+        dataframe: pd.DataFrame, schema_name: str, id_col_name: str | None
+    ) -> list[err.ValidationError]:
+        """Require prediction_id to be a string of length between MIN and MAX.
+
+        Between MIN_PREDICTION_ID_LEN and MAX_PREDICTION_ID_LEN.
         """
         # We check whether the column name can be None is allowed in `Validator.validate_params`
         if id_col_name is None:
@@ -2380,11 +2423,11 @@ class Validator:
 
     @staticmethod
     def _check_document_id_field_str_length(
-        dataframe: pd.DataFrame, schema_name: str, id_col_name: Optional[str]
-    ) -> List[err.ValidationError]:
-        """
-        Require document id to be a string of length between MIN_DOCUMENT_ID_LEN
-        and MAX_DOCUMENT_ID_LEN
+        dataframe: pd.DataFrame, schema_name: str, id_col_name: str | None
+    ) -> list[err.ValidationError]:
+        """Require document id to be a string of length between MIN and MAX.
+
+        Between MIN_DOCUMENT_ID_LEN and MAX_DOCUMENT_ID_LEN.
         """
         # We check whether the column name can be None is allowed in `Validator.validate_params`
         if id_col_name is None:
@@ -2433,7 +2476,7 @@ class Validator:
     @staticmethod
     def _check_value_tag(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> List[err.InvalidTagLength]:
+    ) -> list[err.InvalidTagLength]:
         if schema.tag_column_names is None:
             return []
 
@@ -2459,7 +2502,7 @@ class Validator:
                     truncated_tag_cols.append(col)
         if wrong_tag_cols:
             return [err.InvalidTagLength(wrong_tag_cols)]
-        elif truncated_tag_cols:
+        if truncated_tag_cols:
             logger.warning(
                 get_truncation_warning_message(
                     "tags", MAX_TAG_LENGTH_TRUNCATION
@@ -2470,9 +2513,7 @@ class Validator:
     @staticmethod
     def _check_value_ranking_category(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> List[
-        Union[err.InvalidValueMissingValue, err.InvalidRankingCategoryValue]
-    ]:
+    ) -> list[err.InvalidValueMissingValue | err.InvalidRankingCategoryValue]:
         if schema.relevance_labels_column_name is not None:
             col = schema.relevance_labels_column_name
         elif schema.attributions_column_name is not None:
@@ -2503,7 +2544,7 @@ class Validator:
     @staticmethod
     def _check_length_multi_class_maps(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> List[err.InvalidNumClassesMultiClassMap]:
+    ) -> list[err.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 = {}
@@ -2540,15 +2581,13 @@ class Validator:
     @staticmethod
     def _check_classes_and_scores_values_in_multi_class_maps(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> List[
-        Union[
-            err.InvalidMultiClassClassNameLength,
-            err.InvalidMultiClassActScoreValue,
-            err.InvalidMultiClassPredScoreValue,
-        ]
+    ) -> list[
+        err.InvalidMultiClassClassNameLength
+        | err.InvalidMultiClassActScoreValue
+        | err.InvalidMultiClassPredScoreValue
     ]:
-        """
-        Validate the class names and score values of dictionaries:
+        """Validate the class names and score values of dictionaries.
+
         - class name length
         - valid actual score
         - valid prediction / threshold score
@@ -2624,11 +2663,12 @@ class Validator:
     @staticmethod
     def _check_each_multi_class_pred_has_threshold(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> List[err.InvalidMultiClassThresholdClasses]:
-        """
-        For Multi Class, if threshold scores col is included in schema and dataframe,
-        validate for each prediction score received, the associated threshold score
-        for that class was received
+    ) -> list[err.InvalidMultiClassThresholdClasses]:
+        """Validate threshold scores for Multi Class models.
+
+        If threshold scores column is included in schema and dataframe, validate that
+        for each prediction score received, the associated threshold score for that
+        class was also received.
         """
         threshold_col = schema.multi_class_threshold_scores_column_name
         if threshold_col is None:
@@ -2657,10 +2697,10 @@ class Validator:
     def _check_value_timestamp(
         dataframe: pd.DataFrame,
         schema: Schema,
-    ) -> List[Union[err.InvalidValueMissingValue, err.InvalidValueTimestamp]]:
+    ) -> list[err.InvalidValueMissingValue | err.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 suceeeds but the same check on server side fails.
+        # result, i.e. the check here succeeds but the same check on server side fails.
         col = schema.timestamp_column_name
         if col is not None and col in dataframe.columns:
             # When a timestamp column has Date and NaN, pyarrow will be fine, but
@@ -2673,19 +2713,15 @@ class Validator:
                     )
                 ]
 
-            now_t = datetime.datetime.now()
+            now_t = datetime.now(tz=timezone.utc)
             lbound, ubound = (
                 (
                     now_t
-                    - datetime.timedelta(
-                        days=MAX_PAST_YEARS_FROM_CURRENT_TIME * 365
-                    )
+                    - timedelta(days=MAX_PAST_YEARS_FROM_CURRENT_TIME * 365)
                 ).timestamp(),
                 (
                     now_t
-                    + datetime.timedelta(
-                        days=MAX_FUTURE_YEARS_FROM_CURRENT_TIME * 365
-                    )
+                    + timedelta(days=MAX_FUTURE_YEARS_FROM_CURRENT_TIME * 365)
                 ).timestamp(),
             )
             # faster than pyarrow compute
@@ -2767,7 +2803,7 @@ class Validator:
     @staticmethod
     def _check_invalid_missing_values(
         dataframe: pd.DataFrame, schema: BaseSchema, model_type: ModelTypes
-    ) -> List[err.InvalidValueMissingValue]:
+    ) -> list[err.InvalidValueMissingValue]:
         errors = []
         columns = ()
         if isinstance(schema, CorpusSchema):
@@ -2814,7 +2850,7 @@ class Validator:
         environment: Environments,
         schema: Schema,
         model_type: ModelTypes,
-    ) -> List[err.InvalidRecord]:
+    ) -> list[err.InvalidRecord]:
         if environment in (Environments.VALIDATION, Environments.TRAINING):
             return []
 
@@ -2858,11 +2894,11 @@ class Validator:
         environment: Environments,
         schema: Schema,
         model_type: ModelTypes,
-    ) -> List[err.InvalidRecord]:
-        """
-        Validates there's not a single row in the dataframe with pred_label, pred_score all
-        evaluates to null OR with actual_label, actual_score all evaluates to null and returns
-        errors if either of the two cases exists
+    ) -> list[err.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
+        null, OR all of actual_label and actual_score evaluating to null.
         """
         if environment == Environments.PRODUCTION:
             return []
@@ -2905,21 +2941,23 @@ class Validator:
 
     @staticmethod
     def _check_invalid_record_helper(
-        dataframe: pd.DataFrame, column_names: List[Optional[str]]
-    ) -> List[err.InvalidRecord]:
-        """
-        This function checks that there are no null values in a subset of columns,
-        returning an error if so. The column subset is computed from the input list of
-        columns `column_names` that are not None and that are present in the dataframe
+        dataframe: pd.DataFrame, column_names: list[str | None]
+    ) -> list[err.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`
+        that are not None and that are present in the dataframe. Returns an error if
+        null values are found.
 
         Returns:
             List[err.InvalidRecord]: An error expressing the rows that are problematic
 
         """
-        columns_subset = []
-        for col in column_names:
-            if col is not None and col in dataframe.columns:
-                columns_subset.append(col)
+        columns_subset = [
+            col
+            for col in column_names
+            if col is not None and col in dataframe.columns
+        ]
         if len(columns_subset) == 0:
             return []
         null_filter = dataframe[columns_subset].isnull().all(axis=1)
@@ -2930,8 +2968,8 @@ class Validator:
 
     @staticmethod
     def _check_type_prediction_group_id(
-        schema: Schema, column_types: Dict[str, Any]
-    ) -> List[err.InvalidType]:
+        schema: Schema, column_types: dict[str, Any]
+    ) -> list[err.InvalidType]:
         col = schema.prediction_group_id_column_name
         if col in column_types:
             # should mirror server side
@@ -2954,8 +2992,8 @@ class Validator:
 
     @staticmethod
     def _check_type_rank(
-        schema: Schema, column_types: Dict[str, Any]
-    ) -> List[err.InvalidType]:
+        schema: Schema, column_types: dict[str, Any]
+    ) -> list[err.InvalidType]:
         col = schema.rank_column_name
         if col in column_types:
             allowed_datatypes = (
@@ -2976,8 +3014,8 @@ class Validator:
 
     @staticmethod
     def _check_type_ranking_category(
-        schema: Schema, column_types: Dict[str, Any]
-    ) -> List[err.InvalidType]:
+        schema: Schema, column_types: dict[str, Any]
+    ) -> list[err.InvalidType]:
         if schema.relevance_labels_column_name is not None:
             col = schema.relevance_labels_column_name
         elif schema.attributions_column_name is not None:
@@ -2999,7 +3037,7 @@ class Validator:
     @staticmethod
     def _check_value_bounding_boxes_coordinates(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> List[err.InvalidBoundingBoxesCoordinates]:
+    ) -> list[err.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
@@ -3020,7 +3058,7 @@ class Validator:
     @staticmethod
     def _check_value_bounding_boxes_categories(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> List[err.InvalidBoundingBoxesCategories]:
+    ) -> list[err.InvalidBoundingBoxesCategories]:
         errors = []
         if schema.object_detection_prediction_column_names is not None:
             cat_col_name = schema.object_detection_prediction_column_names.categories_column_name
@@ -3041,7 +3079,7 @@ class Validator:
     @staticmethod
     def _check_value_bounding_boxes_scores(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> List[err.InvalidBoundingBoxesScores]:
+    ) -> list[err.InvalidBoundingBoxesScores]:
         errors = []
         if schema.object_detection_prediction_column_names is not None:
             sc_col_name = schema.object_detection_prediction_column_names.scores_column_name
@@ -3066,7 +3104,7 @@ class Validator:
     @staticmethod
     def _check_value_semantic_segmentation_polygon_coordinates(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> List[err.InvalidPolygonCoordinates]:
+    ) -> list[err.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
@@ -3076,7 +3114,7 @@ class Validator:
             if error is not None:
                 errors.append(error)
         if schema.semantic_segmentation_actual_column_names is not None:
-            coords_col_name = schema.semantic_segmentation_actual_column_names.polygon_coordinates_column_name  # noqa: E501
+            coords_col_name = schema.semantic_segmentation_actual_column_names.polygon_coordinates_column_name
             error = _check_value_polygon_coordinates_helper(
                 dataframe[coords_col_name]
             )
@@ -3087,7 +3125,7 @@ class Validator:
     @staticmethod
     def _check_value_semantic_segmentation_polygon_categories(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> List[err.InvalidPolygonCategories]:
+    ) -> list[err.InvalidPolygonCategories]:
         errors = []
         if schema.semantic_segmentation_prediction_column_names is not None:
             cat_col_name = schema.semantic_segmentation_prediction_column_names.categories_column_name
@@ -3108,7 +3146,7 @@ class Validator:
     @staticmethod
     def _check_value_instance_segmentation_polygon_coordinates(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> List[err.InvalidPolygonCoordinates]:
+    ) -> list[err.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
@@ -3118,7 +3156,7 @@ class Validator:
             if error is not None:
                 errors.append(error)
         if schema.instance_segmentation_actual_column_names is not None:
-            coords_col_name = schema.instance_segmentation_actual_column_names.polygon_coordinates_column_name  # noqa: E501
+            coords_col_name = schema.instance_segmentation_actual_column_names.polygon_coordinates_column_name
             error = _check_value_polygon_coordinates_helper(
                 dataframe[coords_col_name]
             )
@@ -3129,7 +3167,7 @@ class Validator:
     @staticmethod
     def _check_value_instance_segmentation_polygon_categories(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> List[err.InvalidPolygonCategories]:
+    ) -> list[err.InvalidPolygonCategories]:
         errors = []
         if schema.instance_segmentation_prediction_column_names is not None:
             cat_col_name = schema.instance_segmentation_prediction_column_names.categories_column_name
@@ -3150,7 +3188,7 @@ class Validator:
     @staticmethod
     def _check_value_instance_segmentation_polygon_scores(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> List[err.InvalidPolygonScores]:
+    ) -> list[err.InvalidPolygonScores]:
         errors = []
         if schema.instance_segmentation_prediction_column_names is not None:
             sc_col_name = schema.instance_segmentation_prediction_column_names.scores_column_name
@@ -3165,7 +3203,7 @@ class Validator:
     @staticmethod
     def _check_value_instance_segmentation_bbox_coordinates(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> List[err.InvalidBoundingBoxesCoordinates]:
+    ) -> list[err.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
@@ -3188,7 +3226,7 @@ class Validator:
     @staticmethod
     def _check_value_prompt_response(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> List[err.ValidationError]:
+    ) -> list[err.ValidationError]:
         vector_cols_to_check = []
         text_cols_to_check = []
         if isinstance(schema.prompt_column_names, str):
@@ -3253,7 +3291,7 @@ class Validator:
     @staticmethod
     def _check_value_llm_model_name(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> List[err.InvalidStringLengthInColumn]:
+    ) -> list[err.InvalidStringLengthInColumn]:
         if schema.llm_config_column_names is None:
             return []
         col = schema.llm_config_column_names.model_column_name
@@ -3270,7 +3308,7 @@ class Validator:
                         max_length=MAX_LLM_MODEL_NAME_LENGTH,
                     )
                 ]
-            elif max_len > MAX_LLM_MODEL_NAME_LENGTH_TRUNCATION:
+            if max_len > MAX_LLM_MODEL_NAME_LENGTH_TRUNCATION:
                 logger.warning(
                     get_truncation_warning_message(
                         "LLM model names", MAX_LLM_MODEL_NAME_LENGTH_TRUNCATION
@@ -3281,7 +3319,7 @@ class Validator:
     @staticmethod
     def _check_value_llm_prompt_template(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> List[err.InvalidStringLengthInColumn]:
+    ) -> list[err.InvalidStringLengthInColumn]:
         if schema.prompt_template_column_names is None:
             return []
         col = schema.prompt_template_column_names.template_column_name
@@ -3298,7 +3336,7 @@ class Validator:
                         max_length=MAX_PROMPT_TEMPLATE_LENGTH,
                     )
                 ]
-            elif max_len > MAX_PROMPT_TEMPLATE_LENGTH_TRUNCATION:
+            if max_len > MAX_PROMPT_TEMPLATE_LENGTH_TRUNCATION:
                 logger.warning(
                     get_truncation_warning_message(
                         "prompt templates",
@@ -3310,7 +3348,7 @@ class Validator:
     @staticmethod
     def _check_value_llm_prompt_template_version(
         dataframe: pd.DataFrame, schema: Schema
-    ) -> List[err.InvalidStringLengthInColumn]:
+    ) -> list[err.InvalidStringLengthInColumn]:
         if schema.prompt_template_column_names is None:
             return []
         col = schema.prompt_template_column_names.template_version_column_name
@@ -3327,7 +3365,7 @@ class Validator:
                         max_length=MAX_PROMPT_TEMPLATE_VERSION_LENGTH,
                     )
                 ]
-            elif max_len > MAX_PROMPT_TEMPLATE_VERSION_LENGTH_TRUNCATION:
+            if max_len > MAX_PROMPT_TEMPLATE_VERSION_LENGTH_TRUNCATION:
                 logger.warning(
                     get_truncation_warning_message(
                         "prompt template versions",
@@ -3338,8 +3376,8 @@ class Validator:
 
     @staticmethod
     def _check_type_document_columns(
-        schema: CorpusSchema, column_types: Dict[str, Any]
-    ) -> List[err.InvalidTypeColumns]:
+        schema: CorpusSchema, column_types: dict[str, Any]
+    ) -> list[err.InvalidTypeColumns]:
         invalid_types = []
         # Check document id
         col = schema.document_id_column_name
@@ -3424,16 +3462,15 @@ class Validator:
         return []
 
 
-def _check_value_string_length_helper(x):
+def _check_value_string_length_helper(x: object) -> int:
     if isinstance(x, str):
         return len(x)
-    else:
-        return 0
+    return 0
 
 
 def _check_value_vector_dimensionality_helper(
-    dataframe: pd.DataFrame, cols_to_check: List[str]
-) -> Tuple[List[str], List[str]]:
+    dataframe: pd.DataFrame, cols_to_check: list[str]
+) -> tuple[list[str], list[str]]:
     invalid_low_dimensionality_vector_cols = []
     invalid_high_dimensionality_vector_cols = []
     for col in cols_to_check:
@@ -3452,8 +3489,8 @@ def _check_value_vector_dimensionality_helper(
 
 
 def _check_value_raw_data_length_helper(
-    dataframe: pd.DataFrame, cols_to_check: List[str]
-) -> Tuple[List[str], List[str]]:
+    dataframe: pd.DataFrame, cols_to_check: list[str]
+) -> tuple[list[str], list[str]]:
     invalid_long_string_data_cols = []
     truncated_long_string_data_cols = []
     for col in cols_to_check:
@@ -3469,7 +3506,7 @@ def _check_value_raw_data_length_helper(
             )
         except TypeError as exc:
             e = TypeError(f"Cannot validate the column '{col}'. " + str(exc))
-            logger.error(e)
+            logger.exception(e)
             raise e from exc
         if max_data_len > MAX_RAW_DATA_CHARACTERS:
             invalid_long_string_data_cols.append(col)
@@ -3480,8 +3517,8 @@ def _check_value_raw_data_length_helper(
 
 def _check_value_bounding_boxes_coordinates_helper(
     coordinates_col: pd.Series,
-) -> Union[err.InvalidBoundingBoxesCoordinates, None]:
-    def check(boxes):
+) -> err.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:
@@ -3502,7 +3539,9 @@ def _check_value_bounding_boxes_coordinates_helper(
     return None
 
 
-def _box_coordinates_wrong_format(box_coords):
+def _box_coordinates_wrong_format(
+    box_coords: object,
+) -> err.InvalidBoundingBoxesCoordinates | None:
     if (
         # Coordinates should be a collection of 4 floats
         len(box_coords) != 4
@@ -3516,12 +3555,13 @@ def _box_coordinates_wrong_format(box_coords):
         return err.InvalidBoundingBoxesCoordinates(
             reason="boxes_coordinates_wrong_format"
         )
+    return None
 
 
 def _check_value_bounding_boxes_categories_helper(
     categories_col: pd.Series,
-) -> Union[err.InvalidBoundingBoxesCategories, None]:
-    def check(categories):
+) -> err.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:
@@ -3542,8 +3582,8 @@ def _check_value_bounding_boxes_categories_helper(
 
 def _check_value_bounding_boxes_scores_helper(
     scores_col: pd.Series,
-) -> Union[err.InvalidBoundingBoxesScores, None]:
-    def check(scores):
+) -> err.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:
@@ -3562,9 +3602,10 @@ def _check_value_bounding_boxes_scores_helper(
     return None
 
 
-def _polygon_coordinates_wrong_format(polygon_coords):
-    """
-    Check if polygon coordinates are valid.
+def _polygon_coordinates_wrong_format(
+    polygon_coords: object,
+) -> err.InvalidPolygonCoordinates | None:
+    """Check if polygon coordinates are valid.
 
     Validates:
     - Has at least 3 vertices (6 coordinates)
@@ -3610,9 +3651,9 @@ def _polygon_coordinates_wrong_format(polygon_coords):
 
     # Check for self-intersections
     # We need to check if any two non-adjacent edges intersect
-    edges = []
-    for i in range(len(points)):
-        edges.append((points[i], points[(i + 1) % len(points)]))
+    edges = [
+        (points[i], points[(i + 1) % len(points)]) for i in range(len(points))
+    ]
 
     for i in range(len(edges)):
         for j in range(i + 2, len(edges)):
@@ -3634,8 +3675,8 @@ def _polygon_coordinates_wrong_format(polygon_coords):
 
 def _check_value_polygon_coordinates_helper(
     coordinates_col: pd.Series,
-) -> Union[err.InvalidPolygonCoordinates, None]:
-    def check(polygons):
+) -> err.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:
@@ -3658,8 +3699,8 @@ def _check_value_polygon_coordinates_helper(
 
 def _check_value_polygon_categories_helper(
     categories_col: pd.Series,
-) -> Union[err.InvalidPolygonCategories, None]:
-    def check(categories):
+) -> err.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:
@@ -3678,8 +3719,8 @@ def _check_value_polygon_categories_helper(
 
 def _check_value_polygon_scores_helper(
     scores_col: pd.Series,
-) -> Union[err.InvalidPolygonScores, None]:
-    def check(scores):
+) -> err.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:
@@ -3696,7 +3737,7 @@ def _check_value_polygon_scores_helper(
     return None
 
 
-def _count_characters_raw_data(data: Union[str, List[str]]) -> int:
+def _count_characters_raw_data(data: str | list[str]) -> int:
     character_count = 0
     if isinstance(data, str):
         character_count = len(data)