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

arize/{types.py → ml/types.py}

@@ -1,9 +1,8 @@
-"""Common type definitions and data models used across the Arize SDK."""
+"""Common type definitions and data models used across the ML Client."""
 
-import json
 import logging
 import math
-from collections.abc import Iterable, Iterator, Sequence
+from collections.abc import Iterator
 from dataclasses import asdict, dataclass, replace
 from datetime import datetime
 from decimal import Decimal
@@ -12,7 +11,6 @@ from itertools import chain
 from typing import (
     NamedTuple,
     Self,
-    TypeVar,
 )
 
 import numpy as np
@@ -40,6 +38,7 @@ from arize.exceptions.parameters import InvalidValueType
 # )
 # from arize.utils.errors import InvalidValueType
 from arize.logging import get_truncation_warning_message
+from arize.utils.types import is_dict_of, is_iterable_of, is_list_of
 
 logger = logging.getLogger(__name__)
 
@@ -162,15 +161,12 @@ class Embedding(NamedTuple):
 
         Ensures validations are passed for vector, data, and link_to_data fields.
 
-        Arguments:
-        ---------
-            emb_name (str, int, float): Name of the embedding feature the
-            vector belongs to
+        Args:
+            emb_name: Name of the embedding feature the
+                vector belongs to.
 
         Raises:
-        ------
-            TypeError: If the embedding fields are of the wrong type
-
+            TypeError: If the embedding fields are of the wrong type.
         """
         if self.vector is not None:
             self._validate_embedding_vector(emb_name)
@@ -194,15 +190,12 @@ class Embedding(NamedTuple):
         Requirements: 1) Type must be list or convertible to list (like numpy arrays,
         pandas Series), 2) List must not be empty, 3) Elements in list must be floats.
 
-        Arguments:
-        ---------
-            emb_name (str, int, float): Name of the embedding feature the vector
-            belongs to
+        Args:
+            emb_name: Name of the embedding feature the vector
+                belongs to.
 
         Raises:
-        ------
-            TypeError: If the embedding does not satisfy requirements above
-
+            TypeError: If the embedding does not satisfy requirements above.
         """
         if not Embedding._is_valid_iterable(self.vector):
             raise TypeError(
@@ -228,15 +221,13 @@ class Embedding(NamedTuple):
 
         Requirement: Must be string or list of strings (NLP case).
 
-        Arguments:
-        ---------
-            emb_name (str, int, float): Name of the embedding feature the vector belongs to
-            data (str, int, float): Raw data associated with the embedding feature. Typically raw text.
+        Args:
+            emb_name: Name of the embedding feature the vector belongs to.
+            data: Raw data associated with the embedding feature.
+                Typically raw text.
 
         Raises:
-        ------
-            TypeError: If the embedding does not satisfy requirements above
-
+            TypeError: If the embedding does not satisfy requirements above.
         """
         # Validate that data is a string or iterable of strings
         is_string = isinstance(data, str)
@@ -276,16 +267,13 @@ class Embedding(NamedTuple):
 
         Requirement: Must be string.
 
-        Arguments:
-        ---------
-            emb_name (str, int, float): Name of the embedding feature the vector belongs to
-            link_to_data (str): Link to source data of embedding feature, typically an image file on
-                cloud storage
+        Args:
+            emb_name: Name of the embedding feature the vector belongs to.
+            link_to_data: Link to source data of embedding feature, typically an
+                image file on cloud storage.
 
         Raises:
-        ------
-            TypeError: If the embedding does not satisfy requirements above
-
+            TypeError: If the embedding does not satisfy requirements above.
         """
         if not isinstance(link_to_data, str):
             raise TypeError(
@@ -301,14 +289,12 @@ class Embedding(NamedTuple):
 
         Accepted types: 1) List, 2) numpy array, or 3) pandas Series.
 
-        Arguments:
-        ---------
-            data: input iterable
+        Args:
+            data: Input iterable.
 
         Returns:
