fiddler-client 3.10.0__tar.gz → 3.11.0.dev3__tar.gz

{fiddler-client-3.10.0/fiddler_client.egg-info → fiddler_client-3.11.0.dev3}/PKG-INFO

@@ -1,17 +1,35 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: fiddler-client
-Version: 3.10.0
+Version: 3.11.0.dev3
 Summary: Python client for Fiddler Platform
 Home-page: https://fiddler.ai
 Author: Fiddler Labs
-License: UNKNOWN
-Platform: UNKNOWN
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
-Requires-Python: >3.9.0
+Requires-Python: >3.10.0
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
+Requires-Dist: pip>=21.0
+Requires-Dist: requests<3
+Requires-Dist: requests-toolbelt
+Requires-Dist: pydantic>=1.10.17
+Requires-Dist: deprecated==1.2.18
+Requires-Dist: tqdm
+Requires-Dist: simplejson>=3.17.0
+Requires-Dist: pyyaml
+Requires-Dist: typing-extensions<5,>=4.6.0
+Requires-Dist: pandas==3.0.0
+Requires-Dist: pyarrow>=15.0.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # fiddler-client
 
@@ -99,5 +117,3 @@ This package is proprietary software. Please refer to your Fiddler license agree
 ---
 
 **Want to see Fiddler in action?** [Request a demo](https://www.fiddler.ai/demo)
-
-

fiddler_client-3.11.0.dev3/fiddler/VERSION

@@ -0,0 +1 @@
+3.11.0.dev3

{fiddler-client-3.10.0 → fiddler_client-3.11.0.dev3}/fiddler/connection.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+import sys
 from functools import cached_property
 from uuid import UUID
 
@@ -10,6 +11,7 @@ from fiddler.constants.common import (
     CLIENT_NAME,
     FIDDLER_CLIENT_NAME_HEADER,
     FIDDLER_CLIENT_VERSION_HEADER,
+    FIDDLER_PYTHON_VERSION_HEADER,
 )
 from fiddler.decorators import handle_api_error
 from fiddler.exceptions import IncompatibleClient
@@ -71,6 +73,7 @@ class Connection:
             validate=False  # Skip version compatibility check
         )
     """
+
     def __init__(  # pylint: disable=too-many-arguments
         self,
         url: str,
@@ -107,10 +110,12 @@ class Connection:
         if not token:
             raise ValueError('`token` is empty')
 
+        python_version = f'{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}'
         self.request_headers = {
             'Authorization': f'Bearer {token}',
             FIDDLER_CLIENT_NAME_HEADER: CLIENT_NAME,
             FIDDLER_CLIENT_VERSION_HEADER: __version__,
+            FIDDLER_PYTHON_VERSION_HEADER: python_version,
         }
 
         if validate:
@@ -257,6 +262,7 @@ class ConnectionMixin:
         org_name = SomeEntityClass.get_organization_name()
         org_id = SomeEntityClass.get_organization_id()
     """
