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

arize/experiments/client.py

@@ -1,10 +1,12 @@
+"""Client implementation for managing experiments in the Arize platform."""
+
 from __future__ import annotations
 
-import hashlib
 import logging
-from typing import TYPE_CHECKING, Any, Dict, List, Tuple
+from typing import TYPE_CHECKING
 
 import opentelemetry.sdk.trace as trace_sdk
+import pandas as pd
 import pyarrow as pa
 from openinference.semconv.resource import ResourceAttributes
 from opentelemetry import trace
@@ -16,23 +18,16 @@ from opentelemetry.sdk.trace.export import (
     ConsoleSpanExporter,
     SimpleSpanProcessor,
 )
-from opentelemetry.trace import Tracer
 
 from arize._flight.client import ArizeFlightClient
 from arize._flight.types import FlightRequestType
 from arize._generated.api_client import models
-from arize.config import SDKConfiguration
 from arize.exceptions.base import INVALID_ARROW_CONVERSION_MSG
-from arize.experiments.evaluators.base import Evaluators
-from arize.experiments.evaluators.types import EvaluationResultFieldNames
 from arize.experiments.functions import (
     run_experiment,
     transform_to_experiment_format,
 )
-from arize.experiments.types import (
-    ExperimentTask,
-    ExperimentTaskResultFieldNames,
-)
+from arize.pre_releases import ReleaseStage, prerelease_endpoint
 from arize.utils.cache import cache_resource, load_cached_resource
 from arize.utils.openinference_conversion import (
     convert_boolean_columns_to_str,
@@ -41,16 +36,31 @@ from arize.utils.openinference_conversion import (
 from arize.utils.size import get_payload_size_mb
 
 if TYPE_CHECKING:
-    import pandas as pd
-
-    from arize._generated.api_client.models.experiment import Experiment
-
+    from opentelemetry.trace import Tracer
+
+    from arize.config import SDKConfiguration
+    from arize.experiments.evaluators.base import Evaluators
+    from arize.experiments.evaluators.types import EvaluationResultFieldNames
+    from arize.experiments.types import (
+        ExperimentTask,
+        ExperimentTaskResultFieldNames,
+    )
 
 logger = logging.getLogger(__name__)
 
 
 class ExperimentsClient:
-    def __init__(self, *, sdk_config: SDKConfiguration):
+    """Client for managing experiments including creation, execution, and result tracking."""
+
+    def __init__(self, *, sdk_config: SDKConfiguration) -> None:
+        """Create an experiments sub-client.
+
+        The experiments client is a thin wrapper around the generated REST API client,
+        using the shared generated API client owned by `SDKConfiguration`.
+
+        Args:
+            sdk_config: Resolved SDK configuration.
+        """
         self._sdk_config = sdk_config
         from arize._generated import api_client as gen
 
@@ -61,16 +71,277 @@ class ExperimentsClient:
             self._sdk_config.get_generated_client()
         )
 
-        self.list = self._api.experiments_list
-        self.get = self._api.experiments_get
-        self.delete = self._api.experiments_delete
+    @prerelease_endpoint(key="experiments.list", stage=ReleaseStage.BETA)
+    def list(
+        self,
+        *,
+        dataset_id: str | None = None,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> models.ExperimentsList200Response:
+        """List experiments the user has access to.
+
+        To filter experiments by the dataset they were run on, provide `dataset_id`.
+
+        Args:
+            dataset_id: Optional dataset ID to filter experiments.
+            limit: Maximum number of experiments to return. The server enforces an
+                upper bound.
+            cursor: Opaque pagination cursor returned from a previous response.
+
+        Returns:
+            A response object with the experiments and pagination information.
+
+        Raises:
+            arize._generated.api_client.exceptions.ApiException: If the REST API
+                returns an error response (e.g. 401/403/429).
+        """
+        return self._api.experiments_list(
+            dataset_id=dataset_id,
+            limit=limit,
+            cursor=cursor,
+        )
+
+    @prerelease_endpoint(key="experiments.create", stage=ReleaseStage.BETA)
+    def create(
+        self,
+        *,
+        name: str,
+        dataset_id: str,
+        experiment_runs: list[dict[str, object]] | pd.DataFrame,
+        task_fields: ExperimentTaskResultFieldNames,
+        evaluator_columns: dict[str, EvaluationResultFieldNames] | None = None,
+        force_http: bool = False,
+    ) -> models.Experiment:
+        """Create an experiment with one or more experiment runs.
+
+        Experiments are composed of runs. Each run must include:
+            - `example_id`: ID of an existing example in the dataset/version
+            - `output`: Model/task output for the matching example
+
+        You may include any additional user-defined fields per run (e.g. `model`,
+        `latency_ms`, `temperature`, `prompt`, `tool_calls`, etc.) that can be used
+        for analysis or filtering.
+
+        This method transforms the input runs into the server's expected experiment
+        format using `task_fields` and optional `evaluator_columns`.
+
+        Transport selection:
+            - If the payload is below the configured REST payload threshold (or
+              `force_http=True`), this method uploads via REST.
+            - Otherwise, it attempts a more efficient upload path via gRPC + Flight.
+
+        Args:
+            name: Experiment name. Must be unique within the target dataset.
+            dataset_id: Dataset ID to attach the experiment to.
+            experiment_runs: Experiment runs either as:
+                - a list of JSON-like dicts, or
+                - a pandas DataFrame.
+            task_fields: Mapping that identifies the columns/fields containing the
+                task results (e.g. `example_id`, output fields).
+            evaluator_columns: Optional mapping describing evaluator result columns.
+            force_http: If True, force REST upload even if the payload exceeds the
+                configured REST payload threshold.
+
+        Returns:
+            The created experiment object.
+
+        Raises:
+            TypeError: If `experiment_runs` is not a list of dicts or a DataFrame.
+            RuntimeError: If the Flight upload path is selected and the Flight request
+                fails.
+            arize._generated.api_client.exceptions.ApiException: If the REST API
+                returns an error response (e.g. 400/401/403/409/429).
+        """
+        if not isinstance(experiment_runs, list | pd.DataFrame):
+            raise TypeError(
+                "Experiment runs must be a list of dicts or a pandas DataFrame"
+            )
+        # transform experiment data to experiment format
+        experiment_df = transform_to_experiment_format(
+            experiment_runs, task_fields, evaluator_columns
+        )
+
+        below_threshold = (
+            get_payload_size_mb(experiment_runs)
+            <= self._sdk_config.max_http_payload_size_mb
+        )
+        if below_threshold or force_http:
+            from arize._generated import api_client as gen
+
+            data = experiment_df.to_dict(orient="records")
+
+            body = gen.ExperimentsCreateRequest(
+                name=name,
+                dataset_id=dataset_id,
+                experiment_runs=data,  # type: ignore
+            )
+            return self._api.experiments_create(experiments_create_request=body)
+
+        # If we have too many examples, try to convert to a dataframe
+        # and log via gRPC + flight
+        logger.info(
+            f"Uploading {len(experiment_df)} experiment runs via REST may be slow. "
+            "Trying for more efficient upload via gRPC + Flight."
+        )
+
+        # TODO(Kiko): Space ID should not be needed,
+        # should work on server tech debt to remove this
+        dataset = self._datasets_api.datasets_get(dataset_id=dataset_id)
+        space_id = dataset.space_id
+
+        return self._create_experiment_via_flight(
+            name=name,
+            dataset_id=dataset_id,
+            space_id=space_id,
+            experiment_df=experiment_df,
+        )
+
+    @prerelease_endpoint(key="experiments.get", stage=ReleaseStage.BETA)
+    def get(self, *, experiment_id: str) -> models.Experiment:
+        """Get an experiment by ID.
+
+        The response does not include the experiment's runs. Use `list_runs()` to
+        retrieve runs for an experiment.
+
+        Args:
+            experiment_id: Experiment ID to retrieve.
+
+        Returns:
+            The experiment object.
+
+        Raises:
+            arize._generated.api_client.exceptions.ApiException: If the REST API
+                returns an error response (e.g. 401/403/404/429).
+        """
+        return self._api.experiments_get(experiment_id=experiment_id)
+
+    @prerelease_endpoint(key="experiments.delete", stage=ReleaseStage.BETA)
+    def delete(self, *, experiment_id: str) -> None:
+        """Delete an experiment by ID.
+
+        This operation is irreversible.
+
+        Args:
+            experiment_id: Experiment ID to delete.
+
+        Returns: This method returns None on success (common empty 204 response)
+
+        Raises:
+            arize._generated.api_client.exceptions.ApiException: If the REST API
+                returns an error response (e.g. 401/403/404/429).
+        """
+        return self._api.experiments_delete(
+            experiment_id=experiment_id,
+        )
+
+    @prerelease_endpoint(key="experiments.list_runs", stage=ReleaseStage.BETA)
+    def list_runs(
+        self,
+        *,
+        experiment_id: str,
+        limit: int = 100,
+        all: bool = False,
+    ) -> models.ExperimentsRunsList200Response:
+        """List runs for an experiment.
+
+        Runs are returned in insertion order.
+
+        Pagination notes:
+            - The response includes `pagination` for forward compatibility.
+            - Cursor pagination may not be fully implemented by the server yet.
+            - If `all=True`, this method retrieves all runs via the Flight path and
+              returns them in a single response with `has_more=False`.
+
+        Args:
+            experiment_id: Experiment ID to list runs for.
+            limit: Maximum number of runs to return when `all=False`. The server
+                enforces an upper bound.
+            all: If True, fetch all runs (ignores `limit`) via Flight and return a
+                single response.
+
+        Returns:
+            A response object containing `experiment_runs` and `pagination` metadata.
+
+        Raises:
+            RuntimeError: If the Flight request fails or returns no response when
+                `all=True`.
+            arize._generated.api_client.exceptions.ApiException: If the REST API
+                returns an error response when `all=False` (e.g. 401/403/404/429).
+        """
+        if not all:
+            return self._api.experiments_runs_list(
+                experiment_id=experiment_id,
+                limit=limit,
+            )
+
+        experiment = self.get(experiment_id=experiment_id)
+        experiment_updated_at = getattr(experiment, "updated_at", None)
+        # TODO(Kiko): Space ID should not be needed,
+        # should work on server tech debt to remove this
+        dataset = self._datasets_api.datasets_get(
+            dataset_id=experiment.dataset_id
+        )
+        space_id = dataset.space_id
+
+        experiment_df = None
+        # try to load dataset from cache
+        if self._sdk_config.enable_caching:
+            experiment_df = load_cached_resource(
+                cache_dir=self._sdk_config.cache_dir,
+                resource="experiment",
+                resource_id=experiment_id,
+                resource_updated_at=experiment_updated_at,
+            )
+        if experiment_df is not None:
+            return models.ExperimentsRunsList200Response(
+                experimentRuns=experiment_df.to_dict(orient="records"),  # type: ignore
+                pagination=models.PaginationMetadata(
+                    has_more=False,  # Note that all=True
+                ),
+            )
 
-        # Custom methods
-        self.run = self._run_experiment
-        self.create = self._create_experiment
-        self.list_runs = self._api.experiments_runs_list
+        with ArizeFlightClient(
+            api_key=self._sdk_config.api_key,
+            host=self._sdk_config.flight_host,
+            port=self._sdk_config.flight_port,
+            scheme=self._sdk_config.flight_scheme,
+            request_verify=self._sdk_config.request_verify,
+            max_chunksize=self._sdk_config.pyarrow_max_chunksize,
+        ) as flight_client:
+            try:
+                experiment_df = flight_client.get_experiment_runs(
+                    space_id=space_id,
+                    experiment_id=experiment_id,
+                )
+            except Exception as e:
+                msg = f"Error during request: {e!s}"
+                logger.exception(msg)
+                raise RuntimeError(msg) from e
+        if experiment_df is None:
+            # This should not happen with proper Flight client implementation,
+            # but we handle it defensively
+            msg = "No response received from flight server during request"
+            logger.error(msg)
+            raise RuntimeError(msg)
 
-    def _run_experiment(
+        # cache experiment for future use
+        cache_resource(
+            cache_dir=self._sdk_config.cache_dir,
+            resource="experiment",
+            resource_id=experiment_id,
+            resource_updated_at=experiment_updated_at,
+            resource_data=experiment_df,
+        )
+
+        return models.ExperimentsRunsList200Response(
+            experimentRuns=experiment_df.to_dict(orient="records"),  # type: ignore
+            pagination=models.PaginationMetadata(
+                has_more=False,  # Note that all=True
+            ),
+        )
+
+    def run(
         self,
         *,
         name: str,
@@ -82,37 +353,46 @@ class ExperimentsClient:
         concurrency: int = 3,
         set_global_tracer_provider: bool = False,
         exit_on_error: bool = False,
-    ) -> Tuple[Experiment | None, pd.DataFrame] | None:
-        """
-        Run an experiment on a dataset and upload the results.
+    ) -> tuple[models.Experiment | None, pd.DataFrame]:
+        """Run an experiment on a dataset and optionally upload results.
+
+        This method executes a task against dataset examples, optionally evaluates
+        outputs, and (when `dry_run=False`) uploads results to Arize.
 
-        This function initializes an experiment, retrieves or uses a provided dataset,
-        runs the experiment with specified tasks and evaluators, and uploads the results.
+        High-level flow:
+            1) Resolve the dataset and `space_id`.
+            2) Download dataset examples (or load from cache if enabled).
+            3) Run the task and evaluators with configurable concurrency.
+            4) If not a dry run, upload experiment runs and return the created
+                experiment plus the results dataframe.
+
+        Notes:
+            - If `dry_run=True`, no data is uploaded and the returned experiment is
+              `None`.
+            - When `enable_caching=True`, dataset examples may be cached and reused.
 
         Args:
-            experiment_name (str): The name of the experiment.
-            task (ExperimentTask): The task to be performed in the experiment.
-            dataset_id (Optional[str], optional): The ID of the dataset to use.
-                Required if dataset_df and dataset_name are not provided. Defaults to None.
-            dataset_name (Optional[str], optional): The name of the dataset to use.
-                Used if dataset_df and dataset_id are not provided. Defaults to None.
-            evaluators (Optional[Evaluators], optional): The evaluators to use in the experiment.
-                Defaults to None.
-            dry_run (bool): If True, the experiment result will not be uploaded to Arize.
-                Defaults to False.
-            concurrency (int): The number of concurrent tasks to run. Defaults to 3.
-            set_global_tracer_provider (bool): If True, sets the global tracer provider for the experiment.
-                Defaults to False.
-            exit_on_error (bool): If True, the experiment will stop running on first occurrence of an error.
+            name: Experiment name.
+            dataset_id: Dataset ID to run the experiment against.
+            task: The task to execute for each dataset example.
+            evaluators: Optional evaluators used to score outputs.
+            dry_run: If True, do not upload results to Arize.
+            dry_run_count: Number of dataset rows to use when `dry_run=True`.
+            concurrency: Number of concurrent tasks to run.
+            set_global_tracer_provider: If True, sets the global OpenTelemetry tracer
+                provider for the experiment run.
+            exit_on_error: If True, stop on the first error encountered during
+                execution.
 
         Returns:
-            Tuple[str, pd.DataFrame]:
-                A tuple of experiment ID and experiment result DataFrame.
-                If dry_run is True, the experiment ID will be an empty string.
+            If `dry_run=True`, returns `(None, results_df)`.
+            If `dry_run=False`, returns `(experiment, results_df)`.
 
         Raises:
-            ValueError: If dataset_id and dataset_name are both not provided, or if the dataset is empty.
-            RuntimeError: If experiment initialization, dataset download, or result upload fails.
+            RuntimeError: If Flight operations (init/download/upload) fail or return
+                no response.
+            pa.ArrowInvalid: If converting results to Arrow fails.
+            Exception: For unexpected errors during Arrow conversion.
         """
         # TODO(Kiko): Space ID should not be needed,
         # should work on server tech debt to remove this
@@ -122,8 +402,8 @@ class ExperimentsClient:
 
         with ArizeFlightClient(
             api_key=self._sdk_config.api_key,
-            host=self._sdk_config.flight_server_host,
-            port=self._sdk_config.flight_server_port,
+            host=self._sdk_config.flight_host,
+            port=self._sdk_config.flight_port,
             scheme=self._sdk_config.flight_scheme,
             request_verify=self._sdk_config.request_verify,
             max_chunksize=self._sdk_config.pyarrow_max_chunksize,
@@ -141,8 +421,8 @@ class ExperimentsClient:
                         experiment_name=name,
                     )
                 except Exception as e:
-                    msg = f"Error during request: {str(e)}"
-                    logger.error(msg)
+                    msg = f"Error during request: {e!s}"
+                    logger.exception(msg)
                     raise RuntimeError(msg) from e
 
                 if response is None:
@@ -173,8 +453,8 @@ class ExperimentsClient:
                         dataset_id=dataset_id,
                     )
                 except Exception as e:
-                    msg = f"Error during request: {str(e)}"
-                    logger.error(msg)
+                    msg = f"Error during request: {e!s}"
+                    logger.exception(msg)
                     raise RuntimeError(msg) from e
                 if dataset_df is None:
                     # This should not happen with proper Flight client implementation,
@@ -232,12 +512,12 @@ class ExperimentsClient:
                 logger.debug("Converting data to Arrow format")
                 pa_table = pa.Table.from_pandas(output_df, preserve_index=False)
             except pa.ArrowInvalid as e:
-                logger.error(f"{INVALID_ARROW_CONVERSION_MSG}: {str(e)}")
+                logger.exception(INVALID_ARROW_CONVERSION_MSG)
                 raise pa.ArrowInvalid(
-                    f"Error converting to Arrow format: {str(e)}"
+                    f"Error converting to Arrow format: {e!s}"
                 ) from e
-            except Exception as e:
-                logger.error(f"Unexpected error creating Arrow table: {str(e)}")
+            except Exception:
+                logger.exception("Unexpected error creating Arrow table")
                 raise
 
             request_type = FlightRequestType.LOG_EXPERIMENT_DATA
@@ -251,8 +531,8 @@ class ExperimentsClient:
                     request_type=request_type,
                 )
             except Exception as e:
-                msg = f"Error during update request: {str(e)}"
-                logger.error(msg)
+                msg = f"Error during update request: {e!s}"
+                logger.exception(msg)
                 raise RuntimeError(msg) from e
 
             if post_resp is None:
@@ -267,200 +547,32 @@ class ExperimentsClient:
             )
             return experiment, output_df
 
-    def _create_experiment(
-        self,
-        *,
-        name: str,
-        dataset_id: str,
-        experiment_runs: List[Dict[str, Any]] | pd.DataFrame,
-        task_fields: ExperimentTaskResultFieldNames,
-        evaluator_columns: Dict[str, EvaluationResultFieldNames] | None = None,
-        force_http: bool = False,
-    ) -> Experiment:
-        """
-        Log an experiment to Arize.
-
-        Args:
-            space_id (str): The ID of the space where the experiment will be logged.
-            experiment_name (str): The name of the experiment.
-            experiment_df (pd.DataFrame): The data to be logged.
-            task_columns (ExperimentTaskResultColumnNames): The column names for task results.
-            evaluator_columns (Optional[Dict[str, EvaluationResultColumnNames]]):
-                The column names for evaluator results.
-            dataset_id (str, optional): The ID of the dataset associated with the experiment.
-                Required if dataset_name is not provided. Defaults to "".
-            dataset_name (str, optional): The name of the dataset associated with the experiment.
-                Required if dataset_id is not provided. Defaults to "".
-
-        Examples:
-            >>> # Example DataFrame:
-            >>> df = pd.DataFrame({
-            ...     "example_id": ["1", "2"],
-            ...     "result": ["success", "failure"],
-            ...     "accuracy": [0.95, 0.85],
-            ...     "ground_truth": ["A", "B"],
-            ...     "explanation_text": ["Good match", "Poor match"],
-            ...     "confidence": [0.9, 0.7],
-            ...     "model_version": ["v1", "v2"],
-            ...     "custom_metric": [0.8, 0.6],
-            ...})
-            ...
-            >>> # Define column mappings for task
-            >>> task_cols = ExperimentTaskResultColumnNames(
-            ...    example_id="example_id", result="result"
-            ...)
-            >>> # Define column mappings for evaluator
-            >>> evaluator_cols = EvaluationResultColumnNames(
-            ...     score="accuracy",
-            ...     label="ground_truth",
-            ...     explanation="explanation_text",
-            ...     metadata={
-            ...         "confidence": None,  # Will use "confidence" column
-            ...         "version": "model_version",  # Will use "model_version" column
-            ...         "custom_metric": None,  # Will use "custom_metric" column
-            ...     },
-            ... )
-            >>> # Use with ArizeDatasetsClient.log_experiment()
-            >>> ArizeDatasetsClient.log_experiment(
-            ...     space_id="my_space_id",
-            ...     experiment_name="my_experiment",
-            ...     experiment_df=df,
-            ...     task_columns=task_cols,
-            ...     evaluator_columns={"my_evaluator": evaluator_cols},
-            ...     dataset_name="my_dataset_name",
-            ... )
-
-        Returns:
-            Optional[str]: The ID of the logged experiment, or None if the logging failed.
-        """
-        if not isinstance(experiment_runs, (list, pd.DataFrame)):
-            raise TypeError(
-                "Examples must be a list of dicts or a pandas DataFrame"
-            )
-        # transform experiment data to experiment format
-        experiment_df = transform_to_experiment_format(
-            experiment_runs, task_fields, evaluator_columns
-        )
-
-        below_threshold = (
-            get_payload_size_mb(experiment_runs)
-            <= self._sdk_config.max_http_payload_size_mb
-        )
-        if below_threshold or force_http:
-            from arize._generated import api_client as gen
-
-            data = experiment_df.to_dict(orient="records")
-
-            body = gen.ExperimentsCreateRequest(
-                name=name,
-                datasetId=dataset_id,
-                experimentRuns=data,
-            )
-            return self._api.experiments_create(experiments_create_request=body)
-
-        # If we have too many examples, try to convert to a dataframe
-        # and log via gRPC + flight
-        logger.info(
-            f"Uploading {len(experiment_df)} experiment runs via REST may be slow. "
-            "Trying for more efficient upload via gRPC + Flight."
-        )
-
-        # TODO(Kiko): Space ID should not be needed,
-        # should work on server tech debt to remove this
-        dataset = self._datasets_api.datasets_get(dataset_id=dataset_id)
-        space_id = dataset.space_id
-
-        return self._create_experiment_via_flight(
-            name=name,
-            dataset_id=dataset_id,
-            space_id=space_id,
-            experiment_df=experiment_df,
-        )
-
-    def _list_runs(
-        self,
-        *,
-        experiment_id: str,
-        limit: int = 100,
-        all: bool = False,
-    ):
-        if not all:
-            return self._api.experiments_runs_list(
-                experiment_id=experiment_id,
-                limit=limit,
-            )
-
-        experiment = self.get(experiment_id=experiment_id)
-        experiment_updated_at = getattr(experiment, "updated_at", None)
-        # TODO(Kiko): Space ID should not be needed,
-        # should work on server tech debt to remove this
-        dataset = self._datasets_api.datasets_get(
-            dataset_id=experiment.dataset_id
-        )
-        space_id = dataset.space_id
-
-        experiment_df = None
-        # try to load dataset from cache
-        if self._sdk_config.enable_caching:
-            experiment_df = load_cached_resource(
-                cache_dir=self._sdk_config.cache_dir,
-                resource="experiment",
-                resource_id=experiment_id,
-                resource_updated_at=experiment_updated_at,
-            )
-        if experiment_df is not None:
-            return models.ExperimentsRunsList200Response(
-                experimentRuns=experiment_df.to_dict(orient="records")
-            )
-
-        with ArizeFlightClient(
-            api_key=self._sdk_config.api_key,
-            host=self._sdk_config.flight_server_host,
-            port=self._sdk_config.flight_server_port,
-            scheme=self._sdk_config.flight_scheme,
-            request_verify=self._sdk_config.request_verify,
-            max_chunksize=self._sdk_config.pyarrow_max_chunksize,
-        ) as flight_client:
-            try:
-                experiment_df = flight_client.get_experiment_runs(
-                    space_id=space_id,
-                    experiment_id=experiment_id,
-                )
-            except Exception as e:
-                msg = f"Error during request: {str(e)}"
-                logger.error(msg)
-                raise RuntimeError(msg) from e
-        if experiment_df is None:
-            # This should not happen with proper Flight client implementation,
-            # but we handle it defensively
-            msg = "No response received from flight server during request"
-            logger.error(msg)
-            raise RuntimeError(msg)
-
-        # cache dataset for future use
-        cache_resource(
-            cache_dir=self._sdk_config.cache_dir,
-            resource="dataset",
-            resource_id=experiment_id,
-            resource_updated_at=experiment_updated_at,
-            resource_data=experiment_df,
-        )
-
-        return models.ExperimentsRunsList200Response(
-            experimentRuns=experiment_df.to_dict(orient="records")
-        )
-
     def _create_experiment_via_flight(
         self,
         name: str,
         dataset_id: str,
         space_id: str,
         experiment_df: pd.DataFrame,
-    ) -> Experiment:
+    ) -> models.Experiment:
+        """Internal method to create an experiment using Flight protocol for large datasets."""
+        # Convert to Arrow table
+        try:
+            logger.debug("Converting data to Arrow format")
+            pa_table = pa.Table.from_pandas(experiment_df, preserve_index=False)
+        except pa.ArrowInvalid as e:
+            logger.exception(INVALID_ARROW_CONVERSION_MSG)
+            raise pa.ArrowInvalid(
+                f"Error converting to Arrow format: {e!s}"
+            ) from e
+        except Exception:
+            logger.exception("Unexpected error creating Arrow table")
+            raise
+
+        experiment_id = ""
         with ArizeFlightClient(
             api_key=self._sdk_config.api_key,
-            host=self._sdk_config.flight_server_host,
-            port=self._sdk_config.flight_server_port,
+            host=self._sdk_config.flight_host,
+            port=self._sdk_config.flight_port,
             scheme=self._sdk_config.flight_scheme,
             request_verify=self._sdk_config.request_verify,
             max_chunksize=self._sdk_config.pyarrow_max_chunksize,
@@ -474,8 +586,8 @@ class ExperimentsClient:
                     experiment_name=name,
                 )
             except Exception as e:
-                msg = f"Error during request: {str(e)}"
-                logger.error(msg)
+                msg = f"Error during request: {e!s}"
+                logger.exception(msg)
                 raise RuntimeError(msg) from e
 
             if response is None:
@@ -484,49 +596,39 @@ class ExperimentsClient:
                 msg = "No response received from flight server during request"
                 logger.error(msg)
                 raise RuntimeError(msg)
-            experiment_id, _ = response
 
-        # Convert to Arrow table
-        try:
-            logger.debug("Converting data to Arrow format")
-            pa_table = pa.Table.from_pandas(experiment_df, preserve_index=False)
-        except pa.ArrowInvalid as e:
-            logger.error(f"{INVALID_ARROW_CONVERSION_MSG}: {str(e)}")
-            raise pa.ArrowInvalid(
-                f"Error converting to Arrow format: {str(e)}"
-            ) from e
-        except Exception as e:
-            logger.error(f"Unexpected error creating Arrow table: {str(e)}")
-            raise
+            experiment_id, _ = response
+            if not experiment_id:
+                msg = "No experiment ID received from flight server during request"
+                logger.error(msg)
+                raise RuntimeError(msg)
 
-        request_type = FlightRequestType.LOG_EXPERIMENT_DATA
-        post_resp = None
-        try:
-            post_resp = flight_client.log_arrow_table(
-                space_id=space_id,
-                pa_table=pa_table,
-                dataset_id=dataset_id,
-                experiment_name=experiment_id,
-                request_type=request_type,
-            )
-        except Exception as e:
-            msg = f"Error during update request: {str(e)}"
-            logger.error(msg)
-            raise RuntimeError(msg) from e
+            request_type = FlightRequestType.LOG_EXPERIMENT_DATA
+            post_resp = None
+            try:
+                post_resp = flight_client.log_arrow_table(
+                    space_id=space_id,
+                    pa_table=pa_table,
+                    dataset_id=dataset_id,
+                    experiment_name=name,
+                    request_type=request_type,
+                )
+            except Exception as e:
+                msg = f"Error during update request: {e!s}"
+                logger.exception(msg)
+                raise RuntimeError(msg) from e
 
-        if post_resp is None:
-            # This should not happen with proper Flight client implementation,
-            # but we handle it defensively
-            msg = "No response received from flight server during request"
-            logger.error(msg)
-            raise RuntimeError(msg)
+            if post_resp is None:
+                # This should not happen with proper Flight client implementation,
+                # but we handle it defensively
+                msg = "No response received from flight server during request"
+                logger.error(msg)
+                raise RuntimeError(msg)
 
-        experiment = self.get(
+        return self.get(
             experiment_id=str(post_resp.experiment_id)  # type: ignore
         )
 
-        return experiment
-
 
 def _get_tracer_resource(
     project_name: str,
@@ -535,7 +637,8 @@ def _get_tracer_resource(
     endpoint: str,
     dry_run: bool = False,
     set_global_tracer_provider: bool = False,
-) -> Tuple[Tracer, Resource]:
+) -> tuple[Tracer, Resource]:
+    """Initialize and return an OpenTelemetry tracer and resource for experiment tracing."""
     resource = Resource(
         {
             ResourceAttributes.PROJECT_NAME: project_name,
@@ -547,7 +650,8 @@ def _get_tracer_resource(
         "arize-space-id": space_id,
         "arize-interface": "otel",
     }
-    insecure = endpoint.startswith("http://")
+    use_tls = any(endpoint.startswith(v) for v in ["https://", "grpc+tls://"])
+    insecure = not use_tls
     exporter = (
         ConsoleSpanExporter()
         if dry_run