fiddler-client 2.4.0.dev2__py3-none-any.whl → 2.5.0.dev1__py3-none-any.whl

fiddler3/entities/alert_rule.py

@@ -0,0 +1,246 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any, Iterator
+from uuid import UUID
+
+from fiddler3.constants.alert_rule import AlertCondition, BinSize, CompareTo, Priority
+from fiddler3.decorators import handle_api_error
+from fiddler3.entities.base import BaseEntity
+from fiddler3.entities.baseline import Baseline, BaselineCompactMixin
+from fiddler3.entities.model import Model, ModelCompactMixin
+from fiddler3.entities.project import ProjectCompactMixin
+from fiddler3.schemas.alert_rule import AlertRuleResp
+from fiddler3.schemas.filter_query import OperatorType, QueryCondition, QueryRule
+from fiddler3.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class AlertRule(
+    BaseEntity, ModelCompactMixin, ProjectCompactMixin, BaselineCompactMixin
+):
+    def __init__(  # pylint: disable=too-many-arguments
+        self,
+        name: str,
+        model_id: UUID,
+        metric_id: str | UUID,
+        priority: Priority | str,
+        compare_to: CompareTo | str,
+        condition: AlertCondition | str,
+        bin_size: BinSize | str,
+        critical_threshold: float,
+        warning_threshold: float | None = None,
+        columns: list[str] | None = None,
+        baseline_id: UUID | None = None,
+        compare_bin_delta: int | None = None,
+    ) -> None:
+        """Construct a alert rule instance."""
+        self.name = name
+        self.model_id = model_id
+        self.metric_id = metric_id
+        self.columns = columns
+        self.baseline_id = baseline_id
+        self.priority = priority
+        self.compare_to = compare_to
+        self.compare_bin_delta = compare_bin_delta
+        self.warning_threshold = warning_threshold
+        self.critical_threshold = critical_threshold
+        self.condition = condition
+        self.bin_size = bin_size
+
+        self.id: UUID | None = None
+        self.project_id: UUID | None = None
+
+        self.created_at: datetime | None = None
+        self.updated_at: datetime | None = None
+
+        # Deserialized response object
+        self._resp: AlertRuleResp | None = None
+
+    @staticmethod
+    def _get_url(id_: UUID | str | None = None) -> str:
+        """Get model resource/item url."""
+        url = '/v2/alert-configs'
+        return url if not id_ else f'{url}/{id_}'
+
+    @classmethod
+    def _from_dict(cls, data: dict) -> AlertRule:
+        """Build entity object from the given dictionary."""
+
+        # Deserialize the response
+        resp_obj = AlertRuleResp(**data)
+
+        # Initialize
+        instance = cls(
+            name=resp_obj.name,
+            model_id=resp_obj.model.id,
+            metric_id=resp_obj.metric_id,
+            priority=resp_obj.priority,
+            compare_to=resp_obj.compare_to,
+            condition=resp_obj.condition,
+            bin_size=resp_obj.bin_size,
+            critical_threshold=resp_obj.critical_threshold,
+            warning_threshold=resp_obj.warning_threshold,
+            columns=resp_obj.columns,
+            baseline_id=resp_obj.baseline_id,
+            compare_bin_delta=resp_obj.compare_bin_delta,
+        )
+
+        # Add remaining fields
+        fields = [
+            'id',
+            # 'notifications_config',
+            'created_at',
+            'updated_at',
+        ]
+        for field in fields:
+            setattr(instance, field, getattr(resp_obj, field, None))
+
+        instance.project_id = resp_obj.project.id
+        instance._resp = resp_obj
+
+        return instance
+
+    def _refresh(self, data: dict) -> None:
+        """Refresh the fields of this instance from the given response dictionary"""
+        # Deserialize the response
+        resp_obj = AlertRuleResp(**data)
+
+        # Reset properties
+        self.model_id = resp_obj.model.id
+        self.project_id = resp_obj.project.id
+
+        # Add remaining fields
+        fields = [
+            'id',
+            'created_at',
+            'updated_at',
+        ]
+        for field in fields:
+            setattr(self, field, getattr(resp_obj, field, None))
+
+        self._resp = resp_obj
+
+    @classmethod
+    @handle_api_error
+    def get(cls, id_: UUID | str) -> AlertRule:
+        """
+        Get the alert rule instance using alert rule id.
+
+        :param id_: unique uuid format identifier for alert rule
+        :return: alert rule instance
+        """
+
+        response = cls._client().get(url=cls._get_url(id_=id_))
+        return cls._from_response(response=response)
+
+    @classmethod
+    @handle_api_error
+    def list(  # pylint: disable=too-many-arguments
+        cls,
+        model_id: UUID | None = None,
+        project_id: UUID | None = None,
+        metric_id: UUID | str | None = None,
+        columns: list[str] | None = None,
+        baseline_id: UUID | None = None,
+        ordering: list[str] | None = None,
+    ) -> Iterator[AlertRule]:
+        """Get a list of all alert rules in the organization."""
+        rules: list[QueryRule | QueryCondition] = []
+
+        if model_id:
+            rules.append(
+                QueryRule(field='model_id', operator=OperatorType.EQUAL, value=model_id)
+            )
+        if project_id:
+            rules.append(
+                QueryRule(
+                    field='project_id', operator=OperatorType.EQUAL, value=project_id
+                )
+            )
+        if baseline_id:
+            rules.append(
+                QueryRule(
+                    field='baseline_id', operator=OperatorType.EQUAL, value=baseline_id
+                )
+            )
+        if metric_id:
+            rules.append(
+                QueryRule(
+                    field='metric_id', operator=OperatorType.EQUAL, value=metric_id
+                )
+            )
+        if columns:
+            for column in columns:
+                rules.append(
+                    QueryRule(field='columns', operator=OperatorType.ANY, value=column)
+                )
+
+        _filter = QueryCondition(rules=rules)
+        params: dict[str, Any] = {'filter': _filter.json()}
+
+        if ordering:
+            params['ordering'] = ','.join(ordering)
+
+        params['organization_name'] = cls.get_organization_name()
+        for rule in cls._paginate(url=cls._get_url(), params=params):
+            yield cls._from_dict(data=rule)
+
+    @handle_api_error
+    def delete(self) -> None:
+        """Delete an alert rule."""
+        assert self.id is not None
+
+        self._client().delete(url=self._get_url(id_=self.id))
+
+    @handle_api_error
+    def create(self) -> AlertRule:
+        """Create a new alert rule."""
+        model = Model.get(self.model_id)
+        payload: dict[str, Any] = {
+            'name': self.name,
+            'organization_name': self.organization_name,
+            'model_name': model.name,
+            'project_name': model.project.name,
+            'metric_id': self.metric_id,
+            'priority': self.priority,
+            'compare_to': self.compare_to,
+            'condition': self.condition,
+            'bin_size': self.bin_size,
+            'critical_threshold': self.critical_threshold,
+            'warning_threshold': self.warning_threshold,
+            'feature_names': self.columns,
+            'compare_bin_delta': self.compare_bin_delta,
+        }
+        if self.baseline_id:
+            baseline = Baseline.get(self.baseline_id)
+            payload['baseline_name'] = baseline.name
+
+        response = self._client().post(
+            url=self._get_url(),
+            data=payload,
+        )
+
+        self._refresh_from_response(response=response)
+        return self
+
+    @handle_api_error
+    def enable_notifications(self) -> None:
+        """Enable notifications for an alert rule"""
+        self._client().patch(
+            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
+        )
+
+    @handle_api_error
+    def disable_notifications(self) -> None:
+        """Diable notifications for an alert rule"""
+        self._client().patch(
+            url=self._get_url(id_=self.id), data={'enable_notification': False}
+        )
+        logger.info(
+            'Notifications have been disabled for alert rule with id: %s', self.id
+        )