+
     @classmethod
     def _conn(cls) -> Connection:
         """Get the global Fiddler connection instance.

{fiddler-client-3.10.0 → fiddler_client-3.11.0.dev3}/fiddler/constants/common.py

@@ -7,6 +7,7 @@ JSON_CONTENT_TYPE = 'application/json'
 
 FIDDLER_CLIENT_NAME_HEADER = 'X-Fiddler-Client-Name'
 FIDDLER_CLIENT_VERSION_HEADER = 'X-Fiddler-Client-Version'
+FIDDLER_PYTHON_VERSION_HEADER = 'X-Fiddler-Python-Version'
 
 # Multi-part upload
 MULTI_PART_CHUNK_SIZE = 100 * 1024 * 1024  # 100MB in bytes

{fiddler-client-3.10.0 → fiddler_client-3.11.0.dev3}/fiddler/decorators.py

@@ -1,15 +1,14 @@
+import logging
 from functools import wraps
 from http import HTTPStatus
-import logging
 from typing import Any, Callable, TypeVar, cast
 
-import requests
 import pydantic.v1
+import requests
 
 from fiddler.exceptions import ApiError, Conflict, HttpError, NotFound, Unsupported
 from fiddler.schemas.response import ErrorResponse
 
-
 logger = logging.getLogger(__name__)
 
 _WrappedFuncType = TypeVar(  # pylint: disable=invalid-name

{fiddler-client-3.10.0 → fiddler_client-3.11.0.dev3}/fiddler/entities/alert_rule.py

@@ -148,7 +148,7 @@ class AlertRule(
             metric_id="accuracy",
             priority=Priority.MEDIUM,
             compare_to=CompareTo.TIME_PERIOD,
-            condition=AlertCondition.LT,
+            condition=AlertCondition.LESSER,
             bin_size=BinSize.DAY,
             critical_threshold=0.85,
             compare_bin_delta=7  # Compare to 7 days ago
@@ -257,7 +257,7 @@ class AlertRule(
                 metric_id="accuracy",
                 priority=Priority.MEDIUM,
                 compare_to=CompareTo.TIME_PERIOD,
-                condition=AlertCondition.LT,
+                condition=AlertCondition.LESSER,
                 bin_size=BinSize.DAY,
                 critical_threshold=0.85,
                 compare_bin_delta=7,  # Compare to 7 days ago

{fiddler-client-3.10.0 → fiddler_client-3.11.0.dev3}/fiddler/entities/custom_expression.py

@@ -70,6 +70,7 @@ Example:
         description="Accuracy for high-value customer segment"
     ).create()
 """
+
 from __future__ import annotations
 
 from abc import abstractmethod
@@ -112,6 +113,7 @@ class CustomExpression(BaseEntity, ModelCompactMixin, ProjectCompactMixin):
         This is an abstract base class. Use CustomMetric or Segment subclasses
         for creating specific types of custom expressions.
     """
+
     def __init__(
         self,
         name: str,
@@ -119,7 +121,18 @@ class CustomExpression(BaseEntity, ModelCompactMixin, ProjectCompactMixin):
         definition: str,
         description: str | None = None,
     ) -> None:
-        """Construct a custom expression instance."""
+        """Construct a CustomExpression instance.
+
+        Args:
+            name: Human-readable name for the CustomExpression.
+                 Should be descriptive and follow naming conventions.
+            model_id: UUID or string identifier of the associated Model.
+            definition: Fiddler Query Language (FQL) expression defining the calculation
+                       or filtering logic. Uses SQL-like syntax with functions like
+                       sum(), average(), if(), is_null(), etc.
+            description: Optional human-readable description explaining the purpose
+                        and usage of the CustomExpression.
+        """
         self.name = name
         self.model_id = model_id
         self.definition = definition
@@ -134,8 +147,8 @@ class CustomExpression(BaseEntity, ModelCompactMixin, ProjectCompactMixin):
     @classmethod
     def _get_url(cls, id_: UUID | str | None = None) -> str:
         """Get custom expression resource/item url."""
-        url = f'/v3/{cls._get_url_path()}'
-        return url if not id_ else f'{url}/{id_}'
+        url = f"/v3/{cls._get_url_path()}"
+        return url if not id_ else f"{url}/{id_}"
 
     @staticmethod
     @abstractmethod
@@ -153,11 +166,11 @@ class CustomExpression(BaseEntity, ModelCompactMixin, ProjectCompactMixin):
         resp_obj = CustomMetricResp(**data)
         assert self.model_id
         fields = [
-            'id',
-            'name',
-            'definition',
-            'description',
-            'created_at',
+            "id",
+            "name",
+            "definition",
+            "description",
+            "created_at",
         ]
         for field in fields:
             setattr(self, field, getattr(resp_obj, field, None))
@@ -181,8 +194,8 @@ class CustomExpression(BaseEntity, ModelCompactMixin, ProjectCompactMixin):
 
         # Add remaining fields
         fields = [
-            'id',
-            'created_at',
+            "id",
+            "created_at",
         ]
         for field in fields:
             setattr(instance, field, getattr(resp_obj, field, None))
@@ -194,11 +207,20 @@ class CustomExpression(BaseEntity, ModelCompactMixin, ProjectCompactMixin):
     @classmethod
     @handle_api_error
     def get(cls, id_: UUID | str) -> CustomExpression:
-        """
-        Get the CustomMetric instance using custom metric id.
+        """Retrieve a CustomExpression by its unique identifier.
+
+        Fetches a CustomExpression from the Fiddler platform using its UUID.
+
+        Args:
+            id_: The unique identifier (UUID) of the CustomExpression to retrieve.
+                Can be provided as a UUID object or string representation.
 
-        :param id_: unique uuid format identifier for custom metric
-        :return: CustomMetric instance
+        Returns:
+            The CustomExpression instance with all its configuration and metadata.
+
+        Raises:
+            NotFound: If no CustomExpression exists with the specified ID.
+            ApiError: If there's an error communicating with the Fiddler API.
         """
         response = cls._client().get(url=cls._get_url(id_=id_))
         return cls._from_response(response=response)
@@ -206,37 +228,45 @@ class CustomExpression(BaseEntity, ModelCompactMixin, ProjectCompactMixin):
     @classmethod
     @handle_api_error
     def from_name(cls, name: str, model_id: UUID | str) -> CustomExpression:
-        """
-        Get the custom metric instance of a model from custom metric name
+        """Retrieve a CustomExpression by name and model.
+
+        Fetches a CustomExpression from the Fiddler platform using its name
+        and associated model ID.
 
-        :param name: Custom metric name
-        :param model_id: Model identifier
+        Args:
+            name: The name of the CustomExpression to retrieve.
+            model_id: UUID or string identifier of the associated Model.
 
-        :return: CustomMetric instance for the provided params
+        Returns:
+            The CustomExpression instance for the provided parameters.
+
+        Raises:
+            NotFound: If no CustomExpression exists with the specified name and model.
+            ApiError: If there's an error communicating with the Fiddler API.
         """
 
         _filter = QueryCondition(
             rules=[
-                QueryRule(field='name', operator=OperatorType.EQUAL, value=name),
+                QueryRule(field="name", operator=OperatorType.EQUAL, value=name),
                 QueryRule(
-                    field='model_id', operator=OperatorType.EQUAL, value=model_id
+                    field="model_id", operator=OperatorType.EQUAL, value=model_id
                 ),
             ]
         )
         params: dict[str, Any] = {
-            'filter': _filter.json(),
+            "filter": _filter.json(),
         }
 
         response = cls._client().get(
             url=cls._get_url(),
             params=params,
         )
-        if response.json()['data']['total'] == 0:
+        if response.json()["data"]["total"] == 0:
             raise_not_found(
-                f'{cls._get_display_name()} not found for the given identifier'
+                f"{cls._get_display_name()} not found for the given identifier"
             )
 
-        return cls._from_dict(data=response.json()['data']['items'][0])
+        return cls._from_dict(data=response.json()["data"]["items"][0])
 
     @classmethod
     @handle_api_error
@@ -244,36 +274,69 @@ class CustomExpression(BaseEntity, ModelCompactMixin, ProjectCompactMixin):
         cls,
         model_id: UUID | str,
     ) -> Iterator[CustomExpression]:
-        """Get a list of all custom metrics in the organization."""
+        """List all CustomExpression instances for a model.
+
+        Retrieves all CustomExpression instances associated with a specific model.
+
+        Args:
+            model_id: UUID or string identifier of the Model.
 
-        url = f'/v3/models/{model_id}/{cls._get_url_path()}'
+        Yields:
+            CustomExpression instances for each CustomExpression in the model.
+
+        Raises:
+            ApiError: If there's an error communicating with the Fiddler API.
+        """
+
+        url = f"/v3/models/{model_id}/{cls._get_url_path()}"
 
         for item in cls._paginate(url=url):
             yield cls._from_dict(data=item)
 
     @handle_api_error
     def create(self) -> CustomExpression:
-        """Create a new custom metric."""
+        """Create a new CustomExpression on the Fiddler platform.
+
+        Registers this CustomExpression with the Fiddler platform. The expression
+        must have a name, model_id, and definition specified before calling create().
+
+        Returns:
+            The same CustomExpression instance with updated server-side attributes
+            (id, created_at, etc.).
+
+        Raises:
+            ApiError: If there's an error communicating with the Fiddler API.
+            Conflict: If a CustomExpression with the same name already exists for this model.
+        """
         payload = {
-            'model_id': self.model_id,
-            'name': self.name,
-            'definition': self.definition,
+            "model_id": self.model_id,
+            "name": self.name,
+            "definition": self.definition,
         }
 
         if self.description:
-            payload['description'] = self.description
+            payload["description"] = self.description
 
         response = self._client().post(
             url=self._get_url(),
             data=payload,
-            headers={'Content-Type': 'application/json'},
+            headers={"Content-Type": "application/json"},
         )
         self._refresh_from_response(response=response)
         return self
 
     @handle_api_error
     def delete(self) -> None:
-        """Delete a custom metric."""
+        """Delete this CustomExpression from the Fiddler platform.
+
+        Permanently removes the CustomExpression. This action cannot be undone.
+        Any alert rules or monitors using this CustomExpression must be deleted first.
+
+        Raises:
+            NotFound: If the CustomExpression no longer exists.
+            ApiError: If there's an error communicating with the Fiddler API.
+            Conflict: If the CustomExpression is still being used by alert rules or monitors.
+        """
         assert self.id is not None
 
         self._client().delete(url=self._get_url(id_=self.id))
@@ -295,7 +358,7 @@ class CustomMetric(CustomExpression):
         conversion_rate = CustomMetric(
             name="weekly_conversion_rate",
             model_id=model.id,
-            definition="SUM(CASE WHEN prediction_score > 0.7 AND converted = 1 THEN 1 ELSE 0 END) / SUM(CASE WHEN prediction_score > 0.7 THEN 1 ELSE 0 END)",
+            definition="sum(if(prediction_score > 0.7 and converted == 1, 1, 0)) / sum(if(prediction_score > 0.7, 1, 0))",
             description="Conversion rate for high-confidence predictions"
         ).create()
 
@@ -303,7 +366,7 @@ class CustomMetric(CustomExpression):
         missing_rate = CustomMetric(
             name="feature_missing_rate",
             model_id=model.id,
-            definition="SUM(CASE WHEN income IS NULL THEN 1 ELSE 0 END) / COUNT(*)",
+            definition="sum(if(is_null(income), 1, 0)) / count(income)",
             description="Percentage of records with missing income values"
         ).create()
 
@@ -311,7 +374,7 @@ class CustomMetric(CustomExpression):
         fairness_metric = CustomMetric(
             name="demographic_parity",
             model_id=model.id,
-            definition="ABS(AVG(CASE WHEN gender = 'M' THEN prediction_score ELSE NULL END) - AVG(CASE WHEN gender = 'F' THEN prediction_score ELSE NULL END))",
+            definition="abs((sum(if(gender == 'Male', predicted_churn, 0)) / sum(if(gender == 'Male', 1, 0))) - (sum(if(gender == 'Female', predicted_churn, 0)) / sum(if(gender == 'Female', 1, 0))))",
             description="Demographic parity difference between gender groups"
         ).create()
 
@@ -322,7 +385,7 @@ class CustomMetric(CustomExpression):
             metric_id=conversion_rate.id,
             priority=Priority.HIGH,
             compare_to=CompareTo.TIME_PERIOD,
-            condition=AlertCondition.LT,
+            condition=AlertCondition.LESSER,
             bin_size=BinSize.DAY,
             critical_threshold=0.15,  # Alert if conversion drops below 15%
             compare_bin_delta=7
@@ -333,6 +396,7 @@ class CustomMetric(CustomExpression):
         Complex expressions may impact performance, so optimize for efficiency.
         Test expressions thoroughly before using in production alert rules.
     """
+
     def __init__(
         self,
         name: str,
@@ -348,11 +412,11 @@ class CustomMetric(CustomExpression):
 
     @staticmethod
     def _get_url_path() -> str:
-        return 'custom-metrics'
+        return "custom-metrics"
 
     @staticmethod
     def _get_display_name() -> str:
-        return 'Custom metric'
+        return "Custom metric"
 
 
 class Segment(CustomExpression):
@@ -370,7 +434,7 @@ class Segment(CustomExpression):
         high_value_segment = Segment(
             name="high_value_customers",
             model_id=model.id,
-            definition="customer_lifetime_value > 10000 AND account_age_days > 365",
+            definition="customer_lifetime_value > 10000 and account_age_days > 365",
             description="Customers with high LTV and established accounts"
         ).create()
 
@@ -378,7 +442,7 @@ class Segment(CustomExpression):
         west_coast_segment = Segment(
             name="west_coast_users",
             model_id=model.id,
-            definition="state IN ('CA', 'OR', 'WA')",
+            definition="state == 'CA' or state == 'OR' or state == 'WA'",
             description="Users from West Coast states"
         ).create()
 
@@ -386,7 +450,7 @@ class Segment(CustomExpression):
         high_risk_segment = Segment(
             name="high_risk_applications",
             model_id=model.id,
-            definition="credit_score < 600 OR debt_to_income > 0.4",
+            definition="credit_score < 600 or debt_to_income > 0.4",
             description="Loan applications with elevated risk factors"
         ).create()
 
@@ -394,7 +458,7 @@ class Segment(CustomExpression):
         young_adults_segment = Segment(
             name="young_adults",
             model_id=model.id,
-            definition="age >= 18 AND age <= 35",
+            definition="age >= 18 and age <= 35",
             description="Young adult demographic (18-35 years)"
         ).create()
 
@@ -418,6 +482,7 @@ class Segment(CustomExpression):
         so optimize for efficiency. Segments are particularly useful for fairness
         monitoring and business-critical cohort analysis.
     """
+
     def __init__(
         self,
         name: str,
@@ -433,8 +498,8 @@ class Segment(CustomExpression):
 
     @staticmethod
     def _get_url_path() -> str:
-        return 'segments'
+        return "segments"
 
     @staticmethod
     def _get_display_name() -> str:
-        return 'Segment'
+        return "Segment"

{fiddler-client-3.10.0 → fiddler_client-3.11.0.dev3}/fiddler/entities/model.py

@@ -35,6 +35,7 @@ Example:
     prod_data = pd.read_csv("production_events.csv")
     job = model.publish(source=prod_data, environment=fiddler.EnvType.PRODUCTION)
 """
+
 from __future__ import annotations
 
 import builtins
@@ -66,7 +67,7 @@ from fiddler.schemas.filter_query import OperatorType, QueryCondition, QueryRule
 from fiddler.schemas.job import JobCompactResp
 from fiddler.schemas.model import ModelResp
 from fiddler.schemas.model_deployment import DeploymentParams
-from fiddler.schemas.model_schema import ModelSchema
+from fiddler.schemas.model_schema import Column, ModelSchema
 from fiddler.schemas.model_spec import ModelSpec
 from fiddler.schemas.model_task_params import ModelTaskParams
 from fiddler.schemas.xai_params import XaiParams
@@ -575,6 +576,93 @@ class Model(
         )
         self._refresh_from_response(response=response)
 
+    @handle_api_error
+    def add_column(
+        self,
+        column: Column,
+        column_type: str = 'metadata',
+    ) -> None:
+        """Add a new column to the model schema.
+
+        Updates both the schema and spec to include the new column. This allows
+        you to extend your model with additional columns after initial creation.
+
+        .. versionadded:: 3.11.0
+
+        Args:
+            column: Column object defining the new column's properties (name, data_type, etc.)
+            column_type: Type of column in spec. One of: 'inputs', 'outputs', 'targets',
+                        'decisions', 'metadata'. Defaults to 'metadata'.
+
+        Raises:
+            ValueError: If column already exists or column_type is invalid
+            BadRequest: If column definition is invalid per backend validation
+
+        Example:
+            # Add a numeric metadata column
+            new_col = Column(
+                name="customer_segment",
+                data_type=DataType.INTEGER,
+                min=1,
+                max=5
+            )
+            model.add_column(column=new_col, column_type='metadata')
+
+            # Add a categorical feature
+            category_col = Column(
+                name="region",
+                data_type=DataType.CATEGORY,
+                categories=["US", "EU", "APAC"]
+            )
+            model.add_column(column=category_col, column_type='inputs')
+
+        Note:
+            - Adding a column doesn't populate historical data; new column will be null
+              for past events
+            - Column names must be unique within the model
+            - After adding a column, include it in future event publishing
+        """
+        valid_column_types = [
+            'inputs',
+            'outputs',
+            'targets',
+            'decisions',
+            'metadata',
+        ]
+
+        if column_type not in valid_column_types:
+            raise ValueError(
+                f"column_type must be one of {valid_column_types}, got: '{column_type}'"
+            )
+
+        # Check if column already exists
+        existing_names = [col.name for col in self.schema.columns]
+        if column.name in existing_names:
+            raise ValueError(
+                f"Column '{column.name}' already exists in model schema. "
+                f'Cannot add existing column.'
+            )
+
+        # Create updated schema with new column
+        updated_columns = [col.dict() for col in self.schema.columns] + [column.dict()]
+
+        # Create updated spec with new column
+        updated_spec = self.spec.dict()
+        current_list = updated_spec.get(column_type) or []
+        updated_spec[column_type] = current_list + [column.name]
+
+        body: dict[str, Any] = {
+            'schema': {'columns': updated_columns},
+            'spec': updated_spec,
+        }
+
+        response = self._client().patch(
+            url=self._get_url(id_=self.id),
+            json=body,
+        )
+
+        self._refresh_from_response(response=response)
+
     @classmethod
     @handle_api_error
     def list(
@@ -967,7 +1055,7 @@ class Model(
 
         Args:
             source: Data to publish. Supported formats:
-                   - **File path (str/Path)**: CSV, Parquet, or JSON files.
+                   - **File path (str/Path)**: CSV or Parquet files.
                      Best for large datasets and batch uploads.
                    - **DataFrame**: Pandas DataFrame with prediction events.
                      Good for programmatic uploads and real-time data.
@@ -1185,6 +1273,7 @@ class ModelCompact:
         print(f"Task: {full_model.task}")
         print(f"Schema: {len(full_model.schema.columns)} columns")
     """
+
     id: UUID
     name: str
     version: str | None = None

{fiddler-client-3.10.0 → fiddler_client-3.11.0.dev3}/fiddler/exceptions.py

@@ -46,7 +46,7 @@ class BaseError(Exception):
         return self.__class__.__name__
 
 
-class IncompatibleClient(BaseError):
+class IncompatibleClient(BaseError):  # noqa: N818
     """Raised when the Python client version is incompatible with the Fiddler platform version.
 
     This exception occurs during connection initialization when the client library
@@ -88,7 +88,7 @@ class IncompatibleClient(BaseError):
         super().__init__(self.message)
 
 
-class AsyncJobFailed(BaseError):
+class AsyncJobFailed(BaseError):  # noqa: N818
     """Raised when an asynchronous job fails to execute successfully.
 
     This exception is thrown when long-running operations (such as model training,
@@ -120,7 +120,7 @@ class AsyncJobFailed(BaseError):
     """
 
 
-class Unsupported(BaseError):
+class Unsupported(BaseError):  # noqa: N818
     """Raised when an unsupported operation is attempted.
 
     This exception occurs when users try to perform operations that are not
@@ -176,7 +176,7 @@ class HttpError(BaseError):
     """
 
 
-class ConnTimeout(HttpError):
+class ConnTimeout(HttpError):  # noqa: N818
     """Raised when a connection timeout occurs during HTTP requests.
 
     This exception was used to indicate that an HTTP request to the Fiddler
@@ -289,7 +289,7 @@ class ApiError(HttpError):
         super().__init__(self.message)
 
 
-class NotFound(ApiError):
+class NotFound(ApiError):  # noqa: N818
     """Raised when a requested resource is not found (HTTP 404).
 
     This exception is thrown when attempting to access or manipulate a resource
@@ -332,7 +332,7 @@ class NotFound(ApiError):
     reason: str = 'NotFound'
 
 
-class Conflict(ApiError):
+class Conflict(ApiError):  # noqa: N818
     """Raised when a request conflicts with the current state of a resource (HTTP 409).
 
     This exception occurs when attempting to perform an operation that conflicts

{fiddler-client-3.10.0 → fiddler_client-3.11.0.dev3}/fiddler/schemas/alert_rule.py

@@ -9,7 +9,7 @@ from fiddler.constants.alert_rule import (
     AlertThresholdAlgo,
     BinSize,
     CompareTo,
-    Priority
+    Priority,
 )
 from fiddler.schemas.base import BaseModel
 from fiddler.schemas.baseline import BaselineCompactResp