fiddler-client 3.5.0.dev2__tar.gz → 3.6.0__tar.gz

{fiddler_client-3.5.0.dev2/fiddler_client.egg-info → fiddler_client-3.6.0}/PKG-INFO

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

{fiddler_client-3.5.0.dev2 → fiddler_client-3.6.0}/README.md

@@ -1,6 +1,6 @@
-[![codecov](https://codecov.io/gh/fiddler-labs/python-client/graph/badge.svg?token=2E6AAUXO56)](https://codecov.io/gh/fiddler-labs/python-client)
+# fiddler-client
 
-# Fiddler Python client
+A Python library for interacting with the Fiddler HTTP API.
 
 ## Pre Release
 

fiddler_client-3.6.0/fiddler/VERSION

@@ -0,0 +1 @@
+3.6.0

{fiddler_client-3.5.0.dev2 → fiddler_client-3.6.0}/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_client-3.5.0.dev2 → fiddler_client-3.6.0}/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),
+                    # Future: have centralized, automatic retrying in our
+                    # client logic which we want to disable here because we
+                    # effectively are in a retry loop, e.g. via passing
+                    # `retry_strategy="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,

{fiddler_client-3.5.0.dev2 → fiddler_client-3.6.0}/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_client-3.5.0.dev2 → fiddler_client-3.6.0}/fiddler/exceptions.py

@@ -53,17 +53,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_client-3.5.0.dev2 → fiddler_client-3.6.0}/fiddler/libs/http_client.py

@@ -10,8 +10,6 @@ from requests.adapters import HTTPAdapter
 
 from fiddler.constants.common import JSON_CONTENT_TYPE
 from fiddler.exceptions import (  # pylint: disable=redefined-builtin
-    ConnError,
-    ConnTimeout,
     HttpError,
 )
 from fiddler.libs.json_encoder import RequestClientJSONEncoder
@@ -49,11 +47,11 @@ 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.
 
         :param method: HTTP method like
         :param url: API endpoint
@@ -62,7 +60,7 @@ class RequestClient:
         :param data: Dict/binary data
         :param timeout: Request timeout in seconds
         """
-        logger.debug('Making %s call to %s', method, url)
+        logger.debug('next: HTTP %s %s', method, url)
 
         full_url = urljoin(self.base_url, url)
 
@@ -81,8 +79,9 @@ class RequestClient:
         # verify param in kwargs when REQUESTS_CA_BUNDLE is set.
         # So setting that as default here
         kwargs.setdefault('verify', self.session.verify)
+
         try:
-            response = self.session.request(
+            resp = self.session.request(
                 method,
                 full_url,
                 params=params,
@@ -92,20 +91,33 @@ class RequestClient:
                 proxies=self.proxies,
                 **kwargs,
             )
-
-        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
-
-        response.raise_for_status()
-        return response
+        except requests.exceptions.RequestException as exc:
+            # Note(JP): we did not get a response. An error happened before
+            # sending the request, while sending the request, while waiting for
+            # response, or while receiving the response. A few examples for
+            # common errors handled here:
+            # - DNS resolution error
+            # - TCP connect() timeout
+            # - 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.
+            #
+            # TODO: add centralized default retrying here, at least for GET
+            # (conservative, I understand we initially may not want to retry
+            # other methods).
+            #
+            # For now, have centralized logging and re-raise to give callers
+            # the opportunity to implement a local error handler, but not
+            # having to worry about logging the full error message.
+            logger.info("http: %s %s failed: %s", method, full_url, exc)
+            raise
+
+        # Raise requests.HTTPError for non-2xx responses, caller can inspect
+        # response status code from the exception object via
+        # e.g. exc.response.status_code.
+        resp.raise_for_status()
+
+        return resp
 
     def get(
         self,
@@ -113,7 +125,7 @@ class RequestClient:
         url: str,
         params: dict | None = None,
         headers: dict | None = None,
-        timeout: int | None = None,
+        timeout: float | tuple[float, float] | None = None,
         **kwargs: dict[str, Any],
     ) -> requests.Response:
         """Construct a get request instance."""

{fiddler_client-3.5.0.dev2 → fiddler_client-3.6.0}/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_client-3.5.0.dev2 → fiddler_client-3.6.0}/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.dev2 → fiddler_client-3.6.0/fiddler_client.egg-info}/PKG-INFO

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

fiddler_client-3.5.0.dev2/fiddler/VERSION

@@ -1 +0,0 @@
-3.5.0.dev2