arthur-client 1.4.0__py3-none-any.whl → 1.4.1186__py3-none-any.whl

arthur/client/rest/insights/client.py

@@ -1,199 +0,0 @@
-from typing import Optional, Any, Union, Dict, List, Tuple
-from http import HTTPStatus
-from requests.cookies import RequestsCookieJar
-from requests import Response
-
-# import http client
-from arthur.client.http.requests import HTTPClient
-
-from arthur.client.rest.insights.models import (
-    Insight,
-    InsightPatch,
-    InsightUpdateResponse,
-    ModelInsightCount,
-    PaginatedInsightGroupCounts,
-    PaginatedInsights,
-)
-
-
-PATH_PREFIX = "/api"
-
-
-class ArthurInsightsClient:
-    """
-    A Python client to interact with the Arthur Insights API
-    """
-
-    def __init__(self, http_client: HTTPClient):
-        """
-        Create a new ArthurInsightsClient from an HTTPClient
-
-        :param http_client: the :class:`~arthurai.client.http.requests.HTTPClient` to use for underlying requests
-        """
-        self.http_client = http_client
-        self.http_client.set_path_prefix(PATH_PREFIX)
-
-    def get_all_insight_counts_by_model(
-        self,
-        status: Optional[str] = None,
-        start_time: Optional[str] = None,
-        end_time: Optional[str] = None,
-    ) -> List[ModelInsightCount]:
-        """
-        Retrieves insight counts by model id for all active models in the current organization
-
-        If a model has no insights that fit the search criteria, the model_id will not be included in the response.
-
-        :param status:
-        :param start_time:
-        :param end_time:
-        """
-
-        params: Dict[str, Any] = {}
-        if status is not None:
-            params["status"] = status
-        if start_time is not None:
-            params["start_time"] = start_time
-        if end_time is not None:
-            params["end_time"] = end_time
-
-        parsed_resp: Dict[str, Any] = self.http_client.get(  # type: ignore
-            f"/v3/insights/model_counts", params=params, validation_response_code=200
-        )
-        return List[ModelInsightCount](**parsed_resp)
-
-    def get_paginated_model_insights(
-        self,
-        model_id: str,
-        page: Optional[int] = None,
-        page_size: Optional[int] = None,
-        sort: Optional[str] = None,
-        start_time: Optional[str] = None,
-        end_time: Optional[str] = None,
-        status: Optional[str] = None,
-        batch_id: Optional[str] = None,
-    ) -> PaginatedInsights:
-        """
-        Retrieve a paginated list of insights for the specific model
-
-        :param model_id:
-        :param page:
-        :param page_size:
-        :param sort:
-        :param start_time:
-        :param end_time:
-        :param status:
-        :param batch_id:
-        """
-
-        params: Dict[str, Any] = {}
-        if page is not None:
-            params["page"] = page
-        if page_size is not None:
-            params["page_size"] = page_size
-        if sort is not None:
-            params["sort"] = sort
-        if start_time is not None:
-            params["start_time"] = start_time
-        if end_time is not None:
-            params["end_time"] = end_time
-        if status is not None:
-            params["status"] = status
-        if batch_id is not None:
-            params["batch_id"] = batch_id
-
-        parsed_resp: Dict[str, Any] = self.http_client.get(  # type: ignore
-            f"/v3/models/{model_id}/insights",
-            params=params,
-            validation_response_code=200,
-        )
-        return PaginatedInsights(**parsed_resp)
-
-    def update_model_insights_status(
-        self, model_id: str, json_body: InsightPatch
-    ) -> InsightUpdateResponse:
-        """
-        Update the status of the insights for a specific model
-
-        :param model_id:
-        :param json_body:
-        """
-
-        parsed_resp: Dict[str, Any] = self.http_client.patch(  # type: ignore
-            f"/v3/models/{model_id}/insights",
-            json=json_body.dict(by_alias=True, exclude_none=True),
-            validation_response_code=200,
-        )
-        return InsightUpdateResponse(**parsed_resp)
-
-    def get_insight_group_counts(
-        self,
-        model_id: str,
-        page: Optional[int] = None,
-        page_size: Optional[int] = None,
-        sort: Optional[str] = None,
-        status: Optional[str] = None,
-        batch_id: Optional[str] = None,
-    ) -> PaginatedInsightGroupCounts:
-        """
-        Retrieve a paginated list of insight groups for this model
-
-        Each group contains a key (batch_id for batch models or window_start for streaming models), a group timestamp, and a count of the number of insights that belong to the group.
-
-        :param model_id:
-        :param page:
-        :param page_size:
-        :param sort:
-        :param status:
-        :param batch_id:
-        """
-
-        params: Dict[str, Any] = {}
-        if page is not None:
-            params["page"] = page
-        if page_size is not None:
-            params["page_size"] = page_size
-        if sort is not None:
-            params["sort"] = sort
-        if status is not None:
-            params["status"] = status
-        if batch_id is not None:
-            params["batch_id"] = batch_id
-
-        parsed_resp: Dict[str, Any] = self.http_client.get(  # type: ignore
-            f"/v3/models/{model_id}/insights/group_counts",
-            params=params,
-            validation_response_code=200,
-        )
-        return PaginatedInsightGroupCounts(**parsed_resp)
-
-    def get_model_insight_by_id(self, model_id: str, insight_id: str) -> Insight:
-        """
-        Retrieve insight for the specific model and insight id
-
-        :param model_id:
-        :param insight_id:
-        """
-
-        parsed_resp: Dict[str, Any] = self.http_client.get(  # type: ignore
-            f"/v3/models/{model_id}/insights/{insight_id}", validation_response_code=200
-        )
-        return Insight(**parsed_resp)
-
-    def update_insight_status(
-        self, model_id: str, insight_id: str, json_body: InsightPatch
-    ) -> InsightUpdateResponse:
-        """
-        Update the status of the insight for a specific model and insight id
-
-        :param model_id:
-        :param insight_id:
-        :param json_body:
-        """
-
-        parsed_resp: Dict[str, Any] = self.http_client.patch(  # type: ignore
-            f"/v3/models/{model_id}/insights/{insight_id}",
-            json=json_body.dict(by_alias=True, exclude_none=True),
-            validation_response_code=200,
-        )
-        return InsightUpdateResponse(**parsed_resp)

