fiddler-client 3.5.0.dev1__py3-none-any.whl → 3.6.0.dev1__py3-none-any.whl

fiddler/VERSION

@@ -1 +1 @@
-3.5.0.dev1
+3.6.0.dev1

fiddler/__init__.py

@@ -57,7 +57,6 @@ from fiddler.schemas.xai import (  # noqa
     DatasetDataSource,
     EventIdDataSource,
     RowDataSource,
-    SqlSliceQueryDataSource,
 )
 from fiddler.schemas.xai_params import XaiParams  # noqa
 from fiddler.utils.helpers import group_by  # noqa
@@ -110,7 +109,6 @@ __all__ = [
     'ModelTaskParams',
     'Multivariate',
     'RowDataSource',
-    'SqlSliceQueryDataSource',
     'TextEmbedding',
     'VectorFeature',
     'XaiParams',

fiddler/configs.py

@@ -1,8 +1,13 @@
 DEFAULT_CONNECTION_TIMEOUT = 60  # In seconds
 MIN_SERVER_VERSION = '24.4.0'
 DEFAULT_PAGE_SIZE = 50
-JOB_POLL_INTERVAL = 3
+
+# In seconds. For example, this generates a log message every N seconds.
+# Was once set to 3, and I think that was too frequent. If this needs to
+# be snappier, we can grow the interval.
+JOB_POLL_INTERVAL = 6
 JOB_WAIT_TIMEOUT = 1800
+
 STREAM_EVENT_LIMIT = 1000
 DEFAULT_NUM_CLUSTERS = 5
 DEFAULT_NUM_TAGS = 5

fiddler/decorators.py

@@ -3,6 +3,7 @@ from http import HTTPStatus
 from typing import Any, Callable, TypeVar, cast
 
 import requests
+import pydantic
 
 from fiddler.exceptions import ApiError, Conflict, HttpError, NotFound, Unsupported
 from fiddler.schemas.response import ErrorResponse
@@ -15,36 +16,67 @@ _WrappedFuncType = TypeVar(  # pylint: disable=invalid-name
 )
 
 
-def handle_api_error(func: _WrappedFuncType) -> _WrappedFuncType:
+# ignore: fiddler/decorators.py:19:1: C901 'handle_api_error' is too complex (11)
+def handle_api_error(func: _WrappedFuncType) -> _WrappedFuncType:  # noqa: C901
     @wraps(func)
     def wrapper(*args: Any, **kwargs: Any) -> Any:
         try:
             return func(*args, **kwargs)
         except requests.JSONDecodeError as e:
+            # This often is premature use of `json()`. Calling code should
+            # first check the response for the expected status code, and only
+            # then attempt JSON-deserialization.
             raise HttpError(message=f'Invalid JSON response - {e.doc}')  # type: ignore
-        except requests.HTTPError as e:
-            logger.error(
-                'HTTP request to %s failed with %s - %s',
-                getattr(e.request, 'url', 'unknown'),
-                getattr(e.response, 'status_code', 'unknown'),
-                getattr(e.response, 'content', 'missing'),
+        except requests.HTTPError as http_exc:
+            # Note(JP): when we're here it means we got an HTTP response.
+            # That's how this exception is documented.
+
+            status = http_exc.response.status_code
+            # The logging levels 'critical' and 'error' are generally meant to
+            # be used for terminal / fatal errors. Here, we handle many
+            # transient (retryable) errors, and it's fair to log them not as
+            # serious as actual errors. Therefore level WARNING and not ERROR.
+            # Even INFO might make sense.
+            logger.warning(
+                '%s HTTP request to %s failed with %s - %s',
+                http_exc.request.method,
+                getattr(http_exc.request, 'url', 'unknown'),
+                status,
+                # Not entire response body in case we have a megabyte response.
+                getattr(http_exc.response, 'content', 'missing')[:200],
             )
 
-            status_code = e.response.status_code or HTTPStatus.INTERNAL_SERVER_ERROR
+            # Now, map the error at hand to an exception to be thrown towards
+            # the caller.
 
-            if status_code == HTTPStatus.METHOD_NOT_ALLOWED:
+            if status == HTTPStatus.METHOD_NOT_ALLOWED:
                 raise Unsupported()
 
+            # Did we get structured error information? This might even
+            # be wrapped in a 501 response for example.
             try:
-                error_resp = ErrorResponse(**e.response.json())
+                # https://github.com/fiddler-labs/fiddler/issues/9314
+                error_resp = ErrorResponse(**http_exc.response.json())
+            except pydantic.ValidationError:
+                # We couldn't turn the HTTP error response into an object
+                # satisfying model='ErrorResponse'. Now, instead of exposing
+                # this to users as a pydantic.ValidationError (which is kinda
+                # useless to them) -- just re-raise requests.HTTPError, with
+                # all its useful error detail -- it is likely to show the
+                # actual problem.
+                raise http_exc
             except requests.JSONDecodeError:
-                raise HttpError(
-                    message=f"Invalid response content-type - {e.response.content}"  # type: ignore
-                )
+                # Re-raise requests.HTTPError, with all its useful error
+                # detail.
+                raise http_exc
+
+            # This code path is only reachable if we could successfully
+            # deserialize an ErrorResponse object from the HTTP response body.
 
-            if status_code == HTTPStatus.CONFLICT:
+            if status == HTTPStatus.CONFLICT:
                 raise Conflict(error_resp.error)
-            if status_code == HTTPStatus.NOT_FOUND:
+
+            if status == HTTPStatus.NOT_FOUND:
                 raise NotFound(error_resp.error)
 
             raise ApiError(error_resp.error)

fiddler/entities/alert_rule.py

@@ -247,7 +247,7 @@ class AlertRule(
             url=self._get_url(id_=self.id), data={'enable_notification': True}
         )
         logger.info(
-            'Notifications have been enabled for alert rule with id: %s', self.id
+            'notifications have been enabled for alert rule with id: %s', self.id
         )
 
     @handle_api_error

fiddler/entities/job.py

@@ -4,6 +4,8 @@ import time
 from typing import Iterator
 from uuid import UUID
 
+import requests
+
 from fiddler.configs import JOB_POLL_INTERVAL, JOB_WAIT_TIMEOUT
 from fiddler.constants.job import JobStatus
 from fiddler.decorators import handle_api_error
@@ -112,24 +114,57 @@ class Job(BaseEntity):  # pylint: disable=too-many-instance-attributes
         :return: Iterator of job objects
         """
         assert self.id is not None
+        deadline = time.monotonic() + timeout
 
-        start_time = time.time()
         while True:
+
+            if time.monotonic() > deadline:
+                raise TimeoutError(f'Deadline exceeded while watching job {self.id}')
+
             try:
-                response = self._client().get(url=self._get_url(id_=self.id))
+                # This can raise requests.HTTPError to represent non-2xx
+                # responses.
+                response = self._client().get(
+                    url=self._get_url(id_=self.id),
+                    # Short-ish TCP connect timeout, to stay responsive in
+                    # terms of logging. The HTTP response latency for GET
+                    # /jobs/<id> is expected to be less than couple of seconds
+                    # (i.e., 30 s includes lots of  leeway).
+                    timeout=(5, 30),
+                    # Inject `retry="off"` to disable the centralized retry
+                    # machinery: ask for being confronted with the details
+                    # (throw exceptions my way, so I an do my own "responsive"
+                    # type of retrying). Otherwise, we'd give up control.
+                    retry="off",
+                )
                 self._refresh_from_response(response)
-            except ConnectionError:
-                logger.exception(
-                    'Failed to connect to the server. Retrying...\n'
-                    'If this error persists, please reach out to Fiddler.'
+
+            except requests.exceptions.HTTPError as exc:
+                # Note(JP): got a non-2xx HTTP response. The main purpose of
+                # this handler is to keep going after having received a 5xx
+                # response. In this case of GETting job status even some 404s
+                # might be worth retrying. That is, it's fine to give up only
+                # after reaching the deadline even if we collect some 4xx
+                # responses along the way. Noteworthy: Receiving a 5xx response
+                # here is not an error, it's an expected scenario to be
+                # accounted for.
+                logger.info(
+                    'watch: ignore unexpected response %s (URL: %s, response body prefix: %s...)',
+                    exc.response,
+                    exc.request.url,
+                    exc.response.text[:120],
                 )
                 continue
 
-            yield self
+            except requests.exceptions.RequestException:
+                # This error is in the hierarchy _above_ `HTTPError`, and in
+                # this setup catches all errors that are _not_ a bad response:
+                # DNS error, TCP connect timeout, err during sending request,
+                # err during receiving response. Rely on the error detail to
+                # have already been logged.
+                continue
 
-            current_time = time.time()
-            if (current_time - start_time) > timeout:
-                raise TimeoutError(f'Timed out while watching job {self.id}')
+            yield self
 
             if self.status in [
                 JobStatus.SUCCESS,
@@ -153,7 +188,7 @@ class Job(BaseEntity):  # pylint: disable=too-many-instance-attributes
 
         for job in self.watch(interval=interval, timeout=timeout):
             logger.info(
-                '%s: status - %s, progress - %.2f%%',
+                '%s: %s, progress: %.1f%%',
                 log_prefix,
                 job.status,
                 job.progress,

fiddler/entities/xai.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import os
 from collections import namedtuple
 from datetime import datetime, timezone
-from io import BytesIO
 from pathlib import Path
 from typing import Any, Callable
 from uuid import UUID
@@ -18,15 +17,10 @@ from fiddler.constants.xai import (
 )
 from fiddler.decorators import handle_api_error
 from fiddler.entities.job import Job
+from fiddler.exceptions import Unsupported
 from fiddler.schemas.job import JobCompactResp
-from fiddler.schemas.xai import (
-    DatasetDataSource,
-    EventIdDataSource,
-    RowDataSource,
-    SqlSliceQueryDataSource,
-)
+from fiddler.schemas.xai import DatasetDataSource, EventIdDataSource, RowDataSource
 from fiddler.utils.decorators import check_version
-from fiddler.utils.helpers import try_series_retype
 from fiddler.utils.logger import get_logger
 
 logger = get_logger(__name__)
@@ -44,7 +38,7 @@ class XaiMixin:
     def explain(  # pylint: disable=too-many-arguments
         self,
         input_data_source: RowDataSource | EventIdDataSource,
-        ref_data_source: DatasetDataSource | SqlSliceQueryDataSource | None = None,
+        ref_data_source: DatasetDataSource | None = None,
         method: ExplainMethod | str = ExplainMethod.FIDDLER_SHAP,
         num_permutations: int | None = None,
         ci_level: float | None = None,
@@ -55,8 +49,8 @@ class XaiMixin:
 
         :param input_data_source: DataSource for the input data to compute explanation
             on (RowDataSource, EventIdDataSource)
-        :param ref_data_source: DataSource for the reference data to compute explanation
-            on (DatasetDataSource, SqlSliceQueryDataSource).
+        :param ref_data_source: Dataset data source for the reference data to compute explanation
+            on.
             Only used for non-text models and the following methods:
             'SHAP', 'FIDDLER_SHAP', 'PERMUTE', 'MEAN_RESET'
         :param method: Explanation method name. Could be your custom
@@ -102,7 +96,7 @@ class XaiMixin:
         sample: bool = False,
         max_rows: int | None = None,
         columns: list[str] | None = None,
-    ) -> pd.DataFrame:
+    ) -> None:
         """
         Fetch data with slice query.
 
@@ -111,35 +105,12 @@ class XaiMixin:
                         columns to select overriding columns selected in the query.
         :param max_rows: Number of maximum rows to fetch
         :param sample: Whether rows should be sample or not from the database
-
         :return: Dataframe of the query output
         """
-        self._check_id_attributes()
-
-        payload: dict[str, Any] = {
-            'model_id': self.id,
-            'query': query,
-            'sample': sample,
-        }
-        if max_rows:
-            payload['max_rows'] = max_rows
-        if columns:
-            payload['columns'] = columns
-
-        response = self._client().post(
-            url='/v3/slice-query/fetch',
-            data=payload,
+        raise Unsupported(
+            'This method is not supported since version 3.4. Please use `model.download_data` instead.'
         )
 
-        response_dict = response.json()['data']
-
-        column_names = response_dict['metadata']['columns']
-        dtype_strings = response_dict['metadata']['dtypes']
-        df = pd.DataFrame(response_dict['rows'], columns=column_names)
-        for column_name, dtype in zip(column_names, dtype_strings):
-            df[column_name] = try_series_retype(df[column_name], dtype)
-        return df
-
     @handle_api_error
     def download_data(  # pylint: disable=too-many-arguments
         self,
@@ -250,25 +221,9 @@ class XaiMixin:
         :param max_rows: Number of maximum rows to fetch
         :param sample: Whether rows should be sample or not from the database
         """
-        self._check_id_attributes()
-        output_dir = Path(output_dir)
-        if not output_dir.exists():
-            os.makedirs(output_dir)
-        payload: dict[str, Any] = {
-            'model_id': self.id,
-            'query': query,
-            'sample': sample,
-        }
-        if max_rows:
-            payload['max_rows'] = max_rows
-        if columns:
-            payload['columns'] = columns
-
-        file_path = os.path.join(output_dir, 'output.parquet')
-        with self._client().post(url='/v3/slice-query/download', data=payload) as resp:
-            # Download parquet file
-            df = pd.read_parquet(BytesIO(resp.content))
-            df.to_parquet(file_path)
+        raise Unsupported(
+            'This method is not supported since version 3.4. Please use `model.download_data` instead.'
+        )
 
     @handle_api_error
     def get_mutual_info(
@@ -277,7 +232,7 @@ class XaiMixin:
         column_name: str,
         num_samples: int | None = None,
         normalized: bool = False,
-    ) -> dict:
+    ) -> None:
         """
         Get mutual information.
 
@@ -290,27 +245,10 @@ class XaiMixin:
                all the variables in the dataset.
         :param num_samples: Number of samples to select for computation
         :param normalized: If set to True, it will compute Normalized Mutual Information
-
         :return: a dictionary of mutual information w.r.t the given feature
                  for each column given
         """
-        self._check_id_attributes()
-
-        payload: dict[str, Any] = {
-            'model_id': self.id,
-            'query': query,
-            'column_name': column_name,
-            'normalized': normalized,
-        }
-        if num_samples:
-            payload['num_samples'] = num_samples
-
-        response = self._client().post(
-            url='/v3/analytics/mutual-info',
-            data=payload,
-        )
-
-        return response.json()['data']
+        raise Unsupported('This method is not supported since version 3.4.')
 
     @handle_api_error
     def predict(
@@ -344,7 +282,7 @@ class XaiMixin:
     @handle_api_error
     def get_feature_impact(  # pylint: disable=too-many-arguments
         self,
-        data_source: DatasetDataSource | SqlSliceQueryDataSource,
+        data_source: DatasetDataSource,
         num_iterations: int | None = None,
         num_refs: int | None = None,
         ci_level: float | None = None,
@@ -354,8 +292,8 @@ class XaiMixin:
         """
         Get global feature impact for a model over a dataset or a slice.
 
-        :param data_source: DataSource for the input dataset to compute feature
-            impact on (DatasetDataSource or SqlSliceQueryDataSource)
+        :param data_source: Dataset data Source for the input dataset to compute feature
+            impact on
         :param num_iterations: The maximum number of ablated model inferences per feature
         :param num_refs: The number of reference points used in the explanation
         :param ci_level: The confidence level (between 0 and 1)
@@ -398,7 +336,7 @@ class XaiMixin:
     @handle_api_error
     def get_feature_importance(  # pylint: disable=too-many-arguments
         self,
-        data_source: DatasetDataSource | SqlSliceQueryDataSource,
+        data_source: DatasetDataSource,
         num_iterations: int | None = None,
         num_refs: int | None = None,
         ci_level: float | None = None,
@@ -406,8 +344,8 @@ class XaiMixin:
         """
         Get global feature importance for a model over a dataset or a slice.
 
-        :param data_source: DataSource for the input dataset to compute feature
-            importance on (DatasetDataSource or SqlSliceQueryDataSource)
+        :param data_source: Dataset data aSource for the input dataset to compute feature
+            importance on
         :param num_iterations: The maximum number of ablated model inferences per feature
         :param num_refs: The number of reference points used in the explanation
         :param ci_level: The confidence level (between 0 and 1)

fiddler/exceptions.py

@@ -17,6 +17,8 @@ class BaseError(Exception):
         super().__init__(self.message)
 
     def __str__(self) -> str:
+        # It would be better to prepend context: like FiddlerBaseError. Note
+        # that this here is the string representation of an exception.
         return str(self.message)
 
     @property
@@ -53,17 +55,26 @@ class Unsupported(BaseError):
 
 
 class HttpError(BaseError):
-    """Base class for all HTTP errors"""
+    """Base class for all HTTP errors
+
+    Deprecated. Not thrown anymore.
+    """
 
 
 class ConnTimeout(HttpError):
-    """Connection timeout error"""
+    """Connection timeout error
+
+    Deprecated. Not thrown anymore.
+    """
 
     message = 'Request timed out while trying to reach endpoint'
 
 
 class ConnError(HttpError):
-    """Connection error"""
+    """Connection error
+
+    Deprecated. Not thrown anymore.
+    """
 
     message = 'Unable to reach the given endpoint'
 

fiddler/libs/http_client.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import time
 from copy import deepcopy
 from typing import Any
 from urllib.parse import urljoin
@@ -10,16 +11,11 @@ from requests.adapters import HTTPAdapter
 
 import fiddler.libs.aws
 from fiddler.constants.common import JSON_CONTENT_TYPE
-from fiddler.exceptions import (  # pylint: disable=redefined-builtin
-    ConnError,
-    ConnTimeout,
-    HttpError,
-)
+from fiddler.exceptions import HttpError, BaseError  # pylint: disable=redefined-builtin
 from fiddler.libs.json_encoder import RequestClientJSONEncoder
 from fiddler.utils.logger import get_logger
 
-logger = get_logger(__name__)
-
+log = get_logger(__name__)
 
 # Note(JP): this is doing conditional runtime modification for AWS Hadron /
 # SageMaker, depending on
@@ -38,7 +34,21 @@ class RequestClient:
         verify: bool = True,
         proxies: dict | None = None,
     ) -> None:
-        """Construct a request instance."""
+        """
+        HTTP client abstraction.
+
+        For centralized logging and retrying and error handling
+        """
+
+        # The default retry mechanism keep retrying HTTP requests up to a
+        # certain deadline N seconds in the future. The idea is to survive
+        # micro outages, i.e. this should be O(1 min). Idea: make configurable,
+        # maybe have a conservative default and then we can tune this in our CI
+        # to try longer.
+        self.default_retry_for_seconds = 60 * 10
+        self.timeout_long_running_requests = (5, 120)
+        self.timeout_short_running_requests = (5, 15)
+
         self.base_url = base_url
         self.proxies = proxies
         self.headers = headers
@@ -55,6 +65,7 @@ class RequestClient:
 
         self.session.verify = verify
         adapter = HTTPAdapter(
+            # Note(JP): what's the relevance of setting these?
             pool_connections=25,
             pool_maxsize=25,
         )
@@ -63,7 +74,7 @@ class RequestClient:
         # change from above?
         self.session.mount(self.base_url, adapter)
 
-    def call(
+    def _request_with_retry(
         self,
         *,
         method: str,
@@ -71,11 +82,13 @@ class RequestClient:
         params: dict | None = None,
         headers: dict | None = None,
         data: dict | bytes | None = None,
-        timeout: int | None = None,
+        timeout: float | tuple[float, float] | None = None,
         **kwargs: Any,
     ) -> requests.Response:
         """
-        Make request to server
+        Emit HTTP request.
+
+        Always apply retry strategy, unless told not to.
 
         :param method: HTTP method like
         :param url: API endpoint
@@ -83,12 +96,11 @@ class RequestClient:
         :param headers: Request headers
         :param data: Dict/binary data
         :param timeout: Request timeout in seconds
+        :param kwargs: passed on to requests.session.request()
         """
-        logger.debug('Making %s call to %s', method, url)
-
-        full_url = urljoin(self.base_url, url)
-
+        abs_url = urljoin(self.base_url, url)
         request_headers = self.headers
+
         # override/update headers coming from the calling method
         if headers:
             request_headers = deepcopy(self.headers)
@@ -96,38 +108,220 @@ class RequestClient:
 
         content_type = request_headers.get('Content-Type')
         if data is not None and content_type == JSON_CONTENT_TYPE:
-            data = simplejson.dumps(data, ignore_nan=True, cls=RequestClientJSONEncoder)  # type: ignore
+            # Why did we decide on simplejson here instead of stdlib? For
+            # behavior, for perf?
+            data = simplejson.dumps(
+                data, ignore_nan=True, cls=RequestClientJSONEncoder  # type: ignore
+            )
 
+        # Use `setdefault`: define properties in kwargs when the caller doesn't
+        # specify. verify: default to session config, but allow for override.
         kwargs.setdefault('allow_redirects', True)
-        # requests is not able to pass the value of self.session.verify to the
-        # verify param in kwargs when REQUESTS_CA_BUNDLE is set.
-        # So setting that as default here
         kwargs.setdefault('verify', self.session.verify)
+
+        # Construct dictionary of parameters passed to session.request() with
+        # all parameters except for method and URL.
+        kwargs.update(
+            {
+                "params": params,
+                "data": data,
+                "headers": request_headers,
+                "timeout": timeout,
+                "proxies": self.proxies,
+            }
+        )
+
+        return self._make_request_retry_until_deadline(method, abs_url, **kwargs)
+
+    def _make_request_retry_until_deadline(
+        self, method: str, url: str, **kwargs: Any
+    ) -> requests.Response:
+        """
+        Return `requests.Response` object when the request was sent out and
+        responded to with an HTTP response with a 2xx status code.
+
+        Implement a retry loop with deadline control.
+
+        Raise an exception derived from `requests.exceptions.RequestException`
+        to indicate a non-retryable error, such as various 4xx responses.
+
+        Interrupt the retry loop and raise ryingHTTPClientNonRetryableResponse
+
+        Raise `fiddler.exceptions.BaseError` (from last exception) when
+        reaching the deadline (it might raise a minute early, or even be
+        briefly exceeded).
+        """
+        logpfx = f"http: {method} {url} --"
+
+        t0 = time.monotonic()
+        deadline = t0 + self.default_retry_for_seconds
+        cycle: int = 0
+
+        log.debug("%s try", logpfx)
+
+        while time.monotonic() < deadline:
+            cycle += 1
+
+            result = self._make_request_retry_guts(method, url, **kwargs)
+
+            if isinstance(result, requests.Response):
+                if cycle > 1:
+                    log.info("%s success after %.3f s", logpfx, time.monotonic() - t0)
+                return result
+
+            # Rename, for clarity. This exception was considered retryable, but
+            # we may have to throw it below upon approaching the deadline.
+            last_exception = result
+
+            # Desired behavior: rather fast first retry attempt; followed by
+            # slow exponential growth, and an upper bound: 0.66, 1.33, 2.66,
+            # 5.33, 10.66, 21.33, 42.66, 60, 60, .... (seconds)
+            wait_seconds = min((2**cycle) / 3.0, 60)
+            log.info(
+                "%s cycle %s failed, wait for %.1f s, deadline in %.1f min",
+                logpfx,
+                cycle,
+                wait_seconds,
+                (deadline - time.monotonic()) / 60.0,
+            )
+
+            # Would the next wait exceed the deadline?
+            if (time.monotonic() + wait_seconds) > deadline:
+                break
+
+            time.sleep(wait_seconds)
+
+        # Give up after retrying. Structurally emit error detail of last seen
+        # (retryable) exception.
+        raise BaseError(
+            f"{method} request to {url}: giving up after {time.monotonic() - t0:.3f} s"
+        ) from last_exception
+
+    def _make_request_retry_guts(
+        self, method: str, url: str, **kwargs: Any
+    ) -> requests.Response | requests.RequestException:
+        """
+        Return `requests.Response` object when the request was sent out and
+        responded to with an HTTP response that does not throw upon
+        `resp.raise_for_status()` (a 2xx status code).
+
+        Return an exception object to indicate a _retryable_ error to the
+        caller. The caller will then retry.
+
+        Raise an exception derived from `requests.exceptions.RequestException`
+        to indicate a non-retryable error, such as various 4xx responses.
+        """
+        logpfx = f"http: {method} {url} --"
+
+        if "timeout" not in kwargs:
+            kwargs["timeout"] = self.timeout_long_running_requests
+
+        # Magic argument passed down to here. Can be set to "off".
+        retry_strategy = kwargs.pop('retry', 'default')
+
+        t0 = time.monotonic()
+        log.info("%s emit", logpfx)
+
+        try:
+            # Here, we want to have a tight TCP connect() timeout and a
+            # meaningful TCP recv timeout, also a meaningful global
+            # request-response cycle timeout (accounting for the ~expected HTTP
+            # request processing time in the API implementation, plus leeway).
+            resp = self.session.request(method=method, url=url, **kwargs)
+        except requests.exceptions.RequestException as exc:
+
+            if retry_strategy == "off":
+                log.info("%s error: %s", logpfx, exc)
+                # Do not retry, let the caller deal with this exception.
+                raise
+
+            # Note(JP): we did not get a response. We might not even have sent
+            # the request. An error happened before sending the request, while
+            # sending the request, while waiting for response, or while
+            # receiving the response. High probability for this being a
+            # transient problem. A few examples for errors handled here:
+            #
+            # - DNS resolution error
+            # - TCP connect() timeout
+            # - Connection refused during TCP connect()
+            # - Timeout while waiting for the other end to start sending the
+            #   HTTP response (after having sent the request).
+            # - RECV timeout between trying to receive two response bytes.
+            #
+            # Note(JP): do this, regardless of the type of request that we
+            # sent. I know we've expressed concerns about idempotency here and
+            # there. But I believe that it will be a big step forward to have
+            # more or less *easy-to-reason-about* retrying in the client and to
+            # maybe risk a rare idempotency problem and debug it and fix it in
+            # the backend.
+
+            # Convention: returning the exception tells the caller to retry.
+            log.info("%s retry soon: %s", logpfx, exc)
+            return exc
+
+        # Got an HTTP response. In the scope below, `resp` reflects that.
+        log.info(
+            "%s request took %.3f s, response code: %s, resp body size: %s, req body size: %s",
+            logpfx,
+            time.monotonic() - t0,
+            resp.status_code,
+            len(resp.content),
+            0 if resp.request.body is None else len(resp.request.body),
+        )
+
         try:
-            response = self.session.request(
-                method,
-                full_url,
-                params=params,
-                data=data,
-                headers=request_headers,
-                timeout=timeout,
-                proxies=self.proxies,
-                **kwargs,
+            resp.raise_for_status()
+
+            # The criterion for a good-looking response. Ideally we check for
+            # the _precisely_ expected status code, but can do that later.
+            return resp
+        except requests.HTTPError as exc:
+            # Decide whether or not this is a retryable based on the response
+            # details. Put into a log message before leaving this function.
+            treat_retryable = self._is_retryable_resp(resp)
+
+            # Log body prefix: sometimes this is critical for debuggability.
+            log.warning(
+                "%s error response with code %s%s, body bytes: <%s ...>",
+                logpfx,
+                resp.status_code,
+                " (treat retryable)" if treat_retryable else "",
+                resp.text[:500],
             )
 
-        except requests.Timeout as exc:
-            logger.error('%s call failed with Timeout error for URL %s', method, url)
-            raise ConnTimeout() from exc
-        except requests.ConnectionError as exc:
-            logger.error('%s call failed with ConnectionError for URL %s', method, url)
-            raise ConnError() from exc
-        except requests.RequestException as exc:
-            # catastrophic error.
-            logger.error('%s call failed with RequestException for %s', method, url)
-            raise HttpError() from exc
+            if retry_strategy == "off":
+                raise
+
+            if treat_retryable:
+                return exc
+
+            # Otherwise let this nice requests.HTTPError object bubble up to
+            # calling code. This is the expected code path for most 4xx
+            # error responses.
+            raise
+
+    def _is_retryable_resp(self, resp: requests.Response) -> bool:
+        """
+        Do we (want to) consider this response as retryable, based on the
+        status code alone?
+        """
+        if resp.status_code == 429:
+            # Canonical way to signal "back off, retry soon".
+            return True
+
+        if resp.status_code == 501:
+            # Means: "not implemented" or "not supported". Might be a little
+            # exotic to use but we seem to rely on it. Do not retry those
+            # for now, in general
+            return False
+
+        # Retry any 5xx response, later maybe fine-tune this by specific status
+        # code. Certain 500 Internal Server Error are probably permanent, but
+        # it's worth retrying them, too.
+        if str(resp.status_code).startswith("5"):
+            return True
 
-        response.raise_for_status()
-        return response
+        return False
 
     def get(
         self,
@@ -135,11 +329,10 @@ class RequestClient:
         url: str,
         params: dict | None = None,
         headers: dict | None = None,
-        timeout: int | None = None,
-        **kwargs: dict[str, Any],
+        timeout: float | tuple[float, float] | None = None,
+        **kwargs: Any,
     ) -> requests.Response:
-        """Construct a get request instance."""
-        return self.call(
+        return self._request_with_retry(
             method='GET',
             url=url,
             params=params,
@@ -155,10 +348,9 @@ class RequestClient:
         params: dict | None = None,
         headers: dict | None = None,
         timeout: int | None = None,
-        **kwargs: dict[str, Any],
+        **kwargs: Any,
     ) -> requests.Response:
-        """Construct a delete request instance."""
-        return self.call(
+        return self._request_with_retry(
             method='DELETE',
             url=url,
             params=params,
@@ -175,10 +367,9 @@ class RequestClient:
         headers: dict | None = None,
         timeout: int | None = None,
         data: dict | bytes | None = None,
-        **kwargs: dict[str, Any],
+        **kwargs: Any,
     ) -> requests.Response:
-        """Construct a post request instance."""
-        return self.call(
+        return self._request_with_retry(
             method='POST',
             url=url,
             params=params,
@@ -196,10 +387,9 @@ class RequestClient:
         headers: dict | None = None,
         timeout: int | None = None,
         data: dict | None = None,
-        **kwargs: dict[str, Any],
+        **kwargs: Any,
     ) -> requests.Response:
-        """Construct a put request instance."""
-        return self.call(
+        return self._request_with_retry(
             method='PUT',
             url=url,
             params=params,
@@ -217,10 +407,9 @@ class RequestClient:
         headers: dict | None = None,
         timeout: int | None = None,
         data: dict | None = None,
-        **kwargs: dict[str, Any],
+        **kwargs: Any,
     ) -> requests.Response:
-        """Construct a potch request instance."""
-        return self.call(
+        return self._request_with_retry(
             method='PATCH',
             url=url,
             params=params,

fiddler/schemas/model.py

@@ -2,7 +2,7 @@ from datetime import datetime
 from typing import Dict, List, Optional
 from uuid import UUID
 
-from pydantic.fields import Field
+from pydantic.v1 import Field
 
 from fiddler.schemas.base import BaseModel
 from fiddler.schemas.model_schema import ModelSchema

fiddler/schemas/xai.py

@@ -24,9 +24,3 @@ class DatasetDataSource(BaseModel):
     env_type: str
     num_samples: Optional[int]
     env_id: Optional[Union[str, UUID]] = Field(alias='dataset_id')
-
-
-class SqlSliceQueryDataSource(BaseModel):
-    source_type = 'SQL_SLICE_QUERY'
-    query: str
-    num_samples: Optional[int]

fiddler/tests/apis/test_alert_rule.py

@@ -288,7 +288,7 @@ def test_add_alert_rule_success() -> None:
 
 
 @responses.activate
-def test_enable_notifications(caplog) -> None:
+def test_enable_notifications() -> None:
     responses.get(
         url=f'{URL}/v3/alert-rules/{ALERT_RULE_ID}',
         json=API_RESPONSE_200,
@@ -304,14 +304,10 @@ def test_enable_notifications(caplog) -> None:
 
     alert_rule.enable_notifications()
     assert json.loads(resp.calls[0].request.body) == {'enable_notification': True}
-    assert (
-        f'Notifications have been enabled for alert rule with id: {ALERT_RULE_ID}'
-        == caplog.messages[0]
-    )
 
 
 @responses.activate
-def test_disable_notifications(caplog) -> None:
+def test_disable_notifications() -> None:
     responses.get(
         url=f'{URL}/v3/alert-rules/{ALERT_RULE_ID}',
         json=API_RESPONSE_200,
@@ -329,10 +325,6 @@ def test_disable_notifications(caplog) -> None:
     set_logging(logging.INFO)
     alert_rule.disable_notifications()
     assert json.loads(resp.calls[0].request.body) == {'enable_notification': False}
-    assert (
-        f'Notifications have been disabled for alert rule with id: {ALERT_RULE_ID}'
-        == caplog.messages[0]
-    )
 
 
 @responses.activate
@@ -459,7 +451,7 @@ def test_set_notifications_webhooks() -> None:
 
 
 @responses.activate
-def test_set_notifications_invalid_input(caplog) -> None:
+def test_set_notifications_invalid_input() -> None:
     responses.get(
         url=f'{URL}/v3/alert-rules/{ALERT_RULE_ID}',
         json=API_RESPONSE_200,
@@ -472,7 +464,6 @@ def test_set_notifications_invalid_input(caplog) -> None:
             emails=TEST_EMAILS[0],
             webhooks=TEST_WEBHOOKS,
         )
-    assert 'Invalid input: The format of input is not correct' in caplog.messages[0]
 
 
 @responses.activate

fiddler/tests/apis/test_xai.py

@@ -219,48 +219,6 @@ EXPLAIN_RESPONSE_200 = {
     'kind': 'NORMAL',
 }
 
-FETCH_SLICE_RESPONSE_200 = {
-    'data': {
-        'metadata': {
-            'query': "SELECT * FROM test_bank_churn.bank_churn WHERE geography='France' order by balance desc LIMIT 2",
-            'is_slice': True,
-            'columns': ['Age'],
-            'dtypes': ['int'],
-            'model': {
-                'id': '36bc3613-49d5-46b5-a0e0-a45c3aa4a9d9',
-                'name': 'bank_churn',
-            },
-            'env': {
-                'id': '86e59334-2b86-4726-a970-6900db46e437',
-                'type': 'PRE_PRODUCTION',
-                'name': 'test_bank_churn',
-            },
-        },
-        'rows': [[57], [37]],
-    },
-    'api_version': '3.0',
-    'kind': 'NORMAL',
-}
-
-MUTUAL_INFO_RESPONSE_200 = {
-    'data': {
-        'CreditScore': 0.009774993816146854,
-        'Geography': 1.0387361759590092,
-        'Gender': 0.000345600896640319,
-        'Age': 0.006747713128151839,
-        'Tenure': 0.0017159873190972647,
-        'Balance': 0.14278016623398132,
-        'NumOfProducts': 0.002155101383831244,
-        'HasCrCard': 0.00011152799557884174,
-        'IsActiveMember': 0.00026523254634630566,
-        'EstimatedSalary': 0.010603971349228138,
-        'probability_churned': 0.06073798415644517,
-        'Decisions': 2.3682864881247045e-05,
-        'Churned': 0.014017045772466472,
-    },
-    'api_version': '3.0',
-    'kind': 'NORMAL',
-}
 
 PREDICT_RESPONSE_200 = {
     'data': {'predictions': [{'predicted_quality': 5.759617514660622}]},
@@ -555,27 +513,6 @@ def test_explain() -> None:
     )
 
 
-@responses.activate
-def test_get_slice() -> None:
-    responses.get(
-        url=f'{URL}/v3/models/{MODEL_ID}',
-        json=MODEL_API_RESPONSE_200,
-    )
-    model = Model.get(id_=MODEL_ID)
-
-    responses.post(
-        url=f'{URL}/v3/slice-query/fetch',
-        json=FETCH_SLICE_RESPONSE_200,
-    )
-
-    slice_df = model.get_slice(
-        query="SELECT * FROM test_bank_churn.bank_churn WHERE geography='France' order by balance desc LIMIT 3",
-        columns=['Age'],
-        max_rows=2,
-    )
-    expected_df = pd.DataFrame({'Age': [57, 37]})
-    pd.testing.assert_frame_equal(expected_df, slice_df)
-
 
 @responses.activate
 def test_download_data() -> None:
@@ -607,51 +544,6 @@ def test_download_data() -> None:
     shutil.rmtree(str(parquet_output))
 
 
-@responses.activate
-def test_slice_download() -> None:
-    responses.get(
-        url=f'{URL}/v3/models/{MODEL_ID}',
-        json=MODEL_API_RESPONSE_200,
-    )
-    model = Model.get(id_=MODEL_ID)
-
-    parquet_path = os.path.join(OUTPUT_DIR, 'test_slice_download.parquet')
-    parquet_output = os.path.join(BASE_TEST_DIR, 'slice_test_dir')
-    with open(parquet_path, 'rb') as parquet_file:
-        data = io.BufferedReader(parquet_file)
-        responses.post(
-            url=f'{URL}/v3/slice-query/download',
-            body=data,
-        )
-        expected_df = pd.DataFrame({'Age': [38, 57, 42]})
-        model.download_slice(
-            output_dir=parquet_output,
-            query='SELECT * FROM test_bank_churn.bank_churn WHERE age>=20 order by balance desc',
-            columns=['Age'],
-            max_rows=3,
-        )
-        slice_df = pd.read_parquet(parquet_path)
-        pd.testing.assert_frame_equal(expected_df, slice_df)
-    shutil.rmtree(str(parquet_output))
-
-
-@responses.activate
-def test_mutual_info() -> None:
-    responses.get(
-        url=f'{URL}/v3/models/{MODEL_ID}',
-        json=MODEL_API_RESPONSE_200,
-    )
-    model = Model.get(id_=MODEL_ID)
-
-    responses.post(
-        url=f'{URL}/v3/analytics/mutual-info',
-        json=MUTUAL_INFO_RESPONSE_200,
-    )
-    mutual_info = model.get_mutual_info(
-        query=f'select * from {DATASET_NAME}.{MODEL_NAME}',
-        column_name='Geography',
-    )
-    assert mutual_info == MUTUAL_INFO_RESPONSE_200['data']
 
 
 @responses.activate

{fiddler_client-3.5.0.dev1.dist-info → fiddler_client-3.6.0.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fiddler-client
-Version: 3.5.0.dev1
+Version: 3.6.0.dev1
 Summary: Python client for Fiddler Platform
 Home-page: https://fiddler.ai
 Author: Fiddler Labs

{fiddler_client-3.5.0.dev1.dist-info → fiddler_client-3.6.0.dev1.dist-info}/RECORD

@@ -1,9 +1,9 @@
-fiddler/VERSION,sha256=loAQSF8-sXNfBcb_xw6p7lr4vDB7esoacqSpkRL8Yrc,11
-fiddler/__init__.py,sha256=zqmlh-rlaIsZu8-wlul2jxccIC1PV3Z9FbyymLdDOf0,3832
-fiddler/configs.py,sha256=ZimSo0Gk7j1BFkjDHdRdycrGZ8oh-7G5TBXYiOh1HvU,217
+fiddler/VERSION,sha256=GEhNOdsvFfk1-UqmBoYWxbLNcwiqgDmoJMtNkUTmTIs,11
+fiddler/__init__.py,sha256=3gbyU75uS19XTOqscenO38oPfC7qf9d44Cgt9UYyTJI,3772
+fiddler/configs.py,sha256=qwmxc6oYKUoNgzXyY7nSkPMeEk0KehYTl7qNi-uKul4,406
 fiddler/connection.py,sha256=gm7dShXhNFRTyHKsAEtQ56_lDlArLdxjKJQaQMK5-fE,5775
-fiddler/decorators.py,sha256=TyM5__nxjX8tIT83YAnIWMkWlh5GIsGg6F8wdlHeq-g,1836
-fiddler/exceptions.py,sha256=_C4569NmMOq99DRD9IAYKFaH1TzbDOyPAdmMepj5IfY,2260
+fiddler/decorators.py,sha256=yfA_7s41kzZOBqc0ZqluGezvkoTlHyL8q2dLF2amMyA,3624
+fiddler/exceptions.py,sha256=LrGXSNP3N5aQKyiVX7H1mX2hs23YWZev1WxlRzxiWis,2534
 fiddler/version.py,sha256=8fyg3UhFpqghMpxbtYIwNcB1lhCG6yTkPBbDS7IrwxY,140
 fiddler/constants/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fiddler/constants/alert_rule.py,sha256=cmFq-VKAlQbRKEkTtMmVNdD5R52uMI2zJai6TESFwfs,512
@@ -17,14 +17,14 @@ fiddler/constants/model_deployment.py,sha256=SfagLKVD7tK1QmYQFJLDrA4-6FaSeNF6tik
 fiddler/constants/xai.py,sha256=m6uO9DleXj7l9ZwqscmAkr3ZNzdcgLMtPPKwUNh8B3k,344
 fiddler/entities/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fiddler/entities/alert_record.py,sha256=RcDACWDNpntkiId-JpkLQvVeIbuaZAzn6AWl2zYIh9A,3564
-fiddler/entities/alert_rule.py,sha256=p6PzU98EqPHUgr43Ao-TX8vZL7BwMgIcnQszmqpBzsI,10512
+fiddler/entities/alert_rule.py,sha256=MmYr0_RVWFoMvp7EPE5u23hvDO45rNNuuhuKOnLv9D4,10512
 fiddler/entities/base.py,sha256=YCTLt1ta8UbD7u-5BW7v_ocA4S7LevEncI5XPS_SB60,2106
 fiddler/entities/baseline.py,sha256=k3D-K8WC5MkHDILyejRaH1v9jdCIymT96McDBOVQ9A0,7907
 fiddler/entities/custom_expression.py,sha256=SdS61JiI0gOxWwHAGxkHh1vqS5XsRtyeNSDs5E-Sg2U,6568
 fiddler/entities/dataset.py,sha256=kwD1pZMG6DQGIjejU7A2KUUBRgOi0o1qbbUX-PSlnGg,4399
 fiddler/entities/events.py,sha256=9pzg7J1v03o2DGgHX_uPsCSujwk5iyPEDJPrrBNWJbo,5662
 fiddler/entities/file.py,sha256=dk8ISfjy0--F2eF23Ae8vGiEZmJW6e9LMqNmKfrY2mE,4710
-fiddler/entities/job.py,sha256=Feiqo6ns4bRcp2uaV-kuGYAKs90-aYXvzqqi1yLivYE,5220
+fiddler/entities/job.py,sha256=C_P2w_sMPFgBIEa2ILyMV0B3dc3dPzuo9Yik1B5CP0k,7098
 fiddler/entities/model.py,sha256=giqLWvnqXsqrekJ3sIeHf3vUUYO43PxrGh6I_KsGfH4,19271
 fiddler/entities/model_artifact.py,sha256=Y7o1mFs-nVDz7HI9mVBu9ICwkqGD_QbT3q6vf8KKesk,5520
 fiddler/entities/model_deployment.py,sha256=pzS6xPg4zuhrIzMbF44ptK_ZwV8yN6URF0hDwyVhnwY,3966
@@ -33,10 +33,10 @@ fiddler/entities/project.py,sha256=G5omjjKHEjvhenMvW-R0bYwrkRVHixIOhTPZb1pS7FI,4
 fiddler/entities/surrogate.py,sha256=94RkJmv8uwNhRL8PaliuiRv-R0EXDMKJTimE9boXKwQ,3077
 fiddler/entities/user.py,sha256=ev_Xx9QHAdEHYzNDafzQihXOcD8ME5XkpKgc8MiqCnw,1243
 fiddler/entities/webhook.py,sha256=BhwV-05EaFtOATbnlPWUaGeziRSewBPSNSGsYFbIRfc,4514
-fiddler/entities/xai.py,sha256=XVrLpjt_IJFlvsSz13LbdG_8ykm9R6oTaPWibPqEloQ,23921
+fiddler/entities/xai.py,sha256=-jbQEBFO1NxsBGld_bWV-nmeciex-jK4ett0_AjaO8I,22041
 fiddler/libs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fiddler/libs/aws.py,sha256=QZAVyNhZ5hUpP1GV9lBzldpKDVZvCenTWSZ4yM6g79E,3480
-fiddler/libs/http_client.py,sha256=idRyRzDqjtMvvPBGlrImS2tn42FoYuSzoTOPwVS2qvA,7035
+fiddler/libs/http_client.py,sha256=fgawVffkW25xsswlIGy7TctDKgRFiQTsA5GCcaHe_qc,14945
 fiddler/libs/json_encoder.py,sha256=brsrWySvtZdaBArIkqKM5WwJUbvZf6ZbKozn1CewjOc,512
 fiddler/libs/semver.py,sha256=khO8HpPceBXbimD4Q7hqQB9BYFHl9G7z7--ycXDQQwo,15979
 fiddler/packtools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -56,7 +56,7 @@ fiddler/schemas/events.py,sha256=dH6SGPBO_rgGZetIhSo4Fq0L1pTU7TEKR7zW7gg3fnI,409
 fiddler/schemas/file.py,sha256=UNQAHQW1SILLC4SFnPnbZQ0oSSYEw1qzkN6REdD_chY,465
 fiddler/schemas/filter_query.py,sha256=XP8SoFGSJOo9yf3fA9dPqpKdCJuaUpbKbYixn46lBF0,1325
 fiddler/schemas/job.py,sha256=6q3SiHp43ah0R0eIO77DNgJRug-dejI13NZAd_7c0sk,354
-fiddler/schemas/model.py,sha256=d9NZy-RvQ1rOj8KaPXF4jQcUfsw6qJteMyG3LgyR3Lc,1405
+fiddler/schemas/model.py,sha256=8PsF69DxC5Y8k8klGbYSZAS-xegXEqIygaW9pZq3nAE,1401
 fiddler/schemas/model_deployment.py,sha256=s1moOBT7JIMWgGZ4ALxgZJhB4ulVK6i2VkNp7_mOJKo,1128
 fiddler/schemas/model_schema.py,sha256=Kx5rMyDYvgrBv52Oy2RQrW4pn6D_aqVzrvMICaYckOs,1917
 fiddler/schemas/model_spec.py,sha256=K7GkhkbL8vvoFGLNq-xy1aeiRcPOx0QBx9EaMwZfV-I,969
@@ -67,7 +67,7 @@ fiddler/schemas/response.py,sha256=kcSt3zmyjLpbjt_t2KOOzinBqgmfJFJS9mvx998hhj8,1
 fiddler/schemas/server_info.py,sha256=nrykHzrcIaYX1TcK71RoGSQ6kUIinCfvMU8wxaGtQZQ,500
 fiddler/schemas/user.py,sha256=p_Z-Zjj85HvJw2QGWwP_qqx-lAcNTgzMrVzgkKjstEU,140
 fiddler/schemas/webhook.py,sha256=Utg1wRylr5L0CYc47k7iLQdlVCL0L6S29jVntNwMzbA,464
-fiddler/schemas/xai.py,sha256=z2dEZEGa0E3AHJB1wX-1PD3surJUVfRPP1iytdiat-A,742
+fiddler/schemas/xai.py,sha256=j16vu4iDhTuD42kKEjukbMFkRFgKfkHzMRVDWTsEFz8,616
 fiddler/schemas/xai_params.py,sha256=VX9dXumBrnCAmxyvsQWagj4kYTaQr9Rv1hGsSimhFjU,316
 fiddler/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fiddler/tests/conftest.py,sha256=Dmz9FKAFHYdq1AWmcY7NES9pU4cbY9qKWQiojjaX_0E,840
@@ -80,7 +80,7 @@ fiddler/tests/test_utils.py,sha256=AF6y7UfboEkCa-nNw0aF30SdHC7yW2Hh78J4H_4s78k,3
 fiddler/tests/utils.py,sha256=FEDbASW4pYZktdEK2FLnIDyZCwBzpb60m6EzkvOkwSc,335
 fiddler/tests/apis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fiddler/tests/apis/test_alert_record.py,sha256=_0EBRDn87TqTiO1KYEHKQQVtVZjj4lYjbt8Ix-RRTSg,3118
-fiddler/tests/apis/test_alert_rule.py,sha256=a-EtKeV6TFy71kRh5q5M5ccRGipkOvMKdtBA4q5eJ6Q,14641
+fiddler/tests/apis/test_alert_rule.py,sha256=KlS6FOl3MGcfslAPnqvy6EQmsKDulyqAXlRrCI_AebM,14273
 fiddler/tests/apis/test_baseline.py,sha256=R_vvbZdSenpYMSydurENJrE_uNWE3sJR9sHJksfU_Jk,7494
 fiddler/tests/apis/test_custom_metric.py,sha256=QlNa80M9PxqaqzW-3nCtH5kKLRHYu2iqFDautBusbos,8208
 fiddler/tests/apis/test_dataset.py,sha256=1Xc9Ng91fLMc2C6dpKfse42fQ0anza3ZOKOD1TqCvTQ,4636
@@ -96,7 +96,7 @@ fiddler/tests/apis/test_model_surrogate.py,sha256=h3OPgD1-_n6gTd0YH_hDcBBRjBfXv1
 fiddler/tests/apis/test_project.py,sha256=IEYT3imD4dZJg-OT888G4jQJ_AxxHN5_VkCHcmwUnGA,6015
 fiddler/tests/apis/test_segment.py,sha256=hQiXpZEKLJrnlRBLLMsP3jph8H8K7AEUw17sMK6BuF8,7804
 fiddler/tests/apis/test_webhook.py,sha256=RyBw7p2xNp-LFmq6n9mgG-GQqSu2Y3FzsccM8aSyLwc,8180
-fiddler/tests/apis/test_xai.py,sha256=ugGf9xwnQREXEuQuORnTqy8JoRZHdud8dG1KCPKs35U,27949
+fiddler/tests/apis/test_xai.py,sha256=OSExXaA0ajKR7-qvTsbP5uZ72pzbqTVxVn92SDAHLzs,24485
 fiddler/utils/__init__.py,sha256=ooAJR6_tVaF6UKZriz5ynZPj8IeCzaDIPKV23F-e4Fk,53
 fiddler/utils/decorators.py,sha256=bEMhbfxoeyfJRnPGTY3xfBJbGYe9j7W4jbkhke8yuls,1521
 fiddler/utils/helpers.py,sha256=Xl_T_se9SOeMTmVJAOVzzmkekUsmpFMlAb2KvPCWfTw,2908
@@ -104,8 +104,8 @@ fiddler/utils/logger.py,sha256=-UTpjbhGZxBiZrK6UQ-ayZ37L9tv_ZbG1AnC-k2riiQ,1113
 fiddler/utils/model_generator.py,sha256=TwQMQDpy-0gcq6HyL68s37N-sk_nGPq33mmppK6i7hI,2203
 fiddler/utils/validations.py,sha256=i8NtgrpCsitq6BPa5lygpKDh07oaOXu7PAlCIcMvqzY,408
 fiddler/utils/version.py,sha256=iC8Ry7UFl9EJW_xU1WbzO_l4yK6V7eQ6U5exB3xT864,531
-fiddler_client-3.5.0.dev1.dist-info/LICENSE.txt,sha256=w8-LUAb_VLBWSsCNmih0pAqLIicJfGu8OJXpDjkIg_o,559
-fiddler_client-3.5.0.dev1.dist-info/METADATA,sha256=ZHDTls4L9Xm0qUPUrg99yG_TMToFQQ_ZFAiGc-FNuc0,1591
-fiddler_client-3.5.0.dev1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-fiddler_client-3.5.0.dev1.dist-info/top_level.txt,sha256=ndC6LqvKmrTTs8czRlBOYdYgSqZbHuMf0zHt_HWpzzk,8
-fiddler_client-3.5.0.dev1.dist-info/RECORD,,
+fiddler_client-3.6.0.dev1.dist-info/LICENSE.txt,sha256=w8-LUAb_VLBWSsCNmih0pAqLIicJfGu8OJXpDjkIg_o,559
+fiddler_client-3.6.0.dev1.dist-info/METADATA,sha256=r39vKnQ3TFVYlnBGy_z1o1dXEuWi0OA8OkzhEHp6Zao,1591
+fiddler_client-3.6.0.dev1.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+fiddler_client-3.6.0.dev1.dist-info/top_level.txt,sha256=ndC6LqvKmrTTs8czRlBOYdYgSqZbHuMf0zHt_HWpzzk,8
+fiddler_client-3.6.0.dev1.dist-info/RECORD,,

{fiddler_client-3.5.0.dev1.dist-info → fiddler_client-3.6.0.dev1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: setuptools (75.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any