-        -------
-            True if the data type is one of the accepted iterable types, false otherwise
-
+            True if the data type is one of the accepted iterable types,
+                false otherwise.
         """
         return any(isinstance(data, t) for t in (list, np.ndarray))
 
@@ -379,18 +365,16 @@ class ObjectDetectionColumnNames(NamedTuple):
 
     These values are assigned to the prediction or actual schema parameter.
 
-    Arguments:
-    ---------
-        bounding_boxes_coordinates_column_name (str): Column name containing the coordinates of the
+    Args:
+        bounding_boxes_coordinates_column_name: Column name containing the coordinates of the
             rectangular outline that locates an object within an image or video. Pascal VOC format
             required. The contents of this column must be a List[List[float]].
-        categories_column_name (str): Column name containing the predefined classes or labels used
+        categories_column_name: Column name containing the predefined classes or labels used
             by the model to classify the detected objects. The contents of this column must be List[str].
-        scores_column_names (str, optional): Column name containing the confidence scores that the
+        scores_column_names: Column name containing the confidence scores that the
             model assigns to it's predictions, indicating how certain the model is that the predicted
             class is contained within the bounding box. This argument is only applicable for prediction
             values. The contents of this column must be List[float].
-
     """
 
     bounding_boxes_coordinates_column_name: str
@@ -403,15 +387,13 @@ class SemanticSegmentationColumnNames(NamedTuple):
 
     These values are assigned to the prediction or actual schema parameter.
 
-    Arguments:
-    ---------
-        polygon_coordinates_column_name (str): Column name containing the coordinates of the vertices
+    Args:
+        polygon_coordinates_column_name: Column name containing the coordinates of the vertices
             of the polygon mask within an image or video. The first sublist contains the
             coordinates of the outline of the polygon. The subsequent sublists contain the coordinates
             of any cutouts within the polygon. The contents of this column must be a List[List[float]].
-        categories_column_name (str): Column name containing the predefined classes or labels used
+        categories_column_name: Column name containing the predefined classes or labels used
             by the model to classify the detected objects. The contents of this column must be List[str].
-
     """
 
     polygon_coordinates_column_name: str
@@ -421,22 +403,20 @@ class SemanticSegmentationColumnNames(NamedTuple):
 class InstanceSegmentationPredictionColumnNames(NamedTuple):
     """Used to log instance segmentation prediction values for the prediction schema parameter.
 
-    Arguments:
-    ---------
-        polygon_coordinates_column_name (str): Column name containing the coordinates of the vertices
+    Args:
+        polygon_coordinates_column_name: Column name containing the coordinates of the vertices
             of the polygon mask within an image or video. The first sublist contains the
             coordinates of the outline of the polygon. The subsequent sublists contain the coordinates
             of any cutouts within the polygon. The contents of this column must be a List[List[float]].
-        categories_column_name (str): Column name containing the predefined classes or labels used
+        categories_column_name: Column name containing the predefined classes or labels used
             by the model to classify the detected objects. The contents of this column must be List[str].
-        scores_column_name (str, optional): Column name containing the confidence scores that the
+        scores_column_name: Column name containing the confidence scores that the
             model assigns to it's predictions, indicating how certain the model is that the predicted
             class is contained within the bounding box. This argument is only applicable for prediction
             values. The contents of this column must be List[float].
-        bounding_boxes_coordinates_column_name (str, optional): Column name containing the coordinates of the
+        bounding_boxes_coordinates_column_name: Column name containing the coordinates of the
             rectangular outline that locates an object within an image or video. Pascal VOC format
             required. The contents of this column must be a List[List[float]].
-
     """
 
     polygon_coordinates_column_name: str
@@ -448,17 +428,15 @@ class InstanceSegmentationPredictionColumnNames(NamedTuple):
 class InstanceSegmentationActualColumnNames(NamedTuple):
     """Used to log instance segmentation actual values that are assigned to the actual schema parameter.
 
-    Arguments:
-    ---------
-        polygon_coordinates_column_name (str): Column name containing the coordinates of the
+    Args:
+        polygon_coordinates_column_name: Column name containing the coordinates of the
             polygon that locates an object within an image or video. The contents of this column
             must be a List[List[float]].