arthur/client/rest/insights/models.py

@@ -1,182 +0,0 @@
-# generated by datamodel-codegen:
-#   filename:  insights.yaml
-#   timestamp: 2024-01-29T20:41:18+00:00
-
-from __future__ import annotations
-
-from datetime import datetime
-from enum import Enum
-from typing import Dict, List, Optional
-
-from arthur.client.rest.common.models import Page, PageSize, TotalCount, TotalPages
-from pydantic import BaseModel, Extra
-
-
-class Operator(BaseModel):
-    """
-    Operator for a metric region
-    """
-
-    class Config:
-        extra = Extra.allow
-
-    __root__: Optional[Dict[str, float]] = None
-
-
-class InsightUpdateResponse(BaseModel):
-    """
-    Information on the outcome of an insight(s) update
-    """
-
-    updated_count: int
-    """
-    The number of insights updated
-    """
-
-
-class ModelInsightCount(BaseModel):
-    """
-    Insight counts by model
-    """
-
-    model_id: str
-    """
-    UUID of the model these insights belong to
-    """
-    count: float
-    """
-    number of insights that fit the request criteria
-    """
-
-
-class MetricType(str, Enum):
-    """
-    the metric this insight is calculate for. Only accuracy hotspots insights are supported for now.
-    """
-
-    AccuracyHotspot = 'accuracyhotspot'
-
-
-class Status(str, Enum):
-    """
-    Whether the alert has been resolved or not.
-    """
-
-    New = 'new'
-    Resolved = 'resolved'
-    Acknowledged = 'acknowledged'
-
-
-class Insight(BaseModel):
-    id: str
-    """
-    UUID of the insight
-    """
-    model_id: str
-    """
-    UUID of the model the insight is on
-    """
-    batch_id: Optional[str] = None
-    """
-    Id of the batch which the insights was generated for. Only valid for batch models.
-    """
-    run_id: str
-    """
-    UUID of the corresponding workflow run in dataset-service that triggered the generation of this insight.
-    """
-    metric_type: MetricType
-    """
-    the metric this insight is calculate for. Only accuracy hotspots insights are supported for now.
-    """
-    threshold_value: float
-    """
-    the threshold value the metric is checked against
-    """
-    region: Dict[str, Operator]
-    """
-    bounds on model inputs associated with this insight
-    """
-    metric_value: float
-    """
-    the value of this input region for the specified metric type
-    """
-    timestamp: datetime
-    """
-    UTC timestamp in ISO8601 format when the insight was created
-    """
-    window_start: Optional[datetime] = None
-    """
-    Only for streaming models. UTC timestamp in ISO8601, of the start time boundary of hotspot checking
-    """
-    window_end: Optional[datetime] = None
-    """
-    Only for streaming models. UTC timestamp in ISO8601, of the end time boundary of hotspot checking
-    """
-    status: Status
-    """
-    Whether the alert has been resolved or not.
-    """
-
-
-class InsightGroupCounts(BaseModel):
-    """
-    Insights are grouped by batch_id for batch models and by window_start for streaming models. Each group contains either a batch_id or window_start field that identifies the group.
-    """
-
-    batch_id: Optional[str] = None
-    """
-    Id of the batch which identify this group of generated insights. Only valid for batch models.
-    """
-    window_start: Optional[datetime] = None
-    """
-    Only for streaming models. UTC timestamp in ISO8601, of the start time boundary of hotspot checking which identify this group of generated insights.
-    """
-    timestamp: Optional[datetime] = None
-    """
-    UTC timestamp in ISO8601 format of the latest insight that belongs to this group.
-    """
-    count: Optional[float] = None
-    """
-    Total number of insights that belong to this group.
-    """
-
-
-class Status1(str, Enum):
-    """
-    Status to update alert with
-    """
-
-    New = 'new'
-    Resolved = 'resolved'
-    Acknowledge = 'acknowledged'
-
-
-class InsightPatch(BaseModel):
-    status: Status1
-    """
-    Status to update alert with
-    """
-
-
-class PaginatedInsights(BaseModel):
-    """
-    Paginated list of insights.
-    """
-
-    data: List[Insight]
-    page: Page
-    page_size: PageSize
-    total_pages: TotalPages
-    total_count: TotalCount
-
-
-class PaginatedInsightGroupCounts(BaseModel):
-    """
-    Paginated list of Insight Groups.
-    """
-
-    data: List[InsightGroupCounts]
-    page: Page
-    page_size: PageSize
-    total_pages: TotalPages
-    total_count: TotalCount

arthur/client/rest/metrics/__init__.py

@@ -1,2 +0,0 @@
-from . import models
-from . import client

arthur/client/rest/metrics/client.py

@@ -1,296 +0,0 @@
-from typing import Optional, Any, Union, Dict, List, Tuple
-from http import HTTPStatus
-from requests.cookies import RequestsCookieJar
-from requests import Response
-
-# import http client
-from arthur.client.http.requests import HTTPClient
-
-from arthur.client.rest.metrics.models import (
-    MetricEvaluationRequest,
-    MetricEvaluationResponse,
-    MetricRequest,
-    MetricResponse,
-    MetricTypeEnum,
-    PaginatedModelMetricsResponse,
-)
-
-
-PATH_PREFIX = "/api"
-
-
-class ArthurMetricsClient:
-    """
-    A Python client to interact with the Arthur Metrics API
-    """
-
-    def __init__(self, http_client: HTTPClient):
-        """
-        Create a new ArthurMetricsClient from an HTTPClient
-
-        :param http_client: the :class:`~arthurai.client.http.requests.HTTPClient` to use for underlying requests
-        """
-        self.http_client = http_client
-        self.http_client.set_path_prefix(PATH_PREFIX)
-
-    def get_paginated_metrics_deprecated(
-        self,
-        model_id: str,
-        page: Optional[int] = None,
-        page_size: Optional[int] = None,
-        expand: Optional[List[Any]] = None,
-        default: Optional[bool] = None,
-        type: Optional[List[MetricTypeEnum]] = None,
-        sort: Optional[str] = None,
-    ) -> PaginatedModelMetricsResponse:
-        """
-        Fetches the stored metrics associated with this model
-
-        This may include default Arthur metrics as well as custom metrics associated with the model.
-
-        :param model_id:
-        :param page:
-        :param page_size:
-        :param expand:
-        :param default:
-        :param type:
-        :param sort: Must be supplied in the format [column_name] to denote asc sort by this column OR -[column_name] to denote desc sort by this column
-        """
-
-        params: Dict[str, Any] = {}
-        if page is not None:
-            params["page"] = page
-        if page_size is not None:
-            params["page_size"] = page_size
-        if expand is not None:
-            params["expand"] = expand
-        if default is not None:
-            params["default"] = default
-        if type is not None:
-            params["type"] = type
-        if sort is not None:
-            params["sort"] = sort
-
-        parsed_resp: Dict[str, Any] = self.http_client.get(  # type: ignore
-            f"/v3/models/{model_id}/metrics",
-            params=params,
-            validation_response_code=200,
-        )
-        return PaginatedModelMetricsResponse(**parsed_resp)
-
-    def create_metric_for_model_deprecated(
-        self, model_id: str, json_body: MetricRequest
-    ) -> MetricResponse:
-        """
-        Creates a new custom metric for the model
-
-        :param model_id:
-        :param json_body: A Metric containing a template query and parameter definitions
-        """
-
-        parsed_resp: Dict[str, Any] = self.http_client.post(  # type: ignore
-            f"/v3/models/{model_id}/metrics",
-            json=json_body.dict(by_alias=True, exclude_none=True),
-            validation_response_code=201,
-        )
-        return MetricResponse(**parsed_resp)
-
-    def get_metric_for_model_by_id_deprecated(
-        self, model_id: str, metric_id: str
-    ) -> MetricResponse:
-        """
-        Fetches a metric by id
-
-        :param model_id:
-        :param metric_id:
-        """
-
-        parsed_resp: Dict[str, Any] = self.http_client.get(  # type: ignore
-            f"/v3/models/{model_id}/metrics/{metric_id}", validation_response_code=200
-        )
-        return MetricResponse(**parsed_resp)
-
-    def update_metric_for_model_deprecated(
-        self, model_id: str, metric_id: str, json_body: MetricRequest
-    ) -> MetricResponse:
-        """
-        Updates a metric
-
-        :param model_id:
-        :param metric_id:
-        :param json_body: A Metric containing a template query and parameter definitions
-        """
-
-        parsed_resp: Dict[str, Any] = self.http_client.put(  # type: ignore
-            f"/v3/models/{model_id}/metrics/{metric_id}",
-            json=json_body.dict(by_alias=True, exclude_none=True),
-            validation_response_code=200,
-        )
-        return MetricResponse(**parsed_resp)
-
-    def delete_metric_for_model_deprecated(
-        self, model_id: str, metric_id: str
-    ) -> Response:
-        """
-        Deletes a metric
-
-        Note that if any alerts are associated with this metric then they will automatically be disabled.
-
-        :param model_id:
-        :param metric_id:
-        """
-
-        raw_resp: Response = self.http_client.delete(  # type: ignore
-            f"/v3/models/{model_id}/metrics/{metric_id}",
-            validation_response_code=204,
-            return_raw_response=True,
-        )
-        return raw_resp
-
-    def evaluate_metric_for_model_deprecated(
-        self, model_id: str, metric_id: str, json_body: MetricEvaluationRequest
-    ) -> MetricEvaluationResponse:
-        """
-        Evaluate the metric on the provided parameters, filters, and groups
-
-        :param model_id:
-        :param metric_id:
-        :param json_body: The arguments to use when evaluating a metric
-        """
-
-        parsed_resp: Dict[str, Any] = self.http_client.post(  # type: ignore
-            f"/v3/models/{model_id}/metrics/{metric_id}/result",
-            json=json_body.dict(by_alias=True, exclude_none=True),
-            validation_response_code=200,
-        )
-        return MetricEvaluationResponse(**parsed_resp)
-
-    def get_paginated_metrics(
-        self,
-        model_id: str,
-        page: Optional[int] = None,
-        page_size: Optional[int] = None,
-        expand: Optional[List[Any]] = None,
-        default: Optional[bool] = None,
-        type: Optional[List[MetricTypeEnum]] = None,
-        sort: Optional[str] = None,
-    ) -> PaginatedModelMetricsResponse:
-        """
-        Fetches the stored metrics associated with this model
-
-        This may include default Arthur metrics as well as custom metrics associated with the model.
-
-        :param model_id:
-        :param page:
-        :param page_size:
-        :param expand:
-        :param default:
-        :param type:
-        :param sort: Must be supplied in the format [column_name] to denote asc sort by this column OR -[column_name] to denote desc sort by this column
-        """
-
-        params: Dict[str, Any] = {}
-        if page is not None:
-            params["page"] = page
-        if page_size is not None:
-            params["page_size"] = page_size
-        if expand is not None:
-            params["expand"] = expand
-        if default is not None:
-            params["default"] = default
-        if type is not None:
-            params["type"] = type
-        if sort is not None:
-            params["sort"] = sort
-
-        parsed_resp: Dict[str, Any] = self.http_client.get(  # type: ignore
-            f"/v4/models/{model_id}/metrics",
-            params=params,
-            validation_response_code=200,
-        )
-        return PaginatedModelMetricsResponse(**parsed_resp)
-
-    def create_metric_for_model(
-        self, model_id: str, json_body: MetricRequest
-    ) -> MetricResponse:
-        """
-        Creates a new custom metric for the model
-
-        :param model_id:
-        :param json_body: A Metric containing a template query and parameter definitions
-        """
-
-        parsed_resp: Dict[str, Any] = self.http_client.post(  # type: ignore
-            f"/v4/models/{model_id}/metrics",
-            json=json_body.dict(by_alias=True, exclude_none=True),
-            validation_response_code=201,
-        )
-        return MetricResponse(**parsed_resp)
-
-    def get_metric_for_model_by_id(
-        self, model_id: str, metric_id: str
-    ) -> MetricResponse:
-        """
-        Fetches a metric by id
-
-        :param model_id:
-        :param metric_id:
-        """
-
-        parsed_resp: Dict[str, Any] = self.http_client.get(  # type: ignore
-            f"/v4/models/{model_id}/metrics/{metric_id}", validation_response_code=200
-        )
-        return MetricResponse(**parsed_resp)
-
-    def update_metric_for_model(
-        self, model_id: str, metric_id: str, json_body: MetricRequest
-    ) -> MetricResponse:
-        """
-        Updates a metric
-
-        :param model_id:
-        :param metric_id:
-        :param json_body: A Metric containing a template query and parameter definitions
-        """
-
-        parsed_resp: Dict[str, Any] = self.http_client.put(  # type: ignore
-            f"/v4/models/{model_id}/metrics/{metric_id}",
-            json=json_body.dict(by_alias=True, exclude_none=True),
-            validation_response_code=200,
-        )
-        return MetricResponse(**parsed_resp)
-
-    def delete_metric_for_model(self, model_id: str, metric_id: str) -> Response:
-        """
-        Deletes a metric
-
-        Note that if any alerts are associated with this metric then they will automatically be disabled.
-
-        :param model_id:
-        :param metric_id:
-        """
-
-        raw_resp: Response = self.http_client.delete(  # type: ignore
-            f"/v4/models/{model_id}/metrics/{metric_id}",
-            validation_response_code=204,
-            return_raw_response=True,
-        )
-        return raw_resp
-
-    def evaluate_metric_for_model(
-        self, model_id: str, metric_id: str, json_body: MetricEvaluationRequest
-    ) -> MetricEvaluationResponse:
-        """
-        Evaluate the metric on the provided parameters, filters, and groups
-
-        :param model_id:
-        :param metric_id:
-        :param json_body: The arguments to use when evaluating a metric
-        """
-
-        parsed_resp: Dict[str, Any] = self.http_client.post(  # type: ignore
-            f"/v4/models/{model_id}/metrics/{metric_id}/result",
-            json=json_body.dict(by_alias=True, exclude_none=True),
-            validation_response_code=200,
-        )
-        return MetricEvaluationResponse(**parsed_resp)