fiddler3/entities/base.py

@@ -6,8 +6,7 @@ from typing import Iterator, TypeVar
 from requests import Response
 
 from fiddler3.configs import DEFAULT_PAGE_SIZE
-from fiddler3.connection import Connection
-from fiddler3.libs.http_client import RequestClient
+from fiddler3.connection import ConnectionMixin
 from fiddler3.schemas.response import PaginatedApiResponse
 
 BaseEntityType = TypeVar(  # pylint: disable=invalid-name
@@ -15,20 +14,7 @@ BaseEntityType = TypeVar(  # pylint: disable=invalid-name
 )
 
 
-class BaseEntity(ABC):
-    @classmethod
-    def _connection(cls) -> Connection:
-        """Fiddler connection instance"""
-        from fiddler3 import connection  # pylint: disable=import-outside-toplevel
-
-        assert connection is not None
-        return connection
-
-    @classmethod
-    def _client(cls) -> RequestClient:
-        """Request client instance"""
-        return cls._connection().client
-
+class BaseEntity(ABC, ConnectionMixin):
     @classmethod
     def _from_response(cls: type[BaseEntityType], response: Response) -> BaseEntityType:
         """Build entity object from the given response"""

fiddler3/entities/events.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Callable
+from uuid import UUID
+
+import pandas as pd
+from requests import Response
+
+from fiddler3.decorators import handle_api_error
+from fiddler3.entities.files import File
+from fiddler3.entities.job import Job
+from fiddler3.schemas.dataset import EnvType
+from fiddler3.schemas.events import EventsSource, FileSource
+from fiddler3.schemas.job import JobCompactResp
+
+STREAM_EVENTS_MAX = 1000
+
+
+class EventMixin:
+    id: UUID | None
+    _client: Callable
+
+    @handle_api_error
+    def publish(
+        self,
+        source: list[dict[Any, Any]] | str | Path | pd.DataFrame,
+        environment: EnvType,
+        dataset_name: str | None = None,
+    ) -> list[UUID] | Job:
+        """
+        Publish Pre-production or Production data
+
+        :param source: source can be:
+            Path or str path: path for data file.
+            list[dict]: list of event dicts. max_len=1000. EnvType.PRE_PRODUCTION not supported
+            dataframe: events dataframe. EnvType.PRE_PRODUCTION not supported.
+        :param environment: either EnvType.PRE_PRODUCTION or EnvType.PRODUCTION
+        :param dataset_name: name of the dataset. Not supported for EnvType.PRODUCTION
+
+        :return: list[UUID] for list of dicts or dataframe source and Job object for file path source.
+        """
+        _sources = self._get_sources(source)
+        if isinstance(_sources, FileSource):
+            return self._publish_file(
+                source=_sources,
+                environment=environment,
+                dataset_name=dataset_name,
+            )
+        return self._publish_stream(
+            sources=_sources,
+            environment=environment,
+            dataset_name=dataset_name,
+        )
+
+    def _publish_stream(
+        self,
+        sources: list[EventsSource],
+        environment: EnvType,
+        dataset_name: str | None = None,
+    ) -> list[UUID]:
+        fiddler_ids = []
+        for _source in sources:
+            response = self._publish_call(
+                source=_source,
+                environment=environment,
+                dataset_name=dataset_name,
+            )
+            fiddler_ids.extend(response.json()['data']['fiddler_ids'])
+
+        return fiddler_ids
+
+    def _publish_file(
+        self,
+        source: FileSource,
+        environment: EnvType,
+        dataset_name: str | None = None,
+    ) -> Job:
+        response = self._publish_call(
+            source=source, environment=environment, dataset_name=dataset_name
+        )
+        job_compact = JobCompactResp(**response.json()['data']['job'])
+        return Job.get(id_=job_compact.id)
+
+    def _get_sources(
+        self, source: list[dict[str, Any]] | str | Path | pd.DataFrame
+    ) -> list[EventsSource] | FileSource:
+        _source = []
+        if isinstance(source, (str, Path)):
+            file = File(path=Path(source)).upload()
+            assert file.id is not None
+            return FileSource(file_id=file.id)
+
+        if isinstance(source, list):
+            _source.append(EventsSource(events=source))
+
+        elif isinstance(source, pd.DataFrame):
+            for event_dict in [
+                source[i : i + STREAM_EVENTS_MAX]
+                for i in range(0, source.shape[0], STREAM_EVENTS_MAX)
+            ]:
+                _source.append(EventsSource(events=event_dict.to_dict('records')))
+
+        return _source
+
+    def _publish_call(
+        self,
+        source: FileSource | EventsSource,
+        environment: EnvType,
+        dataset_name: str | None = None,
+    ) -> Response:
+        return self._client().post(
+            url='/v3/events',
+            data={
+                'source': source.dict(),
+                'model_id': self.id,
+                'env_type': environment,
+                'env_name': dataset_name,
+            },
+        )

fiddler3/entities/files.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+
+import io
+import os
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Callable
+from uuid import UUID
+
+from requests import Response
+from requests_toolbelt import MultipartEncoder
+
+from fiddler3.constants.common import MULTI_PART_CHUNK_SIZE
+from fiddler3.decorators import handle_api_error
+from fiddler3.entities.base import BaseEntity
+from fiddler3.entities.user import CreatedByMixin, UpdatedByMixin
+from fiddler3.schemas.files import FileResp
+from fiddler3.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class File(BaseEntity, CreatedByMixin, UpdatedByMixin):
+    def __init__(self, path: str | Path, name: str | None = None) -> None:
+        """Construct a files instance."""
+        self.path = path
+        self.name = name or os.path.basename(self.path)
+        self.id: UUID | None = None
+        self.status: str | None = None
+        self.type: str | None = None
+
+        self.created_at: datetime | None = None
+        self.updated_at: datetime | None = None
+
+        # Deserialized response object
+        self._resp: FileResp | None = None
+
+    @classmethod
+    def _from_dict(cls, data: dict) -> File:
+        """Build entity object from the given dictionary"""
+        raise NotImplementedError()
+
+    def _refresh(self, data: dict) -> None:
+        """Refresh the fields of this instance from the given response dictionary"""
+        resp_obj = FileResp(**data)
+
+        # Reset fields
+        self.name = resp_obj.name
+
+        # Add remaining fields
+        fields = [
+            'id',
+            'status',
+            'type',
+            'created_at',
+            'updated_at',
+        ]
+        for field in fields:
+            setattr(self, field, getattr(resp_obj, field, None))
+
+        self._resp = resp_obj
+
+    @handle_api_error
+    def upload(
+        self,
+        chunk_size: int = MULTI_PART_CHUNK_SIZE,
+    ) -> File:
+        """Upload file. Single or multipart upload depends on file size"""
+        upload_method = self._get_upload_method(chunk_size=chunk_size)
+        return upload_method(
+            chunk_size=chunk_size,
+        )
+
+    @handle_api_error
+    def single_upload(
+        self,
+        chunk_size: int = MULTI_PART_CHUNK_SIZE,  # pylint: disable=unused-argument
+    ) -> File:
+        """Single part file upload"""
+        with open(self.path, 'rb') as f:
+            multipart_data = MultipartEncoder(fields={'file': (self.name, f)})
+
+            response = self._client().post(
+                url='/v3/files/upload',
+                data=multipart_data,
+                headers={'Content-Type': multipart_data.content_type},
+            )
+
+        self._refresh_from_response(response)
+        return self
+
+    @handle_api_error
+    def multipart_upload(
+        self,
+        chunk_size: int = MULTI_PART_CHUNK_SIZE,
+    ) -> File:
+        """Multi part file upload"""
+
+        # init multipart upload
+        self._init_multipart_upload()
+
+        assert self.id is not None
+        # multipart parts upload
+        parts = self._multipart_upload(
+            chunk_size=chunk_size,
+        )
+
+        # multipart upload complete
+        response = self._multipart_upload_complete(parts=parts)
+
+        self._refresh_from_response(response)
+        return self
+
+    def _init_multipart_upload(self) -> File:
+        logger.info('Multi-part upload initializing')
+        response = self._client().post(
+            url='/v3/files/multipart-init',
+            data={'filename': self.name},
+        )
+
+        self._refresh_from_response(response)
+        return self
+
+    def _multipart_upload(self, chunk_size: int) -> list[dict[str, Any]]:
+        parts: list[dict[str, Any]] = []
+        part_number = 1
+
+        with open(self.path, 'rb') as f:
+            while True:
+                data = f.read(chunk_size)
+                if not data:
+                    break
+
+                logger.info('Uploading part %d', part_number)
+
+                response = self._client().post(
+                    url='/v3/files/multipart-upload',
+                    files={
+                        'file': (f'part_{part_number}_{self.name}', io.BytesIO(data)),
+                        'file_id': (None, str(self.id)),
+                        'part_number': (None, part_number),
+                    },
+                    headers={'Content-Type': None},
+                )
+
+                parts.append(
+                    {'number': part_number, 'id': response.json()['data']['part_id']}
+                )
+
+                part_number += 1
+
+        return parts
+
+    def _multipart_upload_complete(self, parts: list[dict[str, Any]]) -> Response:
+
+        response = self._client().post(
+            url='/v3/files/multipart-complete',
+            json={
+                'file_id': str(self.id),
+                'parts': parts,
+            },
+        )
+
+        logger.info('Multi-part upload complete')
+        return response
+
+    def _get_upload_method(self, chunk_size: int) -> Callable:
+        if os.path.getsize(self.path) < chunk_size:
+            return self.single_upload
+        return self.multipart_upload

fiddler3/entities/helpers.py

@@ -1,7 +1,7 @@
 from http import HTTPStatus
 
 from fiddler3.exceptions import NotFound
-from fiddler3.schemas.response import ErrorData
+from fiddler3.schemas.response import ErrorData, ErrorItem
 
 
 def raise_not_found(message: str) -> None:
@@ -11,11 +11,11 @@ def raise_not_found(message: str) -> None:
             code=HTTPStatus.NOT_FOUND,
             message=message,
             errors=[
-                {
-                    'reason': 'ObjectNotFound',  # type: ignore
-                    'message': message,
-                    'help': '',
-                }
+                ErrorItem(
+                    reason='ObjectNotFound',
+                    message=message,
+                    help='',
+                ),
             ],
         ),
     )