-        categories_column_name (str): Column name containing the predefined classes or labels used
+        categories_column_name: Column name containing the predefined classes or labels used
             by the model to classify the detected objects. The contents of this column must be List[str].
-        bounding_boxes_coordinates_column_name (str, optional): Column name containing the coordinates of the
+        bounding_boxes_coordinates_column_name: Column name containing the coordinates of the
             rectangular outline that locates an object within an image or video. Pascal VOC format
             required. The contents of this column must be a List[List[float]].
-
     """
 
     polygon_coordinates_column_name: str
@@ -743,13 +721,10 @@ class InstanceSegmentationActualLabel(NamedTuple):
 class MultiClassPredictionLabel(NamedTuple):
     """Used to log multi class prediction label.
 
-    Arguments:
-    ---------
-    MultiClassPredictionLabel
-        prediction_scores (Dict[str, Union[float, int]]): the prediction scores of the classes.
-        threshold_scores (Optional[Dict[str, Union[float, int]]]): the threshold scores of the classes.
+    Args:
+        prediction_scores: The prediction scores of the classes.
+        threshold_scores: The threshold scores of the classes.
             Only Multi Label will have threshold scores.
-
     """
 
     prediction_scores: dict[str, float | int]
@@ -848,12 +823,9 @@ class MultiClassPredictionLabel(NamedTuple):
 class MultiClassActualLabel(NamedTuple):
     """Used to log multi class actual label.
 
-    Arguments:
-    ---------
-    MultiClassActualLabel
-        actual_scores (Dict[str, Union[float, int]]): the actual scores of the classes.
-        Any class in actual_scores with a score of 1 will be sent to arize
-
+    Args:
+        actual_scores: The actual scores of the classes.
+            Any class in actual_scores with a score of 1 will be sent to arize.
     """
 
     actual_scores: dict[str, float | int]
@@ -972,6 +944,15 @@ class RankingActualLabel(NamedTuple):
 
     @staticmethod
     def _validate_relevance_labels(relevance_labels: list[str]) -> None:
+        """Validate relevance labels.
+
+        Args:
+            relevance_labels: List of relevance labels to validate.
+
+        Raises:
+            TypeError: If relevance_labels is not a list of strings.
+            ValueError: If any label is an empty string.
+        """
         if not is_list_of(relevance_labels, str):
             raise TypeError("Actual Relevance Labels must be a list of strings")
         if any(label == "" for label in relevance_labels):
@@ -981,6 +962,14 @@ class RankingActualLabel(NamedTuple):
 
     @staticmethod
     def _validate_relevance_score(relevance_score: float) -> None:
+        """Validate relevance score.
+
+        Args:
+            relevance_score: Relevance score to validate.
+
+        Raises:
+            TypeError: If relevance_score is not a float or int.
+        """
         if not isinstance(relevance_score, (float, int)):
             raise TypeError("Actual Relevance score must be a float or an int")
 
@@ -1133,33 +1122,20 @@ class BaseSchema:
 class TypedColumns:
     """Optional class used for explicit type enforcement of feature and tag columns in the dataframe.
 
-    Usage:
-    ------
-        When initializing a Schema, use TypedColumns in place of a list of string column names.
-        e.g. feature_column_names=TypedColumns(
-                inferred=["feature_1", "feature_2"],
-                to_str=["feature_3"],
-                to_int=["feature_4"]
-            )
+    When initializing a Schema, use TypedColumns in place of a list of string column names::
 
-    Fields:
-    -------
-        inferred (Optional[List[str]]): List of columns that will not be altered at all.
-            The values in these columns will have their type inferred as Arize validates and ingests the data.
-            There's no difference between passing in all column names as inferred
-            vs. not using TypedColumns at all.
-        to_str (Optional[List[str]]): List of columns that should be cast to pandas StringDType.
-        to_int (Optional[List[str]]): List of columns that should be cast to pandas Int64DType.
-        to_float (Optional[List[str]]): List of columns that should be cast to pandas Float64DType.
+        feature_column_names = TypedColumns(
+            inferred=["feature_1", "feature_2"],
+            to_str=["feature_3"],
+            to_int=["feature_4"],
+        )
 
     Notes:
-    -----
         - If a TypedColumns object is included in a Schema, pandas version 1.0.0 or higher is required.
         - Pandas StringDType is still considered an experimental field.
         - Columns not present in any field will not be captured in the Schema.
         - StringDType, Int64DType, and Float64DType are all nullable column types.
-        Null values will be ingested and represented in Arize as empty values.
-
+          Null values will be ingested and represented in Arize as empty values.
     """
 
     inferred: list[str] | None = None
@@ -1188,92 +1164,80 @@ class TypedColumns:
 class Schema(BaseSchema):
     """Used to organize and map column names containing model data within your Pandas dataframe to Arize.
 
-    Arguments:
-    ---------
-        prediction_id_column_name (str, optional): Column name for the predictions unique identifier.
+    Args:
+        prediction_id_column_name: Column name for the predictions unique identifier.
             Unique IDs are used to match a prediction to delayed actuals or feature importances in Arize.
             If prediction ids are not provided, it will default to an empty string "" and, when possible,
             Arize will create a random prediction id on the server side. Prediction id must be a string column
             with each row indicating a unique prediction event.
-        feature_column_names (Union[List[str], TypedColumns], optional): Column names for features.
+        feature_column_names: Column names for features.
             The content of feature columns can be int, float, string. If TypedColumns is used,
             the columns will be cast to the provided types prior to logging.
-        tag_column_names (Union[List[str], TypedColumns], optional): Column names for tags. The content of tag
+        tag_column_names: Column names for tags. The content of tag
             columns can be int, float, string. If TypedColumns is used,
             the columns will be cast to the provided types prior to logging.
-        timestamp_column_name (str, optional): Column name for timestamps. The content of this
+        timestamp_column_name: Column name for timestamps. The content of this
             column must be int Unix Timestamps in seconds.
-        prediction_label_column_name (str, optional): Column name for categorical prediction values.
+        prediction_label_column_name: Column name for categorical prediction values.
             The content of this column must be convertible to string.
-        prediction_score_column_name (str, optional): Column name for numeric prediction values. The
+        prediction_score_column_name: Column name for numeric prediction values. The
             content of this column must be int/float or list of dictionaries mapping class names to
             int/float scores in the case of MULTI_CLASS model types.
-        actual_label_column_name (str, optional): Column name for categorical ground truth values.
+        actual_label_column_name: Column name for categorical ground truth values.
             The content of this column must be convertible to string.
-        actual_score_column_name (str, optional): Column name for numeric ground truth values. The
+        actual_score_column_name: Column name for numeric ground truth values. The
             content of this column must be int/float or list of dictionaries mapping class names to
             int/float scores in the case of MULTI_CLASS model types.
-        shap_values_column_names (Dict[str, str], optional): Dictionary mapping feature column name
+        shap_values_column_names: Dictionary mapping feature column name
             and corresponding SHAP feature importance column name. e.g.
             {{"feat_A": "feat_A_shap", "feat_B": "feat_B_shap"}}
-        embedding_feature_column_names (Dict[str, EmbeddingColumnNames], optional): Dictionary
+        embedding_feature_column_names: Dictionary
             mapping embedding display names to EmbeddingColumnNames objects.
-        prediction_group_id_column_name (str, optional): Column name for ranking groups or lists in
+        prediction_group_id_column_name: Column name for ranking groups or lists in
             ranking models. The content of this column must be string and is limited to 128 characters.
-        rank_column_name (str, optional): Column name for rank of each element on the its group or
+        rank_column_name: Column name for rank of each element on the its group or
             list. The content of this column must be integer between 1-100.
-        relevance_score_column_name (str, optional): Column name for ranking model type numeric
+        relevance_score_column_name: Column name for ranking model type numeric
             ground truth values. The content of this column must be int/float.
-        relevance_labels_column_name (str, optional): Column name for ranking model type categorical
+        relevance_labels_column_name: Column name for ranking model type categorical
             ground truth values. The content of this column must be a string.
