fiddler-client 3.12.0rc1__tar.gz → 3.13.0.dev1__tar.gz

{fiddler_client-3.12.0rc1/fiddler_client.egg-info → fiddler_client-3.13.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fiddler-client
-Version: 3.12.0rc1
+Version: 3.13.0.dev1
 Summary: Python client for Fiddler Platform
 Author: Fiddler Labs
 License-Expression: Apache-2.0

fiddler_client-3.13.0.dev1/fiddler/VERSION

@@ -0,0 +1 @@
+3.13.0.dev1

{fiddler_client-3.12.0rc1 → fiddler_client-3.13.0.dev1}/fiddler/connection.py

@@ -52,14 +52,14 @@ class Connection:
 
         connection = Connection(
             url="https://your-fiddler-instance.com",
-            token="your-auth-token"
+            token="your-api-key"
         )
 
         Creating a connection with custom timeout and proxy:
 
         connection = Connection(
             url="https://your-fiddler-instance.com",
-            token="your-auth-token",
+            token="your-api-key",
             timeout=(5.0, 30.0),  # (connect_timeout, read_timeout)
             proxies={"https": "https://proxy.company.com:8080"}
         )
@@ -68,7 +68,7 @@ class Connection:
 
         connection = Connection(
             url="https://your-fiddler-instance.com",
-            token="your-auth-token",
+            token="your-api-key",
             verify=False,  # Not recommended for production
             validate=False  # Skip version compatibility check
         )
@@ -365,14 +365,14 @@ def init(  # pylint: disable=too-many-arguments
 
         fdl.init(
             url="https://your-fiddler-instance.com",
-            token="your-auth-token"
+            token="your-api-key"
         )
 
         Initialization with custom timeout and proxy:
 
         fdl.init(
             url="https://your-fiddler-instance.com",
-            token="your-auth-token",
+            token="your-api-key",
             timeout=(10.0, 60.0),  # 10s connect, 60s read timeout
             proxies={"https": "https://proxy.company.com:8080"}
         )

{fiddler_client-3.12.0rc1 → fiddler_client-3.13.0.dev1}/fiddler/entities/events.py

@@ -4,6 +4,7 @@ import logging
 import os
 import tempfile
 import warnings
+from datetime import datetime
 from pathlib import Path
 from typing import Any
 from uuid import UUID
@@ -18,11 +19,16 @@ from fiddler.decorators import handle_api_error
 from fiddler.entities.file import File
 from fiddler.entities.job import Job
 from fiddler.schemas.dataset import EnvType
-from fiddler.schemas.events import EventsSource, FileSource
+from fiddler.schemas.events import EventsSource, FileSource, TimeRange
 from fiddler.schemas.job import JobCompactResp
 
 logger = logging.getLogger(__name__)
 
+# Maximum number of event ids accepted by the delete events API in a single
+# call, as documented at
+# https://docs.fiddler.ai/sdk-api/rest-api/events/delete-events
+DELETE_EVENT_IDS_LIMIT = 10_000
+
 
 class EventPublisher(ConnectionMixin):
     STREAM_LIMIT = STREAM_EVENT_LIMIT
@@ -141,6 +147,97 @@ class EventPublisher(ConnectionMixin):
             update=update,
         )
 
+    @handle_api_error
+    def delete_events(
+        self,
+        start_time: datetime | str | None = None,
+        end_time: datetime | str | None = None,
+        event_ids: list[str] | None = None,
+        update_metrics: bool = False,
+    ) -> Job:
+        """
+        Delete published production events for this model.
+
+        Events can be selected by a time range, by an explicit list of event
+        ids, or by both. Deletion runs asynchronously on the server; use the
+        returned :class:`~fiddler.entities.job.Job` to track progress.
+
+        AWS SageMaker SigV4 request signing (when configured via the
+        ``AWS_PARTNER_APP_*`` environment variables) is applied automatically,
+        as it is for every other client request.
+
+        :param start_time: Inclusive start of the time window to delete. Accepts
+            a timezone-aware ``datetime`` or an ISO 8601 string with an explicit
+            offset (e.g. ``'2025-11-17T01:00:00Z'``); the value is normalized to
+            UTC. Naive datetimes are rejected. Must be given together with
+            ``end_time``.
+        :param end_time: Exclusive end of the time window to delete. Same format
+            rules as ``start_time``. Must be given together with ``start_time``.
+        :param event_ids: List of up to ``DELETE_EVENT_IDS_LIMIT`` event ids to
+            delete. An empty list is treated as "no id filter" (the same as
+            ``None``), so a programmatically built list that comes back empty
+            still works alongside a time range.
+        :param update_metrics: Whether the server should recompute metrics after
+            the events are deleted.
+
+        :return: Job object for tracking the async deletion.
+
+        :raises ValueError: If neither a time range nor ``event_ids`` is given
+            (to avoid accidentally deleting all events for the model), if only
+            one of ``start_time``/``end_time`` is provided, or if ``event_ids``
+            exceeds ``DELETE_EVENT_IDS_LIMIT``.
+        :raises pydantic.ValidationError: If ``start_time`` or ``end_time`` is a
+            naive datetime (without timezone information).
+        """
+        # Treat an empty event_ids list as "no id filter" so a programmatically
+        # built (possibly empty) list still works alongside a time range,
+        # rather than surfacing a surprising ValueError.
+        if event_ids is not None and len(event_ids) == 0:
+            event_ids = None
+
+        if (start_time is None) != (end_time is None):
+            raise ValueError(
+                'start_time and end_time must be provided together to delete '
+                'events by time range'
+            )
+
+        if start_time is None and event_ids is None:
+            raise ValueError(
+                'Provide a time range (start_time and end_time) and/or '
+                'event_ids. Refusing to delete all events for the model.'
+            )
+
+        if event_ids is not None and len(event_ids) > DELETE_EVENT_IDS_LIMIT:
+            raise ValueError(
+                f'event_ids must contain at most {DELETE_EVENT_IDS_LIMIT:,} '
+                f'ids, got {len(event_ids)}'
+            )
+
+        body: dict[str, Any] = {
+            'model_id': self.model_id,
+            'update_metrics': update_metrics,
+        }
+
+        if start_time is not None:
+            # Serialize to JSON-native types (ISO 8601 strings) so the request
+            # body matches the format documented for the delete events API.
+            body['time_range'] = TimeRange(
+                start_time=start_time,  # type: ignore[arg-type]
+                end_time=end_time,  # type: ignore[arg-type]
+            ).model_dump(mode='json')
+
+        if event_ids is not None:
+            body['event_ids'] = event_ids
+
+        response = self._client().delete(
+            url='/v3/events',
+            data=body,
+            headers={'Content-Type': 'application/json'},
+        )
+
+        job_compact = JobCompactResp(**response.json()['data']['job'])
+        return Job.get(id_=job_compact.id)
+
     def _publish_batch(
         self,
         source: str | Path | pd.DataFrame,

{fiddler_client-3.12.0rc1 → fiddler_client-3.13.0.dev1}/fiddler/entities/model.py

@@ -1296,6 +1296,72 @@ class Model(  # pylint: disable=too-many-public-methods
             update=update,
         )
 
+    @handle_api_error
+    def delete_events(
+        self,
+        start_time: datetime | str | None = None,
+        end_time: datetime | str | None = None,
+        event_ids: builtins.list[str] | None = None,
+        update_metrics: bool = False,
+    ) -> Job:
+        """Delete published production events for this model.
+
+        Select events to delete by a time range, by an explicit list of event
+        ids, or by both. Deletion runs asynchronously on the server; use the
+        returned Job to track progress.
+
+        Args:
+            start_time: Inclusive start of the time window to delete. Accepts a
+                       timezone-aware ``datetime`` or an ISO 8601 string with an
+                       explicit offset (e.g. ``'2025-11-17T01:00:00Z'``); the
+                       value is normalized to UTC. Naive datetimes are rejected.
+                       Must be given together with ``end_time``.
+            end_time: Exclusive end of the time window to delete. Same format
+                     rules as ``start_time``. Must be given together with
+                     ``start_time``.
+            event_ids: List of event ids to delete, up to the documented
+                      per-call limit. An empty list is treated as "no id
+                      filter" (the same as ``None``).
+            update_metrics: Whether the server should recompute metrics after
+                           the events are deleted.
+
+        Returns:
+            :class:`~fiddler.entities.Job`: Async job object. Use ``job.wait()``
+            to block until completion, or check ``job.status`` to poll.
+
+        Raises:
+            ValueError: If neither a time range nor ``event_ids`` is given (to
+                       avoid accidentally deleting all events for the model), if
+                       only one of ``start_time``/``end_time`` is provided, or if
+                       ``event_ids`` exceeds the documented per-call limit.
+            ApiError: If there's an error deleting the events on Fiddler.
+
+        Example:
+            # Delete a window of production events
+            job = model.delete_events(
+                start_time='2025-11-17T01:00:00.000Z',
+                end_time='2025-11-17T02:00:00.000Z',
+                update_metrics=True,
+            )
+            job.wait()
+            print(f"Delete status: {job.status}")
+
+            # Delete specific events by id
+            job = model.delete_events(event_ids=['pred_001', 'pred_002'])
+            job.wait()
+
+        Note:
+            Deletion is irreversible. Provide a time range and/or ``event_ids``
+            to scope the deletion; a call with no filter is rejected.
+        """
+        logger.info('Model[%s/%s] - Deleting events', self.name, self.version)
+        return self._event_publisher.delete_events(
+            start_time=start_time,
+            end_time=end_time,
+            event_ids=event_ids,
+            update_metrics=update_metrics,
+        )
+
     def add_artifact(
         self,
         model_dir: str | Path,

{fiddler_client-3.12.0rc1 → fiddler_client-3.13.0.dev1}/fiddler/schemas/custom_features.py

@@ -298,7 +298,7 @@ class ImageEmbedding(VectorFeature):
 
 
 class Enrichment(CustomFeature):
-    """Represents custom features derived from enrichment operations (Private Preview).
+    """Represents custom features derived from enrichment operations.
 
     Enrichment features apply external processing or analysis to existing columns
     to create derived insights. This can include operations like sentiment analysis,

fiddler_client-3.13.0.dev1/fiddler/schemas/events.py

@@ -0,0 +1,42 @@
+from datetime import datetime, timezone
+from typing import Any, Dict, List
+from uuid import UUID
+
+from pydantic import AwareDatetime, field_validator
+
+from fiddler.constants.events import PublishEventsSourceType
+from fiddler.schemas.base import BaseModel
+
+
+class FileSource(BaseModel):
+    file_id: UUID
+    type: PublishEventsSourceType = PublishEventsSourceType.FILE
+
+
+class EventsSource(BaseModel):
+    events: List[Dict[Any, Any]]
+    type: PublishEventsSourceType = PublishEventsSourceType.EVENTS
+
+
+class TimeRange(BaseModel):
+    """Half-open time window used to filter events for deletion.
+
+    ``start_time`` and ``end_time`` accept timezone-aware
+    :class:`~datetime.datetime` objects or ISO 8601 strings that carry an
+    explicit offset (e.g. ``'2025-11-17T01:00:00Z'`` or
+    ``'2025-11-17T01:00:00+05:00'``). Aware values are normalized to UTC, so
+    ``model_dump(mode='json')`` always emits a ``Z``-suffixed UTC timestamp.
+
+    Naive datetimes (without timezone information) are rejected with a
+    ``ValidationError`` rather than guessed at — for a destructive operation the
+    deleted window must never be ambiguous.
+    """
+
+    start_time: AwareDatetime
+    end_time: AwareDatetime
+
+    @field_validator('start_time', 'end_time', mode='after')
+    @classmethod
+    def _normalize_to_utc(cls, value: datetime) -> datetime:
+        """Convert any aware datetime to UTC for a consistent wire format."""
+        return value.astimezone(timezone.utc)

{fiddler_client-3.12.0rc1 → fiddler_client-3.13.0.dev1}/fiddler/tests/apis/test_events.py

@@ -1,14 +1,19 @@
+import json
 import warnings
+from datetime import datetime, timezone
 from pathlib import Path
 from uuid import uuid4
 import re
 
 import numpy as np
 import pandas as pd
+import pytest
 import responses
 import requests
+from pydantic import ValidationError
 
 from fiddler.constants.dataset import EnvType
+from fiddler.entities.events import EventPublisher
 from fiddler.entities.job import Job
 from fiddler.entities.model import Model
 from fiddler.tests.apis.test_files import SINGLE_UPLOAD_200_RESPONSE
@@ -51,6 +56,14 @@ PUBLISH_JOB_RESPONSE = {
     'kind': 'NORMAL',
 }
 
+DELETE_EVENTS_202_API_RESPONSE = {
+    'data': {
+        'job': {'id': JOB_ID, 'name': 'Delete events'},
+    },
+    'api_version': '3.0',
+    'kind': 'NORMAL',
+}
+
 df = pd.DataFrame(np.random.randint(0, 100, size=(10, 4)), columns=list('ABCD'))
 
 STREAM_PUBLISH_202_API_RESPONSE = {
@@ -395,3 +408,230 @@ def test_publish_deprecated() -> None:
         assert len(w) == 1
         assert issubclass(w[0].category, DeprecationWarning)
         assert 'publish() is deprecated' in str(w[0].message)
+
+
+@responses.activate
+def test_delete_events_by_time_range() -> None:
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=MODEL_API_RESPONSE_200,
+    )
+    model = Model.get(id_=MODEL_ID)
+
+    def _body_matcher(r: requests.PreparedRequest) -> tuple[bool, str]:
+        body = json.loads(r.body)
+        if 'time_range' not in body:
+            return False, f'time_range missing from body: {body}'
+        if body['time_range']['start_time'] != '2025-11-17T01:00:00Z':
+            return False, f'unexpected start_time: {body}'
+        if body.get('update_metrics') is not True:
+            return False, f'update_metrics not forwarded: {body}'
+        return True, 'good'
+
+    responses.delete(
+        url=f'{URL}/v3/events',
+        json=DELETE_EVENTS_202_API_RESPONSE,
+        match=[_body_matcher],
+    )
+    responses.get(
+        url=f'{URL}/v3/jobs/{JOB_ID}',
+        json=PUBLISH_JOB_RESPONSE,
+    )
+
+    job = model.delete_events(
+        start_time=datetime(2025, 11, 17, 1, 0, 0, tzinfo=timezone.utc),
+        end_time=datetime(2025, 11, 17, 2, 0, 0, tzinfo=timezone.utc),
+        update_metrics=True,
+    )
+
+    assert isinstance(job, Job)
+
+
+@responses.activate
+def test_delete_events_by_event_ids() -> None:
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=MODEL_API_RESPONSE_200,
+    )
+    model = Model.get(id_=MODEL_ID)
+
+    responses.delete(
+        url=f'{URL}/v3/events',
+        json=DELETE_EVENTS_202_API_RESPONSE,
+    )
+    responses.get(
+        url=f'{URL}/v3/jobs/{JOB_ID}',
+        json=PUBLISH_JOB_RESPONSE,
+    )
+
+    job = model.delete_events(event_ids=['pred_001', 'pred_002'])
+
+    assert isinstance(job, Job)
+
+
+@responses.activate
+def test_delete_events_accepts_iso_string() -> None:
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=MODEL_API_RESPONSE_200,
+    )
+    model = Model.get(id_=MODEL_ID)
+
+    responses.delete(
+        url=f'{URL}/v3/events',
+        json=DELETE_EVENTS_202_API_RESPONSE,
+    )
+    responses.get(
+        url=f'{URL}/v3/jobs/{JOB_ID}',
+        json=PUBLISH_JOB_RESPONSE,
+    )
+
+    job = model.delete_events(
+        start_time='2025-11-17T01:00:00.000Z',
+        end_time='2025-11-17T02:00:00.000Z',
+    )
+
+    assert isinstance(job, Job)
+
+
+@responses.activate
+def test_delete_events_by_time_range_and_event_ids() -> None:
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=MODEL_API_RESPONSE_200,
+    )
+    model = Model.get(id_=MODEL_ID)
+
+    def _body_matcher(r: requests.PreparedRequest) -> tuple[bool, str]:
+        body = json.loads(r.body)
+        if 'time_range' not in body:
+            return False, f'time_range missing from body: {body}'
+        if body.get('event_ids') != ['pred_001']:
+            return False, f'event_ids missing/incorrect in body: {body}'
+        return True, 'good'
+
+    responses.delete(
+        url=f'{URL}/v3/events',
+        json=DELETE_EVENTS_202_API_RESPONSE,
+        match=[_body_matcher],
+    )
+    responses.get(
+        url=f'{URL}/v3/jobs/{JOB_ID}',
+        json=PUBLISH_JOB_RESPONSE,
+    )
+
+    job = model.delete_events(
+        start_time='2025-11-17T01:00:00.000Z',
+        end_time='2025-11-17T02:00:00.000Z',
+        event_ids=['pred_001'],
+    )
+
+    assert isinstance(job, Job)
+
+
+@responses.activate
+def test_delete_events_empty_event_ids_with_time_range() -> None:
+    # An empty event_ids list is treated as "no id filter", so a delete scoped
+    # by time range still succeeds and the body omits event_ids.
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=MODEL_API_RESPONSE_200,
+    )
+    model = Model.get(id_=MODEL_ID)
+
+    def _body_matcher(r: requests.PreparedRequest) -> tuple[bool, str]:
+        body = json.loads(r.body)
+        if 'event_ids' in body:
+            return False, f'event_ids should be omitted for empty list: {body}'
+        if 'time_range' not in body:
+            return False, f'time_range missing from body: {body}'
+        return True, 'good'
+
+    responses.delete(
+        url=f'{URL}/v3/events',
+        json=DELETE_EVENTS_202_API_RESPONSE,
+        match=[_body_matcher],
+    )
+    responses.get(
+        url=f'{URL}/v3/jobs/{JOB_ID}',
+        json=PUBLISH_JOB_RESPONSE,
+    )
+
+    job = model.delete_events(
+        start_time='2025-11-17T01:00:00.000Z',
+        end_time='2025-11-17T02:00:00.000Z',
+        event_ids=[],
+    )
+
+    assert isinstance(job, Job)
+
+
+@responses.activate
+def test_delete_events_normalizes_non_utc_time_range() -> None:
+    # A non-UTC offset must be converted to UTC on the wire: 01:00+05:00 is
+    # 20:00Z on the previous day.
+    responses.get(
+        url=f'{URL}/v3/models/{MODEL_ID}',
+        json=MODEL_API_RESPONSE_200,
+    )
+    model = Model.get(id_=MODEL_ID)
+
+    def _body_matcher(r: requests.PreparedRequest) -> tuple[bool, str]:
+        body = json.loads(r.body)
+        start = body['time_range']['start_time']
+        if start != '2025-11-16T20:00:00Z':
+            return False, f'start_time not normalized to UTC: {start!r}'
+        return True, 'good'
+
+    responses.delete(
+        url=f'{URL}/v3/events',
+        json=DELETE_EVENTS_202_API_RESPONSE,
+        match=[_body_matcher],
+    )
+    responses.get(
+        url=f'{URL}/v3/jobs/{JOB_ID}',
+        json=PUBLISH_JOB_RESPONSE,
+    )
+
+    job = model.delete_events(
+        start_time='2025-11-17T01:00:00+05:00',
+        end_time='2025-11-17T02:00:00+05:00',
+    )
+
+    assert isinstance(job, Job)
+
+
+def test_delete_events_rejects_naive_datetime() -> None:
+    with pytest.raises(ValidationError):
+        EventPublisher(model_id=MODEL_ID).delete_events(
+            start_time=datetime(2025, 11, 17, 1, 0, 0),
+            end_time=datetime(2025, 11, 17, 2, 0, 0),
+        )
+
+
+def test_delete_events_requires_a_filter() -> None:
+    # Use the publisher directly so the client-side guard is exercised without
+    # an HTTP round-trip.
+    with pytest.raises(ValueError, match='Refusing to delete all events'):
+        EventPublisher(model_id=MODEL_ID).delete_events()
+
+
+def test_delete_events_requires_both_time_bounds() -> None:
+    with pytest.raises(ValueError, match='start_time and end_time'):
+        EventPublisher(model_id=MODEL_ID).delete_events(
+            start_time='2025-11-17T01:00:00.000Z'
+        )
+
+
+def test_delete_events_empty_event_ids_alone_is_no_filter() -> None:
+    # An empty list with no time range collapses to "no filter", which the
+    # refuse-to-delete-all guard rejects.
+    with pytest.raises(ValueError, match='Refusing to delete all events'):
+        EventPublisher(model_id=MODEL_ID).delete_events(event_ids=[])
+
+
+def test_delete_events_rejects_over_limit_event_ids() -> None:
+    with pytest.raises(ValueError, match='at most 10,000'):
+        EventPublisher(model_id=MODEL_ID).delete_events(
+            event_ids=[f'id_{i}' for i in range(10_001)]
+        )

{fiddler_client-3.12.0rc1 → fiddler_client-3.13.0.dev1/fiddler_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fiddler-client
-Version: 3.12.0rc1
+Version: 3.13.0.dev1
 Summary: Python client for Fiddler Platform
 Author: Fiddler Labs
 License-Expression: Apache-2.0

fiddler_client-3.12.0rc1/fiddler/VERSION

@@ -1 +0,0 @@
-3.12.0rc1

fiddler_client-3.12.0rc1/fiddler/schemas/events.py

@@ -1,15 +0,0 @@
-from typing import Any, Dict, List
-from uuid import UUID
-
-from fiddler.constants.events import PublishEventsSourceType
-from fiddler.schemas.base import BaseModel
-
-
-class FileSource(BaseModel):
-    file_id: UUID
-    type: PublishEventsSourceType = PublishEventsSourceType.FILE
-
-
-class EventsSource(BaseModel):
-    events: List[Dict[Any, Any]]
-    type: PublishEventsSourceType = PublishEventsSourceType.EVENTS