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

arize/exceptions/values.py

@@ -1,5 +1,6 @@
+"""Value validation exception classes."""
+
 from collections.abc import Iterable
-from typing import Dict, List, Optional
 
 from arize.constants.ml import (
     MAX_FUTURE_YEARS_FROM_CURRENT_TIME,
@@ -13,13 +14,22 @@ from arize.logging import log_a_list
 
 
 class InvalidValueTimestamp(ValidationError):
+    """Raised when timestamp values are outside acceptable time range."""
+
     def __repr__(self) -> str:
+        """Return a string representation for debugging and logging."""
         return "Invalid_Timestamp_Value"
 
     def __init__(self, timestamp_col_name: str) -> None:
+        """Initialize the exception with timestamp validation context.
+
+        Args:
+            timestamp_col_name: Name of the column containing invalid timestamp values.
+        """
         self.timestamp_col_name = timestamp_col_name
 
     def error_message(self) -> str:
+        """Return the error message for this exception."""
         return (
             f"Prediction timestamp in {self.timestamp_col_name} is out of range. "
             f"Prediction timestamps must be within {MAX_FUTURE_YEARS_FROM_CURRENT_TIME} year "
@@ -30,32 +40,52 @@ class InvalidValueTimestamp(ValidationError):
 
 
 class InvalidValueMissingValue(ValidationError):
+    """Raised when required fields contain null or missing values."""
+
     def __repr__(self) -> str:
+        """Return a string representation for debugging and logging."""
         return "Invalid_Missing_Value"
 
     def __init__(
-        self, name: str, wrong_values: str, column: Optional[str] = None
+        self, name: str, wrong_values: str, column: str | None = None
     ) -> None:
+        """Initialize the exception with missing value validation context.
+
+        Args:
+            name: Name of the field with missing values.
+            wrong_values: Description of the wrong values found (e.g., "null", "NaN").
+            column: Optional column name where missing values were found.
+        """
         self.name = name
         self.wrong_values = wrong_values
         self.column = column
 
     def error_message(self) -> str:
+        """Return the error message for this exception."""
         if self.name in ["Prediction ID", "Prediction Group ID", "Rank"]:
             return f"{self.name} column '{self.column}' must not contain {self.wrong_values} values."
-        else:
-            return f"{self.name} must not contain {self.wrong_values} values."
+        return f"{self.name} must not contain {self.wrong_values} values."
 
 
 class InvalidRankValue(ValidationError):
+    """Raised when ranking column values are outside acceptable range."""
+
     def __repr__(self) -> str:
+        """Return a string representation for debugging and logging."""
         return "Invalid_Rank_Value"
 
     def __init__(self, name: str, acceptable_range: str) -> None:
+        """Initialize the exception with rank validation context.
+
+        Args:
+            name: Name of the ranking column.
+            acceptable_range: Description of the acceptable value range.
+        """
         self.name = name
         self.acceptable_range = acceptable_range
 
     def error_message(self) -> str:
+        """Return the error message for this exception."""
         return (
             f"ranking column {self.name} is out of range. "
             f"Only values within {self.acceptable_range}  are accepted. "
@@ -63,18 +93,30 @@ class InvalidRankValue(ValidationError):
 
 
 class InvalidStringLengthInColumn(ValidationError):
+    """Raised when string values in a column exceed length limits."""
+
     def __repr__(self) -> str:
+        """Return a string representation for debugging and logging."""
         return "Invalid_String_Length_In_Column"
 
     def __init__(
         self, schema_name: str, col_name: str, min_length: int, max_length: int
     ) -> None:
+        """Initialize the exception with string length validation context.
+
+        Args:
+            schema_name: Name of the schema field.
+            col_name: Name of the column with invalid string lengths.
+            min_length: Minimum acceptable string length.
+            max_length: Maximum acceptable string length.
+        """
         self.schema_name = schema_name
         self.col_name = col_name
         self.min_length = min_length
         self.max_length = max_length
 
     def error_message(self) -> str:
+        """Return the error message for this exception."""
         return (
             f"{self.schema_name} column '{self.col_name}' contains invalid values. "
             f"Only string values of length between {self.min_length} and {self.max_length} are accepted."
@@ -82,13 +124,22 @@ class InvalidStringLengthInColumn(ValidationError):
 
 
 class InvalidTagLength(ValidationError):
+    """Raised when tag values exceed maximum character length."""
+
     def __repr__(self) -> str:
+        """Return a string representation for debugging and logging."""
         return "Invalid_Tag_Length"
 
     def __init__(self, cols: Iterable) -> None:
+        """Initialize the exception with tag length validation context.
+
+        Args:
+            cols: Tag columns with values exceeding maximum character length.
+        """
         self.wrong_value_columns = cols
 
     def error_message(self) -> str:
+        """Return the error message for this exception."""
         return (
             f"Only tag values with less than or equal to {MAX_TAG_LENGTH} characters are supported. "
             f"The following tag columns have more than {MAX_TAG_LENGTH} characters: "
@@ -97,13 +148,22 @@ class InvalidTagLength(ValidationError):
 
 
 class InvalidRankingCategoryValue(ValidationError):
+    """Raised when ranking relevance labels contain invalid values."""
+
     def __repr__(self) -> str:
+        """Return a string representation for debugging and logging."""
         return "Invalid_Ranking_Relevance_Labels_Value"
 
     def __init__(self, name: str) -> None:
+        """Initialize the exception with ranking category validation context.
+
+        Args:
+            name: Name of the ranking relevance labels column.
+        """
         self.name = name
 
     def error_message(self) -> str:
+        """Return the error message for this exception."""
         return (
             f"ranking relevance labels '{self.name}' column contains invalid value"
             f"make sure empty string is not present"
@@ -111,15 +171,24 @@ class InvalidRankingCategoryValue(ValidationError):
 
 
 class InvalidBoundingBoxesCoordinates(ValidationError, Exception):
+    """Raised when bounding box coordinates are invalid or incorrectly formatted."""
+
     def __repr__(self) -> str:
+        """Return a string representation for debugging and logging."""
         return "Invalid_Bounding_Boxes_Coordinates"
 
-    def __init__(self, reason) -> None:
+    def __init__(self, reason: str) -> None:
+        """Initialize the exception with bounding box coordinate validation context.
+
+        Args:
+            reason: Specific reason for invalid coordinates (e.g., "none_boxes",
+                "none_or_empty_box", "boxes_coordinates_wrong_format").
+        """
         self._check_valid_reason(reason)
         self.reason = reason
 
     @staticmethod
-    def _check_valid_reason(reason):
+    def _check_valid_reason(reason: str) -> None:
         possible_reasons = (
             "none_boxes",
             "none_or_empty_box",
@@ -132,6 +201,7 @@ class InvalidBoundingBoxesCoordinates(ValidationError, Exception):
             )
 
     def error_message(self) -> str:
+        """Return the error message for this exception."""
         msg = "Invalid bounding boxes coordinates found. "
         if self.reason == "none_boxes":
             msg += (
@@ -154,15 +224,24 @@ class InvalidBoundingBoxesCoordinates(ValidationError, Exception):
 
 
 class InvalidBoundingBoxesCategories(ValidationError, Exception):
+    """Raised when bounding box categories are invalid or missing."""
+
     def __repr__(self) -> str:
+        """Return a string representation for debugging and logging."""
         return "Invalid_Bounding_Boxes_Categories"
 
-    def __init__(self, reason) -> None:
+    def __init__(self, reason: str) -> None:
+        """Initialize the exception with bounding box category validation context.
+
+        Args:
+            reason: Specific reason for invalid categories (e.g., "none_category_list",
+                "none_category").
+        """
         self._check_valid_reason(reason)
         self.reason = reason
 
     @staticmethod
-    def _check_valid_reason(reason):
+    def _check_valid_reason(reason: str) -> None:
         possible_reasons = (
             "none_category_list",
             "none_category",
@@ -174,6 +253,7 @@ class InvalidBoundingBoxesCategories(ValidationError, Exception):
             )
 
     def error_message(self) -> str:
+        """Return the error message for this exception."""
         msg = "Invalid bounding boxes categories found. "
         if self.reason == "none_category_list":
             msg += (
@@ -189,15 +269,24 @@ class InvalidBoundingBoxesCategories(ValidationError, Exception):
 
 
 class InvalidBoundingBoxesScores(ValidationError, Exception):
+    """Raised when bounding box confidence scores are invalid or out of bounds."""
+
     def __repr__(self) -> str:
+        """Return a string representation for debugging and logging."""
         return "Invalid_Bounding_Boxes_Scores"
 
-    def __init__(self, reason) -> None:
+    def __init__(self, reason: str) -> None:
+        """Initialize the exception with bounding box score validation context.
+
+        Args:
+            reason: Specific reason for invalid scores (e.g., "none_score_list",
+                "scores_out_of_bounds").
+        """
         self._check_valid_reason(reason)
         self.reason = reason
 
     @staticmethod
-    def _check_valid_reason(reason):
+    def _check_valid_reason(reason: str) -> None:
         possible_reasons = (
             "none_score_list",
             "scores_out_of_bounds",
@@ -209,6 +298,7 @@ class InvalidBoundingBoxesScores(ValidationError, Exception):
             )
 
     def error_message(self) -> str:
+        """Return the error message for this exception."""
         msg = "Invalid bounding boxes scores found. "
         if self.reason == "none_score_list":
             msg += (
@@ -224,18 +314,28 @@ class InvalidBoundingBoxesScores(ValidationError, Exception):
 
 
 class InvalidPolygonCoordinates(ValidationError, Exception):
+    """Raised when polygon coordinates are invalid or incorrectly formatted."""
+
     def __repr__(self) -> str:
+        """Return a string representation for debugging and logging."""
         return "Invalid_Polygon_Coordinates"
 
     def __init__(
-        self, reason: str, coordinates: Optional[List[float]] = None
+        self, reason: str, coordinates: list[float] | None = None
     ) -> None:
+        """Initialize the exception with polygon coordinate validation context.
+
+        Args:
+            reason: Specific reason for invalid coordinates (e.g., "none_polygons",
+                "none_or_empty_polygon", "polygon_coordinates_wrong_format").
+            coordinates: Optional list of invalid coordinates for error reporting.
+        """
         self._check_valid_reason(reason)
         self.reason = reason
         self.coordinates = coordinates
 
     @staticmethod
-    def _check_valid_reason(reason):
+    def _check_valid_reason(reason: str) -> None:
         possible_reasons = (
             "none_polygons",
             "none_or_empty_polygon",
@@ -250,6 +350,7 @@ class InvalidPolygonCoordinates(ValidationError, Exception):
             )
 
     def error_message(self) -> str:
+        """Return the error message for this exception."""
         msg = "Invalid polygon coordinates found. "
         if self.reason == "none_polygons":
             msg += (
@@ -285,15 +386,24 @@ class InvalidPolygonCoordinates(ValidationError, Exception):
 
 
 class InvalidPolygonCategories(ValidationError, Exception):
+    """Raised when polygon categories are invalid or missing."""
+
     def __repr__(self) -> str:
+        """Return a string representation for debugging and logging."""
         return "Invalid_Polygon_Categories"
 
-    def __init__(self, reason) -> None:
+    def __init__(self, reason: str) -> None:
+        """Initialize the exception with polygon category validation context.
+
+        Args:
+            reason: Specific reason for invalid categories (e.g., "none_category_list",
+                "none_category").
+        """
         self._check_valid_reason(reason)
         self.reason = reason
 
     @staticmethod
-    def _check_valid_reason(reason):
+    def _check_valid_reason(reason: str) -> None:
         possible_reasons = (
             "none_category_list",
             "none_category",
@@ -305,6 +415,7 @@ class InvalidPolygonCategories(ValidationError, Exception):
             )
 
     def error_message(self) -> str:
+        """Return the error message for this exception."""
         msg = "Invalid polygon categories found. "
         if self.reason == "none_category_list":
             msg += (
@@ -320,15 +431,24 @@ class InvalidPolygonCategories(ValidationError, Exception):
 
 
 class InvalidPolygonScores(ValidationError, Exception):
+    """Raised when polygon confidence scores are invalid or out of bounds."""
+
     def __repr__(self) -> str:
+        """Return a string representation for debugging and logging."""
         return "Invalid_Polygon_Scores"
 
-    def __init__(self, reason) -> None:
+    def __init__(self, reason: str) -> None:
+        """Initialize the exception with polygon score validation context.
+
+        Args:
+            reason: Specific reason for invalid scores (e.g., "none_score_list",
+                "scores_out_of_bounds").
+        """
         self._check_valid_reason(reason)
         self.reason = reason
 
     @staticmethod
-    def _check_valid_reason(reason):
+    def _check_valid_reason(reason: str) -> None:
         possible_reasons = (
             "none_score_list",
             "scores_out_of_bounds",
@@ -340,6 +460,7 @@ class InvalidPolygonScores(ValidationError, Exception):
             )
 
     def error_message(self) -> str:
+        """Return the error message for this exception."""
         msg = "Invalid polygon scores found. "
         if self.reason == "none_score_list":
             msg += (
@@ -355,15 +476,25 @@ class InvalidPolygonScores(ValidationError, Exception):
 
 
 class InvalidNumClassesMultiClassMap(ValidationError):
+    """Raised when multi-class dictionary contains invalid number of classes."""
+
     def __repr__(self) -> str:
+        """Return a string representation for debugging and logging."""
         return "Invalid_Num_classes_Multi_Class_Map"
 
     def __init__(
-        self, dict_col_to_list_of_invalid_num_classes: Dict[str, List[str]]
+        self, dict_col_to_list_of_invalid_num_classes: dict[str, list[str]]
     ) -> None:
+        """Initialize the exception with multi-class number validation context.
+
+        Args:
+            dict_col_to_list_of_invalid_num_classes: Mapping of columns to lists of
+                invalid number of classes found.
+        """
         self.invalid_col_num_classes = dict_col_to_list_of_invalid_num_classes
 
     def error_message(self) -> str:
+        """Return the error message for this exception."""
         err_msg = ""
         for (
             col,
@@ -383,13 +514,22 @@ class InvalidNumClassesMultiClassMap(ValidationError):
 
 
 class InvalidMultiClassClassNameLength(ValidationError):
+    """Raised when multi-class class names exceed maximum length."""
+
     def __repr__(self) -> str:
+        """Return a string representation for debugging and logging."""
         return "Invalid_Multi_Class_Class_Name_Length"
 
-    def __init__(self, invalid_col_class_name: Dict[str, set]) -> None:
+    def __init__(self, invalid_col_class_name: dict[str, set]) -> None:
+        """Initialize the exception with multi-class name length validation context.
+
+        Args:
+            invalid_col_class_name: Mapping of columns to sets of invalid class names.
+        """
         self.invalid_col_class_name = invalid_col_class_name
 
     def error_message(self) -> str:
+        """Return the error message for this exception."""
         err_msg = ""
         for col, class_names in self.invalid_col_class_name.items():
             # limit to 10
@@ -406,13 +546,22 @@ class InvalidMultiClassClassNameLength(ValidationError):
 
 
 class InvalidMultiClassPredScoreValue(ValidationError):
+    """Raised when multi-class prediction scores are outside valid range."""
+
     def __repr__(self) -> str:
+        """Return a string representation for debugging and logging."""
         return "Invalid_Multi_Class_Pred_Score_Value"
 
-    def __init__(self, invalid_col_class_scores: Dict[str, set]) -> None:
+    def __init__(self, invalid_col_class_scores: dict[str, set]) -> None:
+        """Initialize the exception with multi-class prediction score validation context.
+
+        Args:
+            invalid_col_class_scores: Mapping of columns to sets of invalid scores.
+        """
         self.invalid_col_class_scores = invalid_col_class_scores
 
     def error_message(self) -> str:
+        """Return the error message for this exception."""
         err_msg = ""
         for col, scores in self.invalid_col_class_scores.items():
             # limit to 10
@@ -425,13 +574,22 @@ class InvalidMultiClassPredScoreValue(ValidationError):
 
 
 class InvalidMultiClassActScoreValue(ValidationError):
+    """Raised when multi-class actual scores are not 0 or 1."""
+
     def __repr__(self) -> str:
+        """Return a string representation for debugging and logging."""
         return "Invalid_Multi_Class_Act_Score_Value"
 
     def __init__(self, name: str) -> None:
+        """Initialize the exception with multi-class actual score validation context.
+
+        Args:
+            name: Name of the column with invalid actual scores.
+        """
         self.name = name
 
     def error_message(self) -> str:
+        """Return the error message for this exception."""
         return (
             f"Found at least one score in the '{self.name}' column that was invalid. "
             f"All scores (values) must be either 0 or 1."
@@ -439,17 +597,28 @@ class InvalidMultiClassActScoreValue(ValidationError):
 
 
 class InvalidMultiClassThresholdClasses(ValidationError):
+    """Raised when prediction and threshold score dictionaries have mismatched classes."""
+
     def __repr__(self) -> str:
+        """Return a string representation for debugging and logging."""
         return "Invalid_Multi_Class_Threshold_Classes"
 
     def __init__(
         self, name: str, prediction_class_set: set, threshold_class_set: set
     ) -> None:
+        """Initialize the exception with multi-class threshold validation context.
+
+        Args:
+            name: Name of the field being validated.
+            prediction_class_set: Set of classes in prediction scores dictionary.
+            threshold_class_set: Set of classes in threshold scores dictionary.
+        """
         self.name = name
         self.prediction_class_set = prediction_class_set
         self.threshold_class_set = threshold_class_set
 
     def error_message(self) -> str:
+        """Return the error message for this exception."""
         return (
             "Multi-Class Prediction Scores and Threshold Scores Dictionaries must contain the same "
             f"classes. The following classes of the Prediction Scores Dictionary are not in the Threshold "
@@ -460,13 +629,22 @@ class InvalidMultiClassThresholdClasses(ValidationError):
 
 
 class InvalidAdditionalHeaders(ValidationError):
+    """Raised when additional headers use reserved header names."""
+
     def __repr__(self) -> str:
+        """Return a string representation for debugging and logging."""
         return "Invalid_Additional_Headers"
 
     def __init__(self, invalid_headers: Iterable) -> None:
+        """Initialize the exception with invalid headers context.
+
+        Args:
+            invalid_headers: Headers that use reserved names.
+        """
         self.invalid_header_names = invalid_headers
 
     def error_message(self) -> str:
+        """Return the error message for this exception."""
         return (
             "Found invalid additional header, cannot use reserved headers named: "
             f"{', '.join(map(str, self.invalid_header_names))}."
@@ -474,14 +652,24 @@ class InvalidAdditionalHeaders(ValidationError):
 
 
 class InvalidRecord(ValidationError):
+    """Raised when records contain invalid or all-null column sets."""
+
     def __repr__(self) -> str:
+        """Return a string representation for debugging and logging."""
         return "Invalid_Record"
 
-    def __init__(self, columns: List[str], indexes: List[int]) -> None:
+    def __init__(self, columns: list[str], indexes: list[int]) -> None:
+        """Initialize the exception with invalid record context.
+
+        Args:
+            columns: Columns that form an invalid all-null set.
+            indexes: Row indexes containing the invalid records.
+        """
         self.columns = columns
         self.indexes = indexes
 
     def error_message(self) -> str:
+        """Return the error message for this exception."""
         return (
             f"Invalid column set full of null values in one or more rows.\n"
             f"\nProblematic Column Set:\n{log_a_list(self.columns, 'and')}\n"
@@ -495,16 +683,28 @@ class InvalidRecord(ValidationError):
 
 
 class InvalidStringLength(Exception):
+    """Raised when a string value exceeds the allowed length."""
+
     def __init__(self, name: str, min_length: int, max_length: int) -> None:
+        """Initialize the exception with string length validation context.
+
+        Args:
+            name: Name of the field with invalid length.
+            min_length: Minimum acceptable string length.
+            max_length: Maximum acceptable string length.
+        """
         self.name = name
         self.min_length = min_length
         self.max_length = max_length
 
     def __repr__(self) -> str:
+        """Return a string representation for debugging and logging."""
         return "Invalid_String_Length"
 
     def __str__(self) -> str:
+        """Return a human-readable error message."""
         return self.error_message()
 
     def error_message(self) -> str:
+        """Return the error message for this exception."""
         return f"{self.name} must be of length between {self.min_length} and {self.max_length} characters."

arize/experiments/__init__.py

@@ -0,0 +1 @@
+"""Experiment tracking and evaluation functionality for the Arize SDK."""