fiddler-client 3.0.0.dev10__tar.gz → 3.1.0.dev1__tar.gz

{fiddler-client-3.0.0.dev10/fiddler_client.egg-info → fiddler-client-3.1.0.dev1}/PKG-INFO

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

fiddler-client-3.1.0.dev1/fiddler/VERSION

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

{fiddler-client-3.0.0.dev10 → fiddler-client-3.1.0.dev1}/fiddler/__init__.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from fiddler.connection import Connection, ConnectionMixin, init  # noqa
 from fiddler.constants.alert_rule import (  # noqa
     AlertCondition,
@@ -5,7 +7,7 @@ from fiddler.constants.alert_rule import (  # noqa
     CompareTo,
     Priority,
 )
-from fiddler.constants.baseline import BaselineType, WindowSize  # noqa
+from fiddler.constants.baseline import BaselineType, WindowBinSize  # noqa
 from fiddler.constants.dataset import EnvType  # noqa
 from fiddler.constants.job import JobStatus  # noqa
 from fiddler.constants.model import (  # noqa
@@ -19,14 +21,14 @@ from fiddler.constants.model_deployment import ArtifactType, DeploymentType  # n
 from fiddler.constants.xai import ExplainMethod  # noqa
 from fiddler.entities.alert_record import AlertRecord  # noqa
 from fiddler.entities.alert_rule import AlertRule  # noqa
-from fiddler.entities.baseline import Baseline  # noqa
+from fiddler.entities.baseline import Baseline, BaselineCompact  # noqa
 from fiddler.entities.custom_expression import CustomMetric, Segment  # noqa
-from fiddler.entities.dataset import Dataset  # noqa
+from fiddler.entities.dataset import Dataset, DatasetCompact  # noqa
 from fiddler.entities.file import File  # noqa
 from fiddler.entities.job import Job  # noqa
-from fiddler.entities.model import Model  # noqa
+from fiddler.entities.model import Model, ModelCompact  # noqa
 from fiddler.entities.model_deployment import ModelDeployment  # noqa
-from fiddler.entities.project import Project  # noqa
+from fiddler.entities.project import Project, ProjectCompact  # noqa
 from fiddler.entities.webhook import Webhook  # noqa
 from fiddler.exceptions import (  # noqa
     ApiError,
@@ -62,11 +64,22 @@ from fiddler.schemas.xai_params import XaiParams  # noqa
 from fiddler.utils.logger import set_logging  # noqa
 from fiddler.version import __version__  # noqa
 
+# Global connection object
+conn: Connection | None = None
+
+
+def set_conn(conn_: Connection) -> None:
+    """Set global conn variable"""
+    global conn
+    conn = conn_
+
+
 __all__ = [
     '__version__',
     'Connection',
     'ConnectionMixin',
     'init',
+    'conn',
     # Constants
     'AlertCondition',
     'ArtifactStatus',
@@ -82,7 +95,7 @@ __all__ = [
     'ModelInputType',
     'ModelTask',
     'Priority',
-    'WindowSize',
+    'WindowBinSize',
     # Schemas
     'CustomFeature',
     'DatasetDataSource',
@@ -103,13 +116,17 @@ __all__ = [
     'AlertRecord',
     'AlertRule',
     'Baseline',
+    'BaselineCompact',
     'Dataset',
+    'DatasetCompact',
     'CustomMetric',
     'File',
     'Job',
     'Model',
+    'ModelCompact',
     'ModelDeployment',
     'Project',
+    'ProjectCompact',
     'Segment',
     'Webhook',
     # Exceptions

{fiddler-client-3.0.0.dev10 → fiddler-client-3.1.0.dev1}/fiddler/connection.py

@@ -15,9 +15,6 @@ from fiddler.version import __version__
 
 logger = get_logger(__name__)
 
-# Global connection object
-connection: Connection | None = None
-
 
 class Connection:
     def __init__(  # pylint: disable=too-many-arguments
@@ -123,35 +120,37 @@ class Connection:
 
 class ConnectionMixin:
     @classmethod
-    def _connection(cls) -> Connection:
+    def _conn(cls) -> Connection:
         """Fiddler connection instance"""
-        assert connection is not None
-        return connection
+        from fiddler import conn
+
+        assert conn is not None
+        return conn
 
     @classmethod
     def _client(cls) -> RequestClient:
         """Request client instance"""
-        return cls._connection().client
+        return cls._conn().client
 
     @property
     def organization_name(self) -> str:
         """Organization name property"""
-        return self._connection().server_info.organization.name
+        return self._conn().server_info.organization.name
 
     @property
     def organization_id(self) -> UUID:
         """Organization id property"""
-        return self._connection().server_info.organization.id
+        return self._conn().server_info.organization.id
 
     @classmethod
     def get_organization_name(cls) -> str:
         """Organization name"""
-        return cls._connection().server_info.organization.name
+        return cls._conn().server_info.organization.name
 
     @classmethod
     def get_organization_id(cls) -> UUID:
         """Organization id"""
-        return cls._connection().server_info.organization.id
+        return cls._conn().server_info.organization.id
 
 
 def init(  # pylint: disable=too-many-arguments
@@ -173,8 +172,9 @@ def init(  # pylint: disable=too-many-arguments
     :param validate: Whether to validate the server/client version compatibility.
          Some functionalities might not work if this is turned off.
     """
-    global connection  # pylint: disable=global-statement
-    connection = Connection(
+    from fiddler import set_conn
+
+    conn = Connection(
         url=url,
         token=token,
         proxies=proxies,
@@ -182,3 +182,5 @@ def init(  # pylint: disable=too-many-arguments
         verify=verify,
         validate=validate,
     )
+
+    set_conn(conn_=conn)

fiddler-client-3.1.0.dev1/fiddler/constants/baseline.py

@@ -0,0 +1,15 @@
+import enum
+
+
+@enum.unique
+class BaselineType(str, enum.Enum):
+    STATIC = 'STATIC'
+    ROLLING = 'ROLLING'
+
+
+@enum.unique
+class WindowBinSize(str, enum.Enum):
+    HOUR = 'Hour'
+    DAY = 'Day'
+    WEEK = 'Week'
+    MONTH = 'Month'

{fiddler-client-3.0.0.dev10 → fiddler-client-3.1.0.dev1}/fiddler/entities/baseline.py

@@ -5,6 +5,7 @@ from datetime import datetime
 from typing import Any, Iterator
 from uuid import UUID
 
+from fiddler.constants.baseline import WindowBinSize
 from fiddler.constants.dataset import EnvType
 from fiddler.decorators import handle_api_error
 from fiddler.entities.base import BaseEntity
@@ -28,8 +29,8 @@ class Baseline(
         dataset_id: UUID | str | None = None,
         start_time: int | None = None,
         end_time: int | None = None,
-        offset: int | None = None,
-        window_size: int | None = None,
+        offset_delta: int | None = None,
+        window_bin_size: WindowBinSize | str | None = None,
     ) -> None:
         """Construct a baseline instance."""
         self.name = name
@@ -39,8 +40,8 @@ class Baseline(
         self.dataset_id = dataset_id
         self.start_time = start_time
         self.end_time = end_time
-        self.offset = offset
-        self.window_size = window_size
+        self.offset_delta = offset_delta
+        self.window_bin_size = window_bin_size
 
         self.id: UUID | None = None
         self.row_count: int | None = None
@@ -73,8 +74,8 @@ class Baseline(
             type_=resp_obj.type,
             start_time=resp_obj.start_time,
             end_time=resp_obj.end_time,
-            offset=resp_obj.offset,
-            window_size=resp_obj.window_size,
+            offset_delta=resp_obj.offset_delta,
+            window_bin_size=resp_obj.window_bin_size,
         )
 
         # Add remaining fields
@@ -109,8 +110,8 @@ class Baseline(
             'type',
             'start_time',
             'end_time',
-            'offset',
-            'window_size',
+            'offset_delta',
+            'window_bin_size',
             'created_at',
             'updated_at',
             'row_count',
@@ -210,10 +211,10 @@ class Baseline(
             payload['start_time'] = self.start_time
         if self.end_time:
             payload['end_time'] = self.end_time
-        if self.offset:
-            payload['offset'] = self.offset
-        if self.window_size:
-            payload['window_size'] = self.window_size
+        if self.offset_delta:
+            payload['offset_delta'] = self.offset_delta
+        if self.window_bin_size:
+            payload['window_bin_size'] = self.window_bin_size
 
         response = self._client().post(
             url=self._get_url(),

{fiddler-client-3.0.0.dev10 → fiddler-client-3.1.0.dev1}/fiddler/entities/events.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
+import tempfile
 from pathlib import Path
-from typing import Any, Iterator
+from typing import Any
 from uuid import UUID
 
 import pandas as pd
 from requests import Response
+from tqdm import tqdm
 
 from fiddler.configs import STREAM_EVENT_LIMIT
 from fiddler.connection import ConnectionMixin
@@ -28,21 +30,6 @@ class EventPublisher(ConnectionMixin):
         """
         self.model_id = model_id
 
-    def _get_stream_chunks(
-        self, source: pd.DataFrame | list[dict[str, Any]]
-    ) -> Iterator[list[dict[str, Any]]]:
-        """Chunk the source based on stream limit"""
-
-        for i in range(0, len(source), self.STREAM_LIMIT):
-            chunk = source[i : i + self.STREAM_LIMIT]
-
-            if isinstance(chunk, pd.DataFrame):
-                events = chunk.to_dict('records')
-            else:
-                events = chunk
-
-            yield events
-
     @handle_api_error
     def publish(
         self,
@@ -56,13 +43,13 @@ class EventPublisher(ConnectionMixin):
 
         :param source: one of:
             Path or str path: path for data file.
-            list[dict]: list of event dicts (max 1000) EnvType.PRE_PRODUCTION is not supported
-            dataframe: events dataframe. EnvType.PRE_PRODUCTION not supported.
+            dataframe: events dataframe.
+            list[dict]: list of event dicts EnvType.PRE_PRODUCTION is not supported
         :param environment: Either EnvType.PRE_PRODUCTION or EnvType.PRODUCTION
         :param dataset_name: Name of the dataset. Not supported for EnvType.PRODUCTION
         :param update: flag indicating if the events are updates to previously published rows
 
-        :return: list[UUID] for list of dicts or dataframe source and Job object for file path source.
+        :return: list[UUID] for list of dicts source and Job object for file path or dataframe source.
         """
         if isinstance(source, (str, Path)):
             return self._publish_file(
@@ -72,20 +59,30 @@ class EventPublisher(ConnectionMixin):
                 update=update,
             )
 
-        if isinstance(source, (list, pd.DataFrame)):
+        if isinstance(source, pd.DataFrame):
+            with tempfile.NamedTemporaryFile(suffix='.csv') as temp_file:
+                source.to_csv(temp_file.name, index=False)
+                return self._publish_file(
+                    source=temp_file.name,
+                    environment=environment,
+                    dataset_name=dataset_name,
+                    update=update,
+                )
+
+        elif isinstance(source, list):
             return self._publish_stream(source=source, update=update)
 
         raise ValueError(f'Unsupported source - {type(source)}')
 
     def _publish_stream(
         self,
-        source: list[dict[str, Any]] | pd.DataFrame,
+        source: list[dict[str, Any]],
         update: bool = False,
     ) -> list[UUID]:
         event_ids = []
-        for events in self._get_stream_chunks(source=source):
+        for i in tqdm(range(0, len(source), self.STREAM_LIMIT)):
             response = self._publish_call(
-                source=EventsSource(events=events),
+                source=EventsSource(events=source[i : i + self.STREAM_LIMIT]),
                 environment=EnvType.PRODUCTION,
                 dataset_name=None,
                 update=update,

{fiddler-client-3.0.0.dev10 → fiddler-client-3.1.0.dev1}/fiddler/entities/model.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import builtins
+import copy
 import typing
 from dataclasses import dataclass
 from datetime import datetime
@@ -52,6 +53,7 @@ class Model(
         project_id: UUID | str,
         schema: ModelSchema,
         spec: ModelSpec,
+        version: str | None = None,
         input_type: str = ModelInputType.TABULAR,
         task: str = ModelTask.NOT_SET,
         task_params: ModelTaskParams | None = None,
@@ -63,6 +65,7 @@ class Model(
     ) -> None:
         """Construct a model instance"""
         self.name = name
+        self.version = version
         self.project_id = project_id
         self.schema = schema
         self.input_type = input_type
@@ -101,6 +104,7 @@ class Model(
         # Initialize
         instance = cls(
             name=resp_obj.name,
+            version=resp_obj.version,
             schema=resp_obj.schema_,
             spec=resp_obj.spec,
             project_id=resp_obj.project.id,
@@ -141,6 +145,7 @@ class Model(
         fields = [
             'id',
             'name',
+            'version',
             'spec',
             'input_type',
             'task',
@@ -188,12 +193,20 @@ class Model(
 
     @classmethod
     @handle_api_error
-    def from_name(cls, name: str, project_id: UUID | str) -> Model:
+    def from_name(
+        cls,
+        name: str,
+        project_id: UUID | str,
+        version: str | None = None,
+        latest: bool = False,
+    ) -> Model:
         """
         Get the model instance from model name within a project.
 
         :param name: Model name
         :param project_id: Project identifier
+        :param version: Version name
+        :param latest: Whether to fetch the latest version of the model or first version
         :return: Model instance
         """
         _filter = QueryCondition(
@@ -207,8 +220,15 @@ class Model(
             ]
         )
 
+        if version:
+            _filter.add_rule(
+                QueryRule(field='version', operator=OperatorType.EQUAL, value=version)
+            )
+
+        ordering = '-created_at' if latest else 'created_at'
         response = cls._client().get(
-            url=cls._get_url(), params={'filter': _filter.json()}
+            url=cls._get_url(),
+            params={'filter': _filter.json(), 'limit': 1, 'ordering': ordering},
         )
 
         if response.json()['data']['total'] == 0:
@@ -219,22 +239,27 @@ class Model(
     @handle_api_error
     def create(self) -> Model:
         """Create a new model."""
+        payload = {
+            'name': self.name,
+            'project_id': str(self.project_id),
+            'schema': self.schema.dict(),
+            'spec': self.spec.dict(),
+            'input_type': self.input_type,
+            'task': self.task,
+            'task_params': self.task_params.dict(),
+            'description': self.description,
+            'event_id_col': self.event_id_col,
+            'event_ts_col': self.event_ts_col,
+            'event_ts_format': self.event_ts_format,
+            'xai_params': self.xai_params.dict(),
+        }
+
+        if self.version:
+            payload['version'] = self.version
+
         response = self._client().post(
             url=self._get_url(),
-            data={
-                'name': self.name,
-                'project_id': str(self.project_id),
-                'schema': self.schema.dict(),
-                'spec': self.spec.dict(),
-                'input_type': self.input_type,
-                'task': self.task,
-                'task_params': self.task_params.dict(),
-                'description': self.description,
-                'event_id_col': self.event_id_col,
-                'event_ts_col': self.event_ts_col,
-                'event_ts_format': self.event_ts_format,
-                'xai_params': self.xai_params.dict(),
-            },
+            data=payload,
         )
         self._refresh_from_response(response=response)
         return self
@@ -243,6 +268,7 @@ class Model(
     def update(self) -> None:
         """Update an existing model."""
         body: dict[str, Any] = {
+            'version': self.version,
             'xai_params': self.xai_params.dict(),
             'description': self.description,
             'event_id_col': self.event_id_col,
@@ -256,13 +282,13 @@ class Model(
     @classmethod
     @handle_api_error
     def list(
-        cls,
-        project_id: UUID | str,
+        cls, project_id: UUID | str, name: str | None = None
     ) -> Iterator[ModelCompact]:
         """
         Get a list of all models with the given filters
 
         :param project_id: Project identifier
+        :param name: Model name, use this for listing all the versions of a model
         :return: ModelCompact iterator
         """
         _filter = QueryCondition(
@@ -273,11 +299,34 @@ class Model(
             ]
         )
 
+        if name:
+            _filter.add_rule(
+                QueryRule(field='name', operator=OperatorType.EQUAL, value=name)
+            )
+
         params = {'filter': _filter.json()}
 
         for model in cls._paginate(url=cls._get_url(), params=params):
             yield ModelCompact(id=model['id'], name=model['name'])
 
+    def duplicate(self, version: str | None = None) -> Model:
+        """
+        Duplicate the model instance with the given version name.
+
+        This call will not save the model on server. After making changes to the model
+        instance call .create() to add the model version to Fiddler Platform.
+
+        :param version: Version name for the new instance
+        :return: Model instance
+        """
+        self_copy = copy.deepcopy(self)
+        self_copy.id = None
+
+        if version:
+            self_copy.version = version
+
+        return self_copy
+
     @property
     def datasets(self) -> Iterator[Dataset]:
         """Fetch all the datasets of this model"""
@@ -316,6 +365,7 @@ class Model(
         name: str,
         project_id: UUID | str,
         spec: ModelSpec | None = None,
+        version: str | None = None,
         input_type: str = ModelInputType.TABULAR,
         task: str = ModelTask.NOT_SET,
         task_params: ModelTaskParams | None = None,
@@ -334,6 +384,7 @@ class Model(
         :param name: Model name
         :param project_id: Project identifier
         :param spec: ModelSpec instance
+        :param version: Model version name
         :param input_type: Model input task type
         :param task: Model task like Regression, Binary classification etc.
         :param task_params: Parameters based on the task type
@@ -354,6 +405,7 @@ class Model(
 
         return Model(
             name=name,
+            version=version,
             schema=resp_obj.schema_,
             spec=resp_obj.spec,
             project_id=project_id,

{fiddler-client-3.0.0.dev10 → fiddler-client-3.1.0.dev1}/fiddler/entities/model_deployment.py

@@ -110,7 +110,7 @@ class ModelDeployment(
         self._refresh_from_response(response=response)
 
     @classmethod
-    def of(cls, model_id: UUID) -> ModelDeployment:
+    def of(cls, model_id: UUID | str) -> ModelDeployment:
         """
         Get model deployment instance of the given model
 

{fiddler-client-3.0.0.dev10 → fiddler-client-3.1.0.dev1}/fiddler/schemas/baseline.py

@@ -24,8 +24,8 @@ class BaselineResp(BaseModel):
     type: str
     start_time: Optional[int]
     end_time: Optional[int]
-    offset: Optional[int]
-    window_size: Optional[int]
+    offset_delta: Optional[int]
+    window_bin_size: Optional[str]
     row_count: Optional[int]
 
     model: ModelCompactResp

{fiddler-client-3.0.0.dev10 → fiddler-client-3.1.0.dev1}/fiddler/schemas/model.py

@@ -22,6 +22,7 @@ class ModelCompactResp(BaseModel):
 class ModelResp(BaseModel):
     id: UUID
     name: str
+    version: str
     input_type: str
     task: str
     task_params: ModelTaskParams

{fiddler-client-3.0.0.dev10 → fiddler-client-3.1.0.dev1}/fiddler/tests/apis/test_baseline.py

@@ -29,8 +29,8 @@ API_RESPONSE_200 = {
         'type': 'STATIC',
         'start_time': None,
         'end_time': None,
-        'offset': None,
-        'window_size': None,
+        'offset_delta': None,
+        'window_bin_size': None,
         'row_count': 20000,
         'model': {
             'id': MODEL_ID,
@@ -80,8 +80,8 @@ LIST_API_RESPONSE = {
                 'type': 'STATIC',
                 'start_time': None,
                 'end_time': None,
-                'offset': None,
-                'window_size': None,
+                'offset_delta': None,
+                'window_bin_size': None,
                 'row_count': 20000,
                 'model': {
                     'id': MODEL_ID,