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

spb_onprem/models/service.py

@@ -1,68 +1,289 @@
-from typing import Optional, Dict, Any, List, Tuple, Union
-
+from typing import Optional, Union, List, Any
 from spb_onprem.base_service import BaseService
-from spb_onprem.base_types import Undefined, UndefinedType
 from spb_onprem.exceptions import BadParameterError
+from spb_onprem.base_types import Undefined, UndefinedType
 from .queries import Queries
-from .entities import Model
+from .entities import Model, ModelPageInfo, ModelTrainClass
+from .params.models import ModelsFilter
 
 
 class ModelService(BaseService):
-    """Service class for handling model operations."""
+    """
+    Service class for handling model-related operations.
+    """
     
     def get_models(
         self,
         dataset_id: str,
-        filter: Union[UndefinedType, Dict[str, Any]] = Undefined,
-        cursor: Union[UndefinedType, str] = Undefined,
-        length: int = 50
-    ) -> Tuple[List[Model], Optional[str], int]:
-        """Get paginated list of models for a dataset.
+        models_filter: Optional[ModelsFilter] = None,
+        cursor: Optional[str] = None,
+        length: Optional[int] = 10
+    ):
+        """
+        Get a list of models based on the provided filter and pagination parameters.
         
         Args:
-            dataset_id (str): The dataset ID.
-            filter (Union[UndefinedType, Dict[str, Any]]): Filter for models.
-            cursor (Union[UndefinedType, str]): Cursor for pagination.
-            length (int): Number of items to retrieve per page.
+            dataset_id (str): The dataset ID
+            models_filter (Optional[ModelsFilter]): Filter criteria for models
+            cursor (Optional[str]): Cursor for pagination
+            length (Optional[int]): Number of items per page (default: 10)
         
         Returns:
-            Tuple[List[Model], Optional[str], int]: A tuple containing models, next cursor, and total count.
+            tuple: A tuple containing:
+                - List[Model]: A list of Model objects
+                - str: Next cursor for pagination
+                - int: Total count of models
         """
         if dataset_id is None:
             raise BadParameterError("dataset_id is required.")
-
+        
+        if length > 50:
+            raise BadParameterError("The maximum length is 50.")
+        
         response = self.request_gql(
-            Queries.GET_MODELS,
-            Queries.GET_MODELS["variables"](
+            Queries.MODELS,
+            Queries.MODELS["variables"](
                 dataset_id=dataset_id,
-                filter=filter,
+                models_filter=models_filter,
                 cursor=cursor,
                 length=length
             )
         )
-        models_list = response.get("models", [])
+        
+        page_info = ModelPageInfo.model_validate(response)
         return (
-            [Model.model_validate(model) for model in models_list],
-            response.get("next"),
-            response.get("totalCount", 0)
+            page_info.models or [],
+            page_info.next,
+            page_info.total_count or 0
+        )
+
+    def get_model(
+        self,
+        dataset_id: str,
+        model_id: str,
+    ):
+        """
+        Retrieve a model by its ID.
+
+        Args:
+            dataset_id (str): The dataset ID
+            model_id (str): The ID of the model to retrieve
+
+        Returns:
+            Model: The retrieved model object
+        """
+        if dataset_id is None:
+            raise BadParameterError("dataset_id is required.")
+        
+        if model_id is None:
+            raise BadParameterError("model_id is required.")
+        
+        response = self.request_gql(
+            Queries.MODEL,
+            Queries.MODEL["variables"](
+                dataset_id=dataset_id,
+                model_id=model_id
+            ),
+        )
+        return Model.model_validate(response)
+    
+    def create_model(
+        self,
+        dataset_id: str,
+        name: str,
+        baseline_model: str,
+        training_slice_ids: List[str],
+        validation_slice_ids: List[str],
+        description: Union[str, UndefinedType] = Undefined,
+        training_classes: Union[List[ModelTrainClass], UndefinedType] = Undefined,
+        model_content_id: Union[str, UndefinedType] = Undefined,
+        is_trained: Union[bool, UndefinedType] = Undefined,
+        trained_at: Union[str, UndefinedType] = Undefined,
+        is_pinned: Union[bool, UndefinedType] = Undefined,
+        meta: Union[Any, UndefinedType] = Undefined,
+    ):
+        """
+        Create a new model.
+
+        Args:
+            dataset_id (str): The dataset ID
+            name (str): The model name
+            baseline_model (str): The baseline model used
+            training_slice_ids (List[str]): The IDs of the training slices
+            validation_slice_ids (List[str]): The IDs of the validation slices
+            description (Optional[str]): The description of the model
+            training_classes (Optional[List[ModelTrainClass]]): The training classes
+            model_content_id (Optional[str]): The model content ID
+            is_trained (Optional[bool]): Whether the model is trained
+            trained_at (Optional[str]): When the model was trained
+            is_pinned (Optional[bool]): Whether the model is pinned
+            meta (Optional[Any]): The metadata of the model
+
+        Returns:
+            Model: The created model object
+        """
+        if dataset_id is None:
+            raise BadParameterError("dataset_id is required.")
+        
+        if name is None:
+            raise BadParameterError("name is required.")
+        
+        if baseline_model is None:
+            raise BadParameterError("baseline_model is required.")
+        
+        if training_slice_ids is None:
+            raise BadParameterError("training_slice_ids is required.")
+        
+        if validation_slice_ids is None:
+            raise BadParameterError("validation_slice_ids is required.")
+        
+        response = self.request_gql(
+            Queries.CREATE_MODEL,
+            Queries.CREATE_MODEL["variables"](
+                dataset_id=dataset_id,
+                name=name,
+                baseline_model=baseline_model,
+                training_slice_ids=training_slice_ids,
+                validation_slice_ids=validation_slice_ids,
+                description=description,
+                training_classes=training_classes,
+                model_content_id=model_content_id,
+                is_trained=is_trained,
+                trained_at=trained_at,
+                is_pinned=is_pinned,
+                meta=meta,
+            ),
+        )
+        return Model.model_validate(response)
+    
+    def update_model(
+        self,
+        dataset_id: str,
+        model_id: str,
+        name: Union[str, UndefinedType] = Undefined,
+        description: Union[str, UndefinedType] = Undefined,
+        training_classes: Union[List[ModelTrainClass], UndefinedType] = Undefined,
+        model_content_id: Union[str, UndefinedType] = Undefined,
+        is_trained: Union[bool, UndefinedType] = Undefined,
+        trained_at: Union[str, UndefinedType] = Undefined,
+        meta: Union[Any, UndefinedType] = Undefined,
+    ):
+        """
+        Update a model.
+
+        Args:
+            dataset_id (str): The dataset ID
+            model_id (str): The ID of the model to update
+            name (Optional[str]): The new name
+            description (Optional[str]): The new description
+            training_classes (Optional[List[ModelTrainClass]]): The new training classes
+            model_content_id (Optional[str]): The new model content ID
+            is_trained (Optional[bool]): The new trained status
+            trained_at (Optional[str]): The new trained timestamp
+            meta (Optional[Any]): The new metadata
+
+        Returns:
+            Model: The updated model object
+        """
+        if dataset_id is None:
+            raise BadParameterError("dataset_id is required.")
+        
+        if model_id is None:
+            raise BadParameterError("model_id is required.")
+        
+        response = self.request_gql(
+            Queries.UPDATE_MODEL,
+            Queries.UPDATE_MODEL["variables"](
+                dataset_id=dataset_id,
+                model_id=model_id,
+                name=name,
+                description=description,
+                training_classes=training_classes,
+                model_content_id=model_content_id,
+                is_trained=is_trained,
+                trained_at=trained_at,
+                meta=meta,
+            ),
         )
+        return Model.model_validate(response)
+    
+    def pin_model(
+        self,
+        dataset_id: str,
+        model_id: str,
+    ):
+        """
+        Pin a model.
+
+        Args:
+            dataset_id (str): The dataset ID
+            model_id (str): The ID of the model to pin
+
+        Returns:
+            Model: The pinned model object
+        """
+        if dataset_id is None:
+            raise BadParameterError("dataset_id is required.")
+        
+        if model_id is None:
+            raise BadParameterError("model_id is required.")
+        
+        response = self.request_gql(
+            Queries.PIN_MODEL,
+            Queries.PIN_MODEL["variables"](
+                dataset_id=dataset_id,
+                model_id=model_id,
+            ),
+        )
+        return Model.model_validate(response)
+    
+    def unpin_model(
+        self,
+        dataset_id: str,
+        model_id: str,
+    ):
+        """
+        Unpin a model.
+
+        Args:
+            dataset_id (str): The dataset ID
+            model_id (str): The ID of the model to unpin
+
+        Returns:
+            Model: The unpinned model object
+        """
+        if dataset_id is None:
+            raise BadParameterError("dataset_id is required.")
+        
+        if model_id is None:
+            raise BadParameterError("model_id is required.")
+        
+        response = self.request_gql(
+            Queries.UNPIN_MODEL,
+            Queries.UNPIN_MODEL["variables"](
+                dataset_id=dataset_id,
+                model_id=model_id,
+            ),
+        )
+        return Model.model_validate(response)
     
     def delete_model(
         self,
         dataset_id: str,
-        model_id: str
+        model_id: str,
     ) -> bool:
-        """Delete a model from the dataset.
+        """Delete a model.
         
         Args:
-            dataset_id (str): The dataset ID.
-            model_id (str): The model ID to delete.
+            dataset_id (str): The dataset ID
+            model_id (str): The ID of the model to delete
         
         Returns:
-            bool: True if deletion was successful.
+            bool: True if deletion was successful
         """
         if dataset_id is None:
             raise BadParameterError("dataset_id is required.")
+        
         if model_id is None:
             raise BadParameterError("model_id is required.")
 
@@ -70,7 +291,7 @@ class ModelService(BaseService):
             Queries.DELETE_MODEL,
             Queries.DELETE_MODEL["variables"](
                 dataset_id=dataset_id,
-                model_id=model_id
+                model_id=model_id,
             )
         )
-        return response
+        return response

spb_onprem/reports/__init__.py

@@ -0,0 +1,25 @@
+from .service import ReportService
+from .entities import (
+    AnalyticsReport,
+    AnalyticsReportItem,
+    AnalyticsReportItemType,
+    AnalyticsReportPageInfo,
+)
+from .params import (
+    AnalyticsReportsFilter,
+    AnalyticsReportsFilterOptions,
+    AnalyticsReportsOrderBy,
+    AnalyticsReportListOrderFields,
+)
+
+__all__ = (
+    "ReportService",
+    "AnalyticsReport",
+    "AnalyticsReportItem",
+    "AnalyticsReportItemType",
+    "AnalyticsReportPageInfo",
+    "AnalyticsReportsFilter",
+    "AnalyticsReportsFilterOptions",
+    "AnalyticsReportsOrderBy",
+    "AnalyticsReportListOrderFields",
+)

spb_onprem/reports/entities/__init__.py

@@ -0,0 +1,10 @@
+from .analytics_report import AnalyticsReport
+from .analytics_report_item import AnalyticsReportItem, AnalyticsReportItemType
+from .analytics_report_page_info import AnalyticsReportPageInfo
+
+__all__ = (
+    "AnalyticsReport",
+    "AnalyticsReportItem",
+    "AnalyticsReportItemType",
+    "AnalyticsReportPageInfo",
+)

spb_onprem/reports/entities/analytics_report.py

@@ -0,0 +1,22 @@
+from typing import Optional, List, Any
+from spb_onprem.base_model import CustomBaseModel, Field
+from .analytics_report_item import AnalyticsReportItem
+
+
+class AnalyticsReport(CustomBaseModel):
+    """
+    분석 리포트 엔터티
+    
+    데이터셋의 분석 리포트를 나타냅니다.
+    여러 개의 리포트 아이템(차트, 그래프 등)으로 구성됩니다.
+    """
+    id: Optional[str] = Field(None, description="리포트 고유 식별자")
+    dataset_id: Optional[str] = Field(None, alias="datasetId", description="이 리포트가 속한 데이터셋 ID")
+    title: Optional[str] = Field(None, description="리포트 제목")
+    description: Optional[str] = Field(None, description="리포트 설명")
+    meta: Optional[dict] = Field(None, description="추가 메타데이터 (JSONObject)")
+    created_at: Optional[str] = Field(None, alias="createdAt", description="생성일시 (ISO 8601)")
+    created_by: Optional[str] = Field(None, alias="createdBy", description="생성자")
+    updated_at: Optional[str] = Field(None, alias="updatedAt", description="수정일시 (ISO 8601)")
+    updated_by: Optional[str] = Field(None, alias="updatedBy", description="수정자")
+    items: Optional[List[AnalyticsReportItem]] = Field(None, description="리포트 아이템 목록")

spb_onprem/reports/entities/analytics_report_item.py

@@ -0,0 +1,30 @@
+from typing import Optional, Any
+from enum import Enum
+from spb_onprem.base_model import CustomBaseModel, Field
+from spb_onprem.contents.entities.base_content import BaseContent
+
+
+class AnalyticsReportItemType(str, Enum):
+    """분석 리포트 아이템 타입"""
+    PIE = "PIE"
+    HORIZONTAL_BAR = "HORIZONTAL_BAR"
+    VERTICAL_BAR = "VERTICAL_BAR"
+    HEATMAP = "HEATMAP"
+
+
+class AnalyticsReportItem(CustomBaseModel):
+    """
+    분석 리포트 아이템 엔터티
+    
+    리포트 내의 개별 차트나 시각화 아이템을 나타냅니다.
+    """
+    id: Optional[str] = Field(None, description="리포트 아이템 고유 식별자")
+    type: Optional[AnalyticsReportItemType] = Field(None, description="리포트 아이템 타입 (PIE, BAR, HEATMAP 등)")
+    title: Optional[str] = Field(None, description="리포트 아이템 제목")
+    description: Optional[str] = Field(None, description="리포트 아이템 설명")
+    content: Optional[BaseContent] = Field(None, description="리포트 아이템 컨텐츠")
+    meta: Optional[Any] = Field(None, description="추가 메타데이터 (JSONObject)")
+    created_at: Optional[str] = Field(None, alias="createdAt", description="생성일시 (ISO 8601)")
+    created_by: Optional[str] = Field(None, alias="createdBy", description="생성자")
+    updated_at: Optional[str] = Field(None, alias="updatedAt", description="수정일시 (ISO 8601)")
+    updated_by: Optional[str] = Field(None, alias="updatedBy", description="수정자")

spb_onprem/reports/entities/analytics_report_page_info.py

@@ -0,0 +1,14 @@
+from typing import Optional, List
+from spb_onprem.base_model import CustomBaseModel, Field
+from .analytics_report import AnalyticsReport
+
+
+class AnalyticsReportPageInfo(CustomBaseModel):
+    """
+    분석 리포트 페이지 정보 엔터티
+    
+    분석 리포트 목록 조회 시 페이지네이션 정보를 포함합니다.
+    """
+    analytics_reports: Optional[List[AnalyticsReport]] = Field(None, alias="analyticsReports", description="쿼리와 일치하는 리포트 목록")
+    next: Optional[str] = Field(None, description="페이지네이션에 사용할 커서")
+    total_count: Optional[int] = Field(None, alias="totalCount", description="쿼리와 일치하는 리포트의 총 개수")

spb_onprem/reports/params/__init__.py

@@ -0,0 +1,29 @@
+from .analytics_report import analytics_report_params
+from .analytics_reports import (
+    analytics_reports_params,
+    AnalyticsReportsFilter,
+    AnalyticsReportsFilterOptions,
+    AnalyticsReportsOrderBy,
+    AnalyticsReportListOrderFields,
+)
+from .create_analytics_report import create_analytics_report_params
+from .update_analytics_report import update_analytics_report_params
+from .delete_analytics_report import delete_analytics_report_params
+from .create_analytics_report_item import create_analytics_report_item_params
+from .update_analytics_report_item import update_analytics_report_item_params
+from .delete_analytics_report_item import delete_analytics_report_item_params
+
+__all__ = (
+    "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",
+    "AnalyticsReportsFilter",
+    "AnalyticsReportsFilterOptions",
+    "AnalyticsReportsOrderBy",
+    "AnalyticsReportListOrderFields",
+)

spb_onprem/reports/params/analytics_report.py

@@ -0,0 +1,17 @@
+def analytics_report_params(
+    report_id: str,
+    dataset_id: str,
+):
+    """Get parameters for retrieving a single analytics report.
+    
+    Args:
+        report_id: The report ID
+        dataset_id: The dataset ID
+        
+    Returns:
+        dict: Parameters for retrieving an analytics report
+    """
+    return {
+        "reportId": report_id,
+        "datasetId": dataset_id,
+    }

spb_onprem/reports/params/analytics_reports.py

@@ -0,0 +1,87 @@
+from typing import Optional, Union
+from enum import Enum
+
+from spb_onprem.base_model import CustomBaseModel, Field
+from spb_onprem.base_types import Undefined, UndefinedType
+
+
+class AnalyticsReportListOrderFields(str, Enum):
+    """분석 리포트 정렬 필드"""
+    UPDATED_AT = "updatedAt"
+    CREATED_AT = "createdAt"
+    TITLE = "title"
+
+
+class AnalyticsReportsFilterOptions(CustomBaseModel):
+    """Options for filtering analytics reports.
+    
+    Attributes:
+        title_contains: Filter reports by title containing this string
+    """
+    title_contains: Optional[str] = Field(None, alias="titleContains")
+
+
+class AnalyticsReportsFilter(CustomBaseModel):
+    """Filter criteria for analytics report queries.
+    
+    Attributes:
+        must_filter: Conditions that must be met
+        not_filter: Conditions that must not be met
+    """
+    must_filter: Optional[AnalyticsReportsFilterOptions] = Field(None, alias="must")
+    not_filter: Optional[AnalyticsReportsFilterOptions] = Field(None, alias="not")
+
+
+class AnalyticsReportsOrderBy(CustomBaseModel):
+    """Order by options for analytics reports.
+    
+    Attributes:
+        field: The field to order by
+        direction: The direction to order (ASC or DESC)
+    """
+    field: Optional[AnalyticsReportListOrderFields] = Field(None, description="정렬 필드")
+    direction: Optional[str] = Field(None, description="정렬 방향 (ASC or DESC)")
+
+
+def analytics_reports_params(
+    dataset_id: str,
+    analytics_reports_filter: Union[
+        AnalyticsReportsFilter,
+        UndefinedType
+    ] = Undefined,
+    cursor: Optional[str] = None,
+    length: Optional[int] = 10,
+    order_by: Union[
+        AnalyticsReportsOrderBy,
+        UndefinedType
+    ] = Undefined,
+):
+    """Get parameters for listing analytics reports.
+    
+    Args:
+        dataset_id: Required dataset ID
+        analytics_reports_filter: Optional filter criteria for reports
+        cursor: Optional cursor for pagination
+        length: Optional number of items per page (default: 10)
+        order_by: Optional order by options
+        
+    Returns:
+        dict: Parameters for listing analytics reports
+    """
+    params = {
+        "datasetId": dataset_id,
+        "cursor": cursor,
+        "length": length,
+    }
+    
+    if analytics_reports_filter and not isinstance(analytics_reports_filter, UndefinedType):
+        params["filter"] = analytics_reports_filter.model_dump(
+            by_alias=True, exclude_unset=True
+        )
+    
+    if order_by and not isinstance(order_by, UndefinedType):
+        params["orderBy"] = order_by.model_dump(
+            by_alias=True, exclude_unset=True
+        )
+    
+    return params

spb_onprem/reports/params/create_analytics_report.py

@@ -0,0 +1,35 @@
+from typing import Union, Any
+from spb_onprem.base_types import Undefined, UndefinedType
+
+
+def create_analytics_report_params(
+    dataset_id: str,
+    title: Union[str, UndefinedType] = Undefined,
+    description: Union[str, UndefinedType] = Undefined,
+    meta: Union[Any, UndefinedType] = Undefined,
+):
+    """Get parameters for creating an analytics report.
+    
+    Args:
+        dataset_id: The dataset ID
+        title: Optional report title
+        description: Optional report description
+        meta: Optional metadata
+        
+    Returns:
+        dict: Parameters for creating an analytics report
+    """
+    params = {
+        "datasetId": dataset_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/create_analytics_report_item.py

@@ -0,0 +1,47 @@
+from typing import Union, Any
+from spb_onprem.base_types import Undefined, UndefinedType
+from spb_onprem.reports.entities.analytics_report_item import AnalyticsReportItemType
+
+
+def create_analytics_report_item_params(
+    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,
+):
+    """Get parameters for creating an analytics report item.
+    
+    Args:
+        dataset_id: The dataset ID
+        report_id: The report ID
+        type: The type of report item (PIE, HORIZONTAL_BAR, etc.)
+        title: Optional item title
+        description: Optional item description
+        content_id: Optional content ID
+        meta: Optional metadata
+        
+    Returns:
+        dict: Parameters for creating an analytics report item
+    """
+    params = {
+        "datasetId": dataset_id,
+        "reportId": report_id,
+        "type": type.value if isinstance(type, AnalyticsReportItemType) else type,
+    }
+    
+    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/params/delete_analytics_report.py

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