-        object_detection_prediction_column_names (ObjectDetectionColumnNames, optional):
+        object_detection_prediction_column_names:
             ObjectDetectionColumnNames object containing information defining the predicted bounding
             boxes' coordinates, categories, and scores.
-        object_detection_actual_column_names (ObjectDetectionColumnNames, optional):
+        object_detection_actual_column_names:
             ObjectDetectionColumnNames object containing information defining the actual bounding
             boxes' coordinates, categories, and scores.
-        prompt_column_names (str or EmbeddingColumnNames, optional): column names for text that is passed
+        prompt_column_names: column names for text that is passed
             to the GENERATIVE_LLM model. It accepts a string (if sending only a text column) or
             EmbeddingColumnNames object containing the embedding vector data (required) and raw text
             (optional) for the input text your model acts on.
-        response_column_names (str or EmbeddingColumnNames, optional): column names for text generated by
+        response_column_names: column names for text generated by
             the GENERATIVE_LLM model. It accepts a string (if sending only a text column) or
             EmbeddingColumnNames object containing the embedding vector data (required) and raw text
             (optional) for the text your model generates.
-        prompt_template_column_names (PromptTemplateColumnNames, optional): PromptTemplateColumnNames object
+        prompt_template_column_names: PromptTemplateColumnNames object
             containing the prompt template and the prompt template version.
-        llm_config_column_names (LLMConfigColumnNames, optional): LLMConfigColumnNames object containing
+        llm_config_column_names: LLMConfigColumnNames object containing
             the LLM's model name and its hyper parameters used at inference.
-        llm_run_metadata_column_names (LLMRunMetadataColumnNames, optional): LLMRunMetadataColumnNames
+        llm_run_metadata_column_names: LLMRunMetadataColumnNames
             object containing token counts and latency metrics
-        retrieved_document_ids_column_name (str, optional): Column name for retrieved document ids.
+        retrieved_document_ids_column_name: Column name for retrieved document ids.
             The content of this column must be lists with entries convertible to strings.
-        multi_class_threshold_scores_column_name (str, optional):
+        multi_class_threshold_scores_column_name:
             Column name for dictionary that maps class names to threshold values. The
             content of this column must be dictionary of str -> int/float.
-        semantic_segmentation_prediction_column_names (SemanticSegmentationColumnNames, optional):
+        semantic_segmentation_prediction_column_names:
             SemanticSegmentationColumnNames object containing information defining the predicted
             polygon coordinates and categories.
-        semantic_segmentation_actual_column_names (SemanticSegmentationColumnNames, optional):
+        semantic_segmentation_actual_column_names:
             SemanticSegmentationColumnNames object containing information defining the actual
             polygon coordinates and categories.
-        instance_segmentation_prediction_column_names (InstanceSegmentationPredictionColumnNames, optional):
+        instance_segmentation_prediction_column_names:
             InstanceSegmentationPredictionColumnNames object containing information defining the predicted
             polygon coordinates, categories, scores, and bounding box coordinates.
-        instance_segmentation_actual_column_names (InstanceSegmentationActualColumnNames, optional):
+        instance_segmentation_actual_column_names:
             InstanceSegmentationActualColumnNames object containing information defining the actual
             polygon coordinates, categories, scores, and bounding box coordinates.
-
-    Methods:
-    -------
-        replace(**changes):
-            Replaces fields of the schema
-        asdict():
-            Returns the schema as a dictionary. Warning: the types are not maintained, fields are
-            converted to strings.
-        get_used_columns():
-            Returns a set with the unique collection of columns to be used from the dataframe.
-
     """
 
     prediction_id_column_name: str | None = None
@@ -1545,105 +1509,6 @@ class TypedValue:
     value: str | bool | float | int
 
 
-def is_json_str(s: str) -> bool:
-    """Check if a string is valid JSON.
-
-    Args:
-        s: The string to validate.
-
-    Returns:
-        True if the string is valid JSON, False otherwise.
-    """
-    try:
-        json.loads(s)
-    except ValueError:
-        return False
-    except TypeError:
-        return False
-    return True
-
-
-T = TypeVar("T", bound=type)
-
-
-def is_array_of(arr: Sequence[object], tp: T) -> bool:
-    """Check if a value is a numpy array with all elements of a specific type.
-
-    Args:
-        arr: The sequence to check.
-        tp: The expected type for all elements.
-
-    Returns:
-        True if arr is a numpy array and all elements are of type tp.
-    """
-    return isinstance(arr, np.ndarray) and all(isinstance(x, tp) for x in arr)
-
-
-def is_list_of(lst: Sequence[object], tp: T) -> bool:
-    """Check if a value is a list with all elements of a specific type.
-
-    Args:
-        lst: The sequence to check.
-        tp: The expected type for all elements.
-
-    Returns:
-        True if lst is a list and all elements are of type tp.
-    """
-    return isinstance(lst, list) and all(isinstance(x, tp) for x in lst)
-
-
-def is_iterable_of(lst: Sequence[object], tp: T) -> bool:
-    """Check if a value is an iterable with all elements of a specific type.
-
-    Args:
-        lst: The sequence to check.
-        tp: The expected type for all elements.
-
-    Returns:
-        True if lst is an iterable and all elements are of type tp.
-    """
-    return isinstance(lst, Iterable) and all(isinstance(x, tp) for x in lst)
-
-
-def is_dict_of(
-    d: dict[object, object],
-    key_allowed_types: T,
-    value_allowed_types: T = (),
-    value_list_allowed_types: T = (),
-) -> bool:
-    """Method to check types are valid for dictionary.
-
-    Arguments:
-    ---------
-        d (Dict[object, object]): dictionary itself
-        key_allowed_types (T): all allowed types for keys of dictionary
-        value_allowed_types (T): all allowed types for values of dictionary
-        value_list_allowed_types (T): if value is a list, these are the allowed
-        types for value list
-
-    Returns:
-    -------
-        True if the data types of dictionary match the types specified by the
-        arguments, false otherwise
-
-    """
-    if value_list_allowed_types and not isinstance(
-        value_list_allowed_types, tuple
-    ):
-        value_list_allowed_types = (value_list_allowed_types,)
-
-    return (
-        isinstance(d, dict)
-        and all(isinstance(k, key_allowed_types) for k in d)
-        and all(
-            isinstance(v, value_allowed_types)
-            or any(is_list_of(v, t) for t in value_list_allowed_types)
-            for v in d.values()
-            if value_allowed_types or value_list_allowed_types
-        )
-    )
-
-
 def _count_characters_raw_data(data: str | list[str]) -> int:
     character_count = 0
     if isinstance(data, str):

arize/pre_releases.py

@@ -21,8 +21,9 @@ _WARNED: set[str] = set()
 
 
 def _format_prerelease_message(*, key: str, stage: ReleaseStage) -> str:
+    article = "an" if stage is ReleaseStage.ALPHA else "a"
     return (
-        f"[{stage.upper()}] {key} is an {stage} API "
+        f"[{stage.upper()}] {key} is {article} {stage} API "
         f"in Arize SDK v{__version__} and may change without notice."
     )
 

arize/projects/client.py

@@ -15,17 +15,22 @@ logger = logging.getLogger(__name__)
 
 
 class ProjectsClient:
-    """Client for managing Arize projects and project-level operations."""
+    """Client for managing Arize projects and project-level operations.
 
-    def __init__(self, *, sdk_config: SDKConfiguration) -> None:
-        """Create a projects sub-client.
+    This class is primarily intended for internal use within the SDK. Users are
+    highly encouraged to access resource-specific functionality via
+    :class:`arize.ArizeClient`.
 
-        The projects client is a thin wrapper around the generated REST API client,
-        using the shared generated API client owned by `SDKConfiguration`.
+    The projects client is a thin wrapper around the generated REST API client,
+    using the shared generated API client owned by
+    :class:`arize.config.SDKConfiguration`.
+    """
 
+    def __init__(self, *, sdk_config: SDKConfiguration) -> None:
+        """
         Args:
             sdk_config: Resolved SDK configuration.
-        """
+        """  # noqa: D205, D212
         self._sdk_config = sdk_config
 
         # Import at runtime so it's still lazy and extras-gated by the parent