superb-ai-onprem 0.9.0__py3-none-any.whl → 0.10.0__py3-none-any.whl

spb_onprem/reports/params/delete_analytics_report_item.py

@@ -0,0 +1,20 @@
+def delete_analytics_report_item_params(
+    item_id: str,
+    report_id: str,
+    dataset_id: str,
+):
+    """Get parameters for deleting an analytics report item.
+    
+    Args:
+        item_id: The item ID
+        report_id: The report ID
+        dataset_id: The dataset ID
+        
+    Returns:
+        dict: Parameters for deleting an analytics report item
+    """
+    return {
+        "itemId": item_id,
+        "reportId": report_id,
+        "datasetId": dataset_id,
+    }

spb_onprem/reports/params/update_analytics_report.py

@@ -0,0 +1,38 @@
+from typing import Union, Any
+from spb_onprem.base_types import Undefined, UndefinedType
+
+
+def update_analytics_report_params(
+    dataset_id: str,
+    report_id: str,
+    title: Union[str, UndefinedType] = Undefined,
+    description: Union[str, UndefinedType] = Undefined,
+    meta: Union[Any, UndefinedType] = Undefined,
+):
+    """Get parameters for updating an analytics report.
+    
+    Args:
+        dataset_id: The dataset ID
+        report_id: The report ID
+        title: Optional new title
+        description: Optional new description
+        meta: Optional new metadata
+        
+    Returns:
+        dict: Parameters for updating an analytics report
+    """
+    params = {
+        "datasetId": dataset_id,
+        "reportId": report_id,
+    }
+    
+    if not isinstance(title, UndefinedType):
+        params["title"] = title
+    
+    if not isinstance(description, UndefinedType):
+        params["description"] = description
+    
+    if not isinstance(meta, UndefinedType):
+        params["meta"] = meta
+    
+    return params

spb_onprem/reports/params/update_analytics_report_item.py

@@ -0,0 +1,46 @@
+from typing import Union, Any
+from spb_onprem.base_types import Undefined, UndefinedType
+
+
+def update_analytics_report_item_params(
+    dataset_id: str,
+    report_id: str,
+    item_id: str,
+    title: Union[str, UndefinedType] = Undefined,
+    description: Union[str, UndefinedType] = Undefined,
+    content_id: Union[str, UndefinedType] = Undefined,
+    meta: Union[Any, UndefinedType] = Undefined,
+):
+    """Get parameters for updating an analytics report item.
+    
+    Args:
+        dataset_id: The dataset ID
+        report_id: The report ID
+        item_id: The item ID
+        title: Optional new title
+        description: Optional new description
+        content_id: Optional new content ID
+        meta: Optional new metadata
+        
+    Returns:
+        dict: Parameters for updating an analytics report item
+    """
+    params = {
+        "datasetId": dataset_id,
+        "reportId": report_id,
+        "itemId": item_id,
+    }
+    
+    if not isinstance(title, UndefinedType):
+        params["title"] = title
+    
+    if not isinstance(description, UndefinedType):
+        params["description"] = description
+    
+    if not isinstance(content_id, UndefinedType):
+        params["contentId"] = content_id
+    
+    if not isinstance(meta, UndefinedType):
+        params["meta"] = meta
+    
+    return params

spb_onprem/reports/queries.py

@@ -0,0 +1,239 @@
+from spb_onprem.reports.params import (
+    analytics_report_params,
+    analytics_reports_params,
+    create_analytics_report_params,
+    update_analytics_report_params,
+    delete_analytics_report_params,
+    create_analytics_report_item_params,
+    update_analytics_report_item_params,
+    delete_analytics_report_item_params,
+)
+
+
+class Schemas:
+    ANALYTICS_REPORT_ITEM = '''
+        id
+        type
+        title
+        description
+        content {
+            id
+            downloadURL
+        }
+        meta
+        createdAt
+        createdBy
+        updatedAt
+        updatedBy
+    '''
+    
+    ANALYTICS_REPORT = '''
+        datasetId
+        id
+        title
+        description
+        meta
+        createdAt
+        updatedAt
+        createdBy
+        updatedBy
+        items {
+            id
+            type
+            title
+            description
+            content {
+                id
+                downloadURL
+            }
+            meta
+            createdAt
+            createdBy
+            updatedAt
+            updatedBy
+        }
+    '''
+
+
+class Queries():
+    ANALYTICS_REPORT = {
+        "name": "analyticsReport",
+        "query": f'''
+            query AnalyticsReport(
+                $reportId: ID!,
+                $datasetId: String!
+            ) {{
+                analyticsReport(
+                    reportId: $reportId,
+                    datasetId: $datasetId
+                ) {{
+                    {Schemas.ANALYTICS_REPORT}
+                }}
+            }}
+        ''',
+        "variables": analytics_report_params,
+    }
+    
+    ANALYTICS_REPORTS = {
+        "name": "analyticsReports",
+        "query": f'''
+            query AnalyticsReports(
+                $datasetId: ID!,
+                $filter: AnalyticsReportFilter,
+                $cursor: String,
+                $length: Int,
+                $orderBy: AnalyticsReportOrderBy
+            ) {{
+                analyticsReports(
+                    datasetId: $datasetId,
+                    filter: $filter,
+                    cursor: $cursor,
+                    length: $length,
+                    orderBy: $orderBy
+                ) {{
+                    analyticsReports {{
+                        {Schemas.ANALYTICS_REPORT}
+                    }}
+                    next
+                    totalCount
+                }}
+            }}
+        ''',
+        "variables": analytics_reports_params,
+    }
+    
+    CREATE_ANALYTICS_REPORT = {
+        "name": "createAnalyticsReport",
+        "query": f'''
+            mutation CreateAnalyticsReport(
+                $datasetId: ID!,
+                $title: String,
+                $description: String,
+                $meta: JSONObject
+            ) {{
+                createAnalyticsReport(
+                    datasetId: $datasetId,
+                    title: $title,
+                    description: $description,
+                    meta: $meta
+                ) {{
+                    {Schemas.ANALYTICS_REPORT}
+                }}
+            }}
+        ''',
+        "variables": create_analytics_report_params,
+    }
+    
+    UPDATE_ANALYTICS_REPORT = {
+        "name": "updateAnalyticsReport",
+        "query": f'''
+            mutation UpdateAnalyticsReport(
+                $datasetId: ID!,
+                $reportId: ID!,
+                $title: String,
+                $description: String,
+                $meta: JSONObject
+            ) {{
+                updateAnalyticsReport(
+                    datasetId: $datasetId,
+                    reportId: $reportId,
+                    title: $title,
+                    description: $description,
+                    meta: $meta
+                ) {{
+                    {Schemas.ANALYTICS_REPORT}
+                }}
+            }}
+        ''',
+        "variables": update_analytics_report_params,
+    }
+    
+    DELETE_ANALYTICS_REPORT = {
+        "name": "deleteAnalyticsReport",
+        "query": '''
+            mutation DeleteAnalyticsReport(
+                $reportId: String!,
+                $datasetId: String!
+            ) {
+                deleteAnalyticsReport(
+                    reportId: $reportId,
+                    datasetId: $datasetId
+                )
+            }
+        ''',
+        "variables": delete_analytics_report_params,
+    }
+    
+    CREATE_ANALYTICS_REPORT_ITEM = {
+        "name": "createAnalyticsReportItem",
+        "query": f'''
+            mutation CreateAnalyticsReportItem(
+                $datasetId: ID!,
+                $reportId: ID!,
+                $type: AnalyticsReportItemType!,
+                $title: String,
+                $description: String,
+                $contentId: String,
+                $meta: JSONObject
+            ) {{
+                createAnalyticsReportItem(
+                    datasetId: $datasetId,
+                    reportId: $reportId,
+                    type: $type,
+                    title: $title,
+                    description: $description,
+                    contentId: $contentId,
+                    meta: $meta
+                ) {{
+                    {Schemas.ANALYTICS_REPORT_ITEM}
+                }}
+            }}
+        ''',
+        "variables": create_analytics_report_item_params,
+    }
+    
+    UPDATE_ANALYTICS_REPORT_ITEM = {
+        "name": "updateAnalyticsReportItem",
+        "query": f'''
+            mutation UpdateAnalyticsReportItem(
+                $datasetId: ID!,
+                $reportId: ID!,
+                $itemId: ID!,
+                $title: String,
+                $description: String,
+                $contentId: String,
+                $meta: JSONObject
+            ) {{
+                updateAnalyticsReportItem(
+                    datasetId: $datasetId,
+                    reportId: $reportId,
+                    itemId: $itemId,
+                    title: $title,
+                    description: $description,
+                    contentId: $contentId,
+                    meta: $meta
+                ) {{
+                    {Schemas.ANALYTICS_REPORT_ITEM}
+                }}
+            }}
+        ''',
+        "variables": update_analytics_report_item_params,
+    }
+    
+    DELETE_ANALYTICS_REPORT_ITEM = {
+        "name": "deleteAnalyticsReportItem",
+        "query": '''
+            mutation DeleteAnalyticsReportItem(
+                $itemId: String!,
+                $reportId: String!,
+                $datasetId: String!
+            ) {
+                deleteAnalyticsReportItem(
+                    itemId: $itemId,
+                    reportId: $reportId,
+                    datasetId: $datasetId
+                )
+            }
+        ''',
+        "variables": delete_analytics_report_item_params,
+    }

spb_onprem/reports/service.py

@@ -0,0 +1,328 @@
+from typing import Optional, Union, Any
+from spb_onprem.base_service import BaseService
+from spb_onprem.exceptions import BadParameterError
+from spb_onprem.base_types import Undefined, UndefinedType
+from .queries import Queries
+from .entities import (
+    AnalyticsReport,
+    AnalyticsReportItem,
+    AnalyticsReportItemType,
+    AnalyticsReportPageInfo,
+)
+from .params.analytics_reports import AnalyticsReportsFilter, AnalyticsReportsOrderBy
+
+
+class ReportService(BaseService):
+    """
+    Service class for handling analytics report-related operations.
+    """
+    
+    def get_analytics_reports(
+        self,
+        dataset_id: str,
+        analytics_reports_filter: Optional[AnalyticsReportsFilter] = None,
+        cursor: Optional[str] = None,
+        length: Optional[int] = 10,
+        order_by: Union[AnalyticsReportsOrderBy, UndefinedType] = Undefined,
+    ):
+        """
+        Get a list of analytics reports based on the provided filter and pagination parameters.
+        
+        Args:
+            dataset_id (str): The dataset ID
+            analytics_reports_filter (Optional[AnalyticsReportsFilter]): Filter criteria for reports
+            cursor (Optional[str]): Cursor for pagination
+            length (Optional[int]): Number of items per page (default: 10)
+            order_by (Optional[AnalyticsReportsOrderBy]): Order by options
+        
+        Returns:
+            tuple: A tuple containing:
+                - List[AnalyticsReport]: A list of AnalyticsReport objects
+                - str: Next cursor for pagination
+                - int: Total count of reports
+        """
+        if dataset_id is None:
+            raise BadParameterError("dataset_id is required.")
+        
+        if length and length > 50:
+            raise BadParameterError("The maximum length is 50.")
+        
+        response = self.request_gql(
+            Queries.ANALYTICS_REPORTS,
+            Queries.ANALYTICS_REPORTS["variables"](
+                dataset_id=dataset_id,
+                analytics_reports_filter=analytics_reports_filter,
+                cursor=cursor,
+                length=length,
+                order_by=order_by,
+            )
+        )
+        
+        page_info = AnalyticsReportPageInfo.model_validate(response)
+        return (
+            page_info.analytics_reports or [],
+            page_info.next,
+            page_info.total_count or 0
+        )
+
+    def get_analytics_report(
+        self,
+        dataset_id: str,
+        report_id: str,
+    ):
+        """
+        Retrieve an analytics report by its ID.
+
+        Args:
+            dataset_id (str): The dataset ID
+            report_id (str): The ID of the report to retrieve
+
+        Returns:
+            AnalyticsReport: The retrieved analytics report object
+        """
+        if dataset_id is None:
+            raise BadParameterError("dataset_id is required.")
+        
+        if report_id is None:
+            raise BadParameterError("report_id is required.")
+        
+        response = self.request_gql(
+            Queries.ANALYTICS_REPORT,
+            Queries.ANALYTICS_REPORT["variables"](
+                dataset_id=dataset_id,
+                report_id=report_id
+            ),
+        )
+        return AnalyticsReport.model_validate(response)
+    
+    def create_analytics_report(
+        self,
+        dataset_id: str,
+        title: Union[str, UndefinedType] = Undefined,
+        description: Union[str, UndefinedType] = Undefined,
+        meta: Union[Any, UndefinedType] = Undefined,
+    ):
+        """
+        Create a new analytics report.
+
+        Args:
+            dataset_id (str): The dataset ID
+            title (Optional[str]): The title of the report
+            description (Optional[str]): The description of the report
+            meta (Optional[Any]): The metadata of the report
+
+        Returns:
+            AnalyticsReport: The created analytics report object
+        """
+        if dataset_id is None:
+            raise BadParameterError("dataset_id is required.")
+        
+        response = self.request_gql(
+            Queries.CREATE_ANALYTICS_REPORT,
+            Queries.CREATE_ANALYTICS_REPORT["variables"](
+                dataset_id=dataset_id,
+                title=title,
+                description=description,
+                meta=meta,
+            ),
+        )
+        return AnalyticsReport.model_validate(response)
+    
+    def update_analytics_report(
+        self,
+        dataset_id: str,
+        report_id: str,
+        title: Union[str, UndefinedType] = Undefined,
+        description: Union[str, UndefinedType] = Undefined,
+        meta: Union[Any, UndefinedType] = Undefined,
+    ):
+        """
+        Update an analytics report.
+
+        Args:
+            dataset_id (str): The dataset ID
+            report_id (str): The ID of the report to update
+            title (Optional[str]): The new title of the report
+            description (Optional[str]): The new description of the report
+            meta (Optional[Any]): The new metadata of the report
+
+        Returns:
+            AnalyticsReport: The updated analytics report object
+        """
+        if dataset_id is None:
+            raise BadParameterError("dataset_id is required.")
+        
+        if report_id is None:
+            raise BadParameterError("report_id is required.")
+        
+        response = self.request_gql(
+            Queries.UPDATE_ANALYTICS_REPORT,
+            Queries.UPDATE_ANALYTICS_REPORT["variables"](
+                dataset_id=dataset_id,
+                report_id=report_id,
+                title=title,
+                description=description,
+                meta=meta,
+            ),
+        )
+        return AnalyticsReport.model_validate(response)
+    
+    def delete_analytics_report(
+        self,
+        dataset_id: str,
+        report_id: str,
+    ) -> bool:
+        """Delete an analytics report.
+        
+        Args:
+            dataset_id (str): The dataset ID
+            report_id (str): The ID of the report to delete
+        
+        Returns:
+            bool: True if deletion was successful
+        """
+        if dataset_id is None:
+            raise BadParameterError("dataset_id is required.")
+        
+        if report_id is None:
+            raise BadParameterError("report_id is required.")
+
+        response = self.request_gql(
+            Queries.DELETE_ANALYTICS_REPORT,
+            Queries.DELETE_ANALYTICS_REPORT["variables"](
+                dataset_id=dataset_id,
+                report_id=report_id
+            )
+        )
+        return response
+    
+    def create_analytics_report_item(
+        self,
+        dataset_id: str,
+        report_id: str,
+        type: AnalyticsReportItemType,
+        title: Union[str, UndefinedType] = Undefined,
+        description: Union[str, UndefinedType] = Undefined,
+        content_id: Union[str, UndefinedType] = Undefined,
+        meta: Union[Any, UndefinedType] = Undefined,
+    ):
+        """
+        Create a new analytics report item.
+
+        Args:
+            dataset_id (str): The dataset ID
+            report_id (str): The report ID
+            type (AnalyticsReportItemType): The type of report item
+            title (Optional[str]): The title of the item
+            description (Optional[str]): The description of the item
+            content_id (Optional[str]): The content ID of the item
+            meta (Optional[Any]): The metadata of the item
+
+        Returns:
+            AnalyticsReportItem: The created analytics report item object
+        """
+        if dataset_id is None:
+            raise BadParameterError("dataset_id is required.")
+        
+        if report_id is None:
+            raise BadParameterError("report_id is required.")
+        
+        if type is None:
+            raise BadParameterError("type is required.")
+        
+        response = self.request_gql(
+            Queries.CREATE_ANALYTICS_REPORT_ITEM,
+            Queries.CREATE_ANALYTICS_REPORT_ITEM["variables"](
+                dataset_id=dataset_id,
+                report_id=report_id,
+                type=type,
+                title=title,
+                description=description,
+                content_id=content_id,
+                meta=meta,
+            ),
+        )
+        return AnalyticsReportItem.model_validate(response)
+    
+    def update_analytics_report_item(
+        self,
+        dataset_id: str,
+        report_id: str,
+        item_id: str,
+        title: Union[str, UndefinedType] = Undefined,
+        description: Union[str, UndefinedType] = Undefined,
+        content_id: Union[str, UndefinedType] = Undefined,
+        meta: Union[Any, UndefinedType] = Undefined,
+    ):
+        """
+        Update an analytics report item.
+
+        Args:
+            dataset_id (str): The dataset ID
+            report_id (str): The report ID
+            item_id (str): The ID of the item to update
+            title (Optional[str]): The new title of the item
+            description (Optional[str]): The new description of the item
+            content_id (Optional[str]): The new content ID of the item
+            meta (Optional[Any]): The new metadata of the item
+
+        Returns:
+            AnalyticsReportItem: The updated analytics report item object
+        """
+        if dataset_id is None:
+            raise BadParameterError("dataset_id is required.")
+        
+        if report_id is None:
+            raise BadParameterError("report_id is required.")
+        
+        if item_id is None:
+            raise BadParameterError("item_id is required.")
+        
+        response = self.request_gql(
+            Queries.UPDATE_ANALYTICS_REPORT_ITEM,
+            Queries.UPDATE_ANALYTICS_REPORT_ITEM["variables"](
+                dataset_id=dataset_id,
+                report_id=report_id,
+                item_id=item_id,
+                title=title,
+                description=description,
+                content_id=content_id,
+                meta=meta,
+            ),
+        )
+        return AnalyticsReportItem.model_validate(response)
+    
+    def delete_analytics_report_item(
+        self,
+        dataset_id: str,
+        report_id: str,
+        item_id: str,
+    ) -> bool:
+        """Delete an analytics report item.
+        
+        Args:
+            dataset_id (str): The dataset ID
+            report_id (str): The report ID
+            item_id (str): The ID of the item to delete
+        
+        Returns:
+            bool: True if deletion was successful
+        """
+        if dataset_id is None:
+            raise BadParameterError("dataset_id is required.")
+        
+        if report_id is None:
+            raise BadParameterError("report_id is required.")
+        
+        if item_id is None:
+            raise BadParameterError("item_id is required.")
+
+        response = self.request_gql(
+            Queries.DELETE_ANALYTICS_REPORT_ITEM,
+            Queries.DELETE_ANALYTICS_REPORT_ITEM["variables"](
+                dataset_id=dataset_id,
+                report_id=report_id,
+                item_id=item_id,
+            )
+        )
+        return response

spb_onprem/searches.py

@@ -23,6 +23,7 @@ from .data.params.data_list import (
     FrameFilter,
     DataFilter,
     DataListFilter,
+    AnnotationCountsFilter
 )
 from .datasets.params.datasets import (
     DatasetsFilter,
@@ -40,6 +41,16 @@ from .exports.params.exports import (
     ExportFilter,
     ExportFilterOptions,
 )
+from .models.params.models import (
+    ModelsFilter,
+    ModelsFilterOptions,
+)
+from .reports.params.analytics_reports import (
+    AnalyticsReportsFilter,
+    AnalyticsReportsFilterOptions,
+    AnalyticsReportsOrderBy,
+    AnalyticsReportListOrderFields,
+)
 
 __all__ = [
     "DateTimeRangeFilterOption",
@@ -73,4 +84,11 @@ __all__ = [
     "ActivitiesFilterOptions",
     "ExportFilter",
     "ExportFilterOptions",
+    "AnnotationCountsFilter",
+    "ModelsFilter",
+    "ModelsFilterOptions",
+    "AnalyticsReportsFilter",
+    "AnalyticsReportsFilterOptions",
+    "AnalyticsReportsOrderBy",
+    "AnalyticsReportListOrderFields",
 ]