fiddler-client 2.2.1__tar.gz → 2.3.0__tar.gz

{fiddler-client-2.2.1/fiddler_client.egg-info → fiddler-client-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fiddler-client
-Version: 2.2.1
+Version: 2.3.0
 Summary: Python client for Fiddler Service
 Home-page: https://fiddler.ai
 Author: Fiddler Labs
@@ -42,6 +42,11 @@ Documentation for the API can be found [here](https://docs.fiddler.ai/reference/
 
 Version History
 -------------
+### 2.3.0
+  - #### **New Features**
+    - Added support for creating alerts on the `Frequency` metric.
+  - #### **Modifications**
+    - Relax pydantic version to allow any version between 1.9 and 2
 
 ### 2.2.1
   - #### **Modifications**

{fiddler-client-2.2.1 → fiddler-client-2.3.0}/PUBLIC.md

@@ -19,6 +19,11 @@ Documentation for the API can be found [here](https://docs.fiddler.ai/reference/
 
 Version History
 -------------
+### 2.3.0
+  - #### **New Features**
+    - Added support for creating alerts on the `Frequency` metric.
+  - #### **Modifications**
+    - Relax pydantic version to allow any version between 1.9 and 2
 
 ### 2.2.1
   - #### **Modifications**

{fiddler-client-2.2.1 → fiddler-client-2.3.0}/fiddler/__init__.py

@@ -45,11 +45,11 @@ from fiddler.schema.alert import (
 from fiddler.schema.model_deployment import DeploymentParams, DeploymentType
 from fiddler.schemas.custom_features import (
     CustomFeature,
+    CustomFeatureType,
     ImageEmbedding,
     Multivariate,
     TextEmbedding,
     VectorFeature,
-    CustomFeatureType,
 )
 from fiddler.utils import ColorLogger
 from fiddler.utils.logger import get_logger
@@ -61,9 +61,6 @@ from fiddler.utils.validator import (
 
 logger = get_logger(__name__)
 
-SUPPORTED_API_VERSIONS = ['v2']
-
-
 __all__ = [
     '__version__',
     'BatchPublishType',

fiddler-client-2.3.0/fiddler/_version.py

@@ -0,0 +1 @@
+__version__ = '2.3.0'

{fiddler-client-2.2.1 → fiddler-client-2.3.0}/fiddler/api/alert_mixin.py

@@ -54,6 +54,7 @@ class AlertMixin:
         alert_type: Optional[AlertType] = None,
         baseline_id: Optional[str] = None,
         compare_period: Optional[ComparePeriod] = None,
+        category: Optional[str] = None,
         column: Optional[str] = None,
         columns: Optional[List[str]] = None,
         warning_threshold: Optional[float] = None,
@@ -146,6 +147,7 @@ class AlertMixin:
             alert_type=alert_type,
             metric=metric,
             metric_id=metric,
+            category=category,
             compare_to=compare_to,
             compare_period=compare_period,
             priority=priority,

{fiddler-client-2.2.1 → fiddler-client-2.3.0}/fiddler/api/api.py

@@ -4,18 +4,17 @@ from urllib.parse import urljoin
 from fiddler._version import __version__
 from fiddler.api.alert_mixin import AlertMixin
 from fiddler.api.baseline_mixin import BaselineMixin
+from fiddler.api.custom_metrics_mixin import CustomMetricsMixin
 
 # @todo: This is v1 implementation needs to have a proper v2 approach
 from fiddler.api.dataset_mixin import DatasetMixin
 from fiddler.api.events_mixin import EventsMixin
 from fiddler.api.explainability_mixin import ExplainabilityMixin
-from fiddler.api.generate_schema_mixin import GenerateSchemaMixin
 from fiddler.api.job_mixin import JobMixin
 from fiddler.api.model_deployment_mixin import ModelDeploymentMixin
 from fiddler.api.model_mixin import ModelMixin
 from fiddler.api.project_mixin import ProjectMixin
 from fiddler.api.webhooks_mixin import WebhookMixin
-from fiddler.api.custom_metrics_mixin import CustomMetricsMixin
 from fiddler.constants import (
     CURRENT_API_VERSION,
     FIDDLER_CLIENT_VERSION_HEADER,
@@ -40,7 +39,6 @@ class FiddlerClient(
     AlertMixin,
     ExplainabilityMixin,
     ModelDeploymentMixin,
-    GenerateSchemaMixin,
     WebhookMixin,
     CustomMetricsMixin,
 ):

{fiddler-client-2.2.1 → fiddler-client-2.3.0}/fiddler/schema/alert.py

@@ -30,9 +30,9 @@ class Metric(str, enum.Enum):
     PSI = 'psi'
 
     ## Data Integrity Metrics
-    MISSING_VALUE = 'is_nullable_violation'
-    RANGE_VIOLATION = 'is_range_violation'
-    TYPE_VIOLATION = 'is_type_violation'
+    MISSING_VALUE = 'null_violation_count'
+    RANGE_VIOLATION = 'range_violation_count'
+    TYPE_VIOLATION = 'type_violation_count'
 
     ## Performance metrics
     # Binary Classification
@@ -40,10 +40,13 @@ class Metric(str, enum.Enum):
     RECALL = 'recall'
     FPR = 'fpr'
     PRECISION = 'precision'
-    TPR = 'tpr'
     AUC = 'auc'
     F1_SCORE = 'f1_score'
-    ECE = 'expected_callibration_error'
+    ECE = 'expected_calibration_error'
+    CALIBRATED_THRESHOLD = 'calibrated_threshold'
+    GMEAN = 'geometric_mean'
+    LOG_LOSS = 'log_loss'
+    
 
     # Regression
     R2 = 'r2'
@@ -53,18 +56,19 @@ class Metric(str, enum.Enum):
     MAE = 'mae'
 
     # Multiclass Classification
-    LOG_LOSS = 'log_loss'
+    LOG_LOSS_COUNT = 'log_loss_count'
 
     # Ranking
     MAP = 'map'
-    MEAN_NDCG = 'mean_ndcg'
+    NDCG_MEAN = 'ndcg_mean'
 
     ## Service Metrics
-    TRAFFIC = 'Traffic'
+    TRAFFIC = 'traffic'
 
     ## Statistic
     AVERAGE = 'average'
     SUM = 'sum'
+    FREQUENCY = 'frequency'
 
     def __repr__(self) -> str:
         return f'{self.__class__.__name__}.{self.name}'
@@ -144,6 +148,7 @@ class AlertRulePayload(BaseDataSchema):
     metric_id: Union[Metric, str]
     feature_name: Optional[str]
     feature_names: Optional[List[str]]
+    category: Optional[str]
     priority: Priority
     compare_to: CompareTo
     baseline_name: Optional[str]
@@ -172,6 +177,7 @@ class AlertRule(BaseDataSchema):
     metric: str
     column: Optional[str] = Field(alias='feature_name', default=None)
     columns: Optional[List[str]] = Field(alias='feature_names', default=None)
+    category: Optional[str]
     baseline_name: Optional[str]
     priority: Priority
     compare_to: CompareTo

fiddler-client-2.3.0/fiddler3/__init__.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from fiddler3.configs import DEFAULT_CONNECTION_TIMEOUT
+from fiddler3.connection import Connection
+from fiddler3.entities import *  # noqa
+from fiddler3.exceptions import *  # noqa
+from fiddler3.schemas import *  # noqa
+
+# Global connection object
+connection: Connection | None = None
+
+
+def init(
+    url: str,
+    token: str,
+    proxies: dict | None = None,
+    timeout: int = DEFAULT_CONNECTION_TIMEOUT,
+    verify: bool = True,
+    validate: bool = True,
+) -> None:
+    """
+    Initiate Python Client Connection
+    :param url: URL of Fiddler Platform
+    :param token: Authorization token
+    :param proxies: Dictionary mapping protocol to the URL of the proxy
+    :param timeout: Seconds to wait for the server to send data before giving up
+    :param verify: Controls whether we verify the server’s TLS certificate
+    :param validate: Whether to validate the server/client version compatibility.
+         Some functionalities might not work if this is turned off.
+    """
+    global connection
+    connection = Connection(
+        url=url,
+        token=token,
+        proxies=proxies,
+        timeout=timeout,
+        verify=verify,
+        validate=validate,
+    )

fiddler-client-2.3.0/fiddler3/configs.py

@@ -0,0 +1,5 @@
+DEFAULT_CONNECTION_TIMEOUT = 60  # In seconds
+MIN_SERVER_VERSION = '23.7.0'  # @TODO: Change this before 3.0 release
+DEFAULT_PAGE_SIZE = 50
+JOB_POLL_INTERVAL = 3
+JOB_WAIT_TIMEOUT = 1800

fiddler-client-2.3.0/fiddler3/connection.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from functools import cached_property
+from uuid import UUID
+
+from fiddler3.configs import DEFAULT_CONNECTION_TIMEOUT, MIN_SERVER_VERSION
+from fiddler3.constants.common import CLIENT_NAME, FIDDLER_CLIENT_VERSION_HEADER
+from fiddler3.decorators import handle_api_error
+from fiddler3.exceptions import IncompatibleClient
+from fiddler3.libs.http_client import RequestClient
+from fiddler3.schemas.server_info import ServerInfo, Version
+from fiddler3.utils.logger import get_logger
+from fiddler3.utils.version import match_semver
+from fiddler3.version import __version__
+
+logger = get_logger(__name__)
+
+
+class Connection:
+    def __init__(
+        self,
+        url: str,
+        token: str,
+        proxies: dict | None = None,
+        timeout: int = DEFAULT_CONNECTION_TIMEOUT,
+        verify: bool = True,
+        validate: bool = True,
+    ) -> None:
+        """
+        Initiate connection to Fiddler Platform
+        :param url: URL of Fiddler Platform
+        :param token: Authorization token
+        :param proxies: Dictionary mapping protocol to the URL of the proxy
+        :param timeout: Seconds to wait for the server to send data before giving up
+        :param verify: Controls whether we verify the server’s TLS certificate
+        :param validate: Whether to validate the server/client version compatibility.
+            Some functionalities might not work if this is turned off.
+        """
+
+        self.url = url
+        self.token = token
+        self.proxies = proxies
+        self.timeout = timeout
+        self.verify = verify
+
+        if not url:
+            raise ValueError('Please pass a valid url')
+
+        if not token:
+            raise ValueError('Please pass a valid token')
+
+        self.request_headers = {
+            'Authorization': f'Bearer {token}',
+            FIDDLER_CLIENT_VERSION_HEADER: __version__,
+        }
+
+        if validate:
+            self._check_server_version()
+            self._check_version_compatibility()
+
+    @cached_property
+    def client(self) -> RequestClient:
+        """Request client instance"""
+        return RequestClient(
+            base_url=self.url,
+            headers=self.request_headers,
+            proxies=self.proxies,
+            verify=self.verify,
+        )
+
+    @cached_property
+    def server_info(self) -> ServerInfo:
+        """Server info instance"""
+        return self._get_server_info()
+
+    @cached_property
+    def server_version(self) -> Version:
+        """Server semver version"""
+        return self.server_info.server_version
+
+    @cached_property
+    def organization_name(self) -> str:
+        """Organization name"""
+        return self.server_info.organization.name
+
+    @cached_property
+    def organization_id(self) -> UUID:
+        """Organization id"""
+        return self.server_info.organization.id
+
+    @handle_api_error
+    def _get_server_info(self) -> ServerInfo:
+        """Get server info"""
+        response = self.client.get(
+            url='/v3/server-info',
+        )
+
+        return ServerInfo(**response.json().get('data'))
+
+    @handle_api_error
+    def _check_version_compatibility(self) -> None:
+        """Check whether Client version is compatible with Fiddler Platform version"""
+
+        self.client.get(
+            url='/v3/version-compatibility',
+            params={
+                'client_version': __version__,
+                'client_name': CLIENT_NAME,
+            },
+        )
+
+    def _check_server_version(self) -> None:
+        """Check whether Fiddler Platform version is compatible with Client version"""
+        if match_semver(self.server_version, f'>={MIN_SERVER_VERSION}'):
+            return
+
+        raise IncompatibleClient(server_version=str(self.server_version))

fiddler-client-2.3.0/fiddler3/constants/common.py

@@ -0,0 +1,3 @@
+JSON_CONTENT_TYPE = 'application/json'
+FIDDLER_CLIENT_VERSION_HEADER = 'X-Fiddler-Client-Version'
+CLIENT_NAME = 'python-sdk'

fiddler-client-2.3.0/fiddler3/constants/job.py

@@ -0,0 +1,13 @@
+import enum
+
+
+@enum.unique
+class JobStatus(str, enum.Enum):
+    """Async job status enum"""
+
+    PENDING = 'PENDING'
+    STARTED = 'STARTED'
+    SUCCESS = 'SUCCESS'
+    FAILURE = 'FAILURE'
+    RETRY = 'RETRY'
+    REVOKED = 'REVOKED'

fiddler-client-2.3.0/fiddler3/constants/model.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import enum
+
+
+@enum.unique
+class ModelInputType(str, enum.Enum):
+    """Input data type used by the model"""
+
+    TABULAR = 'structured'
+    TEXT = 'text'
+    MIXED = 'mixed'
+
+
+@enum.unique
+class ModelTask(str, enum.Enum):
+    """Task the model is designed to address"""
+
+    BINARY_CLASSIFICATION = 'binary_classification'
+    MULTICLASS_CLASSIFICATION = 'multiclass_classification'
+    REGRESSION = 'regression'
+    RANKING = 'ranking'
+    LLM = 'llm'
+    NOT_SET = 'not_set'
+
+    def is_classification(self) -> bool:
+        return self in {
+            ModelTask.BINARY_CLASSIFICATION,
+            ModelTask.MULTICLASS_CLASSIFICATION,
+        }
+
+    def is_regression(self) -> bool:
+        return self == ModelTask.REGRESSION
+
+
+@enum.unique
+class DataType(str, enum.Enum):
+    """Data types supported for model columns"""
+
+    FLOAT = 'float'
+    INTEGER = 'int'
+    BOOLEAN = 'bool'
+    STRING = 'str'
+    CATEGORY = 'category'
+    TIMESTAMP = 'timestamp'
+    VECTOR = 'vector'
+
+    def is_numeric(self) -> bool:
+        return self in {DataType.INTEGER, DataType.FLOAT}
+
+    def is_bool_or_cat(self) -> bool:
+        return self in {DataType.BOOLEAN, DataType.CATEGORY}
+
+    def is_vector(self) -> bool:
+        return self == DataType.VECTOR
+
+
+@enum.unique
+class ArtifactStatus(str, enum.Enum):
+    """Artifact Status"""
+
+    NO_MODEL = 'no_model'
+    SURROGATE = 'surrogate'
+    USER_UPLOADED = 'user_uploaded'

fiddler-client-2.3.0/fiddler3/decorators.py

@@ -0,0 +1,52 @@
+from functools import wraps
+from http import HTTPStatus
+from typing import Any, Callable, TypeVar, cast
+
+import requests
+
+from fiddler3.exceptions import ApiError, Conflict, HttpError, NotFound, Unsupported
+from fiddler3.schemas.response import ErrorResponse
+from fiddler3.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+_WrappedFuncType = TypeVar(  # pylint: disable=invalid-name
+    '_WrappedFuncType', bound=Callable[..., Any]
+)
+
+
+def handle_api_error(func: _WrappedFuncType) -> _WrappedFuncType:
+    @wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        try:
+            return func(*args, **kwargs)
+        except requests.JSONDecodeError as e:
+            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'),
+            )
+
+            status_code = e.response.status_code or HTTPStatus.INTERNAL_SERVER_ERROR
+
+            if status_code == HTTPStatus.METHOD_NOT_ALLOWED:
+                raise Unsupported()
+
+            try:
+                error_resp = ErrorResponse(**e.response.json())
+            except requests.JSONDecodeError:
+                raise HttpError(
+                    message=f'Invalid response content-type - {e.response.content}'
+                )
+
+            if status_code == HTTPStatus.CONFLICT:
+                raise Conflict(error_resp.error)
+            if status_code == HTTPStatus.NOT_FOUND:
+                raise NotFound(error_resp.error)
+
+            raise ApiError(error_resp.error)
+
+    return cast(_WrappedFuncType, wrapper)

fiddler-client-2.3.0/fiddler3/entities/__init__.py

@@ -0,0 +1,3 @@
+from fiddler3.entities.model import Model  # noqa
+from fiddler3.entities.project import Project  # noqa
+from fiddler3.entities.job import Job  # noqa

fiddler-client-2.3.0/fiddler3/entities/base.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from typing import Iterator, TypeVar
+
+from requests import Response
+
+from fiddler3 import Connection
+from fiddler3.configs import DEFAULT_PAGE_SIZE
+from fiddler3.libs.http_client import RequestClient
+from fiddler3.schemas.response import PaginatedApiResponse
+
+BaseEntityType = TypeVar(  # pylint: disable=invalid-name
+    'BaseEntityType', bound='BaseEntity'
+)
+
+
+class BaseEntity:
+    @classmethod
+    def _connection(cls) -> Connection:
+        """Fiddler connection instance"""
+        from fiddler3 import connection
+
+        assert connection is not None
+        return connection
+
+    @classmethod
+    def _client(cls) -> RequestClient:
+        """Request client instance"""
+        return cls._connection().client
+
+    @classmethod
+    def _from_response(cls: type[BaseEntityType], response: Response) -> BaseEntityType:
+        """Build entity object from the given response"""
+        return cls._from_dict(data=response.json()['data'])
+
+    @classmethod
+    def _from_dict(cls: type[BaseEntityType], data: dict) -> BaseEntityType:
+        """Build entity object from the given dictionary"""
+        raise NotImplementedError()
+
+    @classmethod
+    def _paginate(
+        cls, url: str, params: dict | None = None, page_size: int = DEFAULT_PAGE_SIZE
+    ) -> Iterator[dict]:
+        """
+        Iterator over pagination API
+        :param url: Pagination endpoint
+        :param page_size: Number of items per page
+        :return: Iterator of items
+        """
+        offset = 0
+        params = params or {}
+        params.update(
+            {
+                'limit': page_size,
+                'offset': offset,
+            }
+        )
+
+        while True:
+            response = cls._client().get(
+                url=url,
+                params={
+                    'limit': page_size,
+                    'offset': offset,
+                },
+            )
+            resp_obj = PaginatedApiResponse(**response.json()).data
+
+            if resp_obj.page_count == resp_obj.page_index:
+                break
+
+            yield from resp_obj.items
+
+            # Update offset
+            offset = resp_obj.offset + page_size

fiddler-client-2.3.0/fiddler3/entities/helpers.py

@@ -0,0 +1,21 @@
+from http import HTTPStatus
+
+from fiddler3.exceptions import NotFound
+from fiddler3.schemas.response import ErrorData
+
+
+def raise_not_found(message: str) -> None:
+    """Raise NotFound if the resource is not found while fetching with names"""
+    raise NotFound(
+        error=ErrorData(
+            code=HTTPStatus.NOT_FOUND,
+            message=message,
+            errors=[
+                {
+                    'reason': 'ObjectNotFound',  # type: ignore
+                    'message': message,
+                    'help': '',
+                }
+            ],
+        ),
+    )