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

spb_onprem/predictions/__init__.py

@@ -1,7 +0,0 @@
-from .service import PredictionService
-from .entities import PredictionSet
-
-__all__ = [
-    "PredictionService",
-    "PredictionSet",
-]

spb_onprem/predictions/entities.py

@@ -1,11 +0,0 @@
-from typing import List, Optional
-from spb_onprem.base_model import CustomBaseModel, Field
-
-
-class PredictionSet(CustomBaseModel):
-    """PredictionSet entity representing a set of predictions in the dataset."""
-    
-    id: str
-    name: Optional[str] = None
-    annotations_contents: Optional[List[str]] = Field(None, alias="annotationsContents")
-    evaluation_result_content: Optional[dict] = Field(None, alias="evaluationResultContent")

spb_onprem/predictions/params/__init__.py

@@ -1,15 +0,0 @@
-from .get_prediction_sets import get_prediction_sets_params
-from .get_prediction_set import get_prediction_set_params
-from .delete_prediction_set import delete_prediction_set_params
-from .delete_prediction_from_data import delete_prediction_from_data_params
-from .create_prediction_set import create_prediction_set_params
-from .update_prediction_set_data_info import update_prediction_set_data_info_params
-
-__all__ = [
-    "get_prediction_sets_params",
-    "get_prediction_set_params", 
-    "delete_prediction_set_params",
-    "delete_prediction_from_data_params",
-    "create_prediction_set_params",
-    "update_prediction_set_data_info_params",
-]

spb_onprem/predictions/params/create_prediction_set.py

@@ -1,44 +0,0 @@
-from typing import Optional, Dict, Any
-
-
-def create_prediction_set_params(
-    dataset_id: str,
-    model_id: str,
-    name: str,
-    type: str,
-    description: Optional[str] = None,
-    annotations_count: Optional[int] = None,
-    data_count: Optional[int] = None,
-) -> Dict[str, Any]:
-    """Convert parameters for create_prediction_set GraphQL mutation.
-    
-    Args:
-        dataset_id (str): The dataset ID
-        model_id (str): The model ID
-        name (str): Name of the prediction set
-        type (str): Type of the prediction set
-        description (Optional[str]): Description of the prediction set
-        annotations_count (Optional[int]): Number of annotations
-        data_count (Optional[int]): Number of data items
-        
-    Returns:
-        Dict[str, Any]: Parameters formatted for GraphQL mutation
-    """
-    params = {
-        "datasetId": dataset_id,
-        "modelId": model_id,
-        "name": name,
-        "type": type,
-    }
-    
-    if description is not None:
-        params["description"] = description
-        
-    if annotations_count is not None or data_count is not None:
-        params["dataInfo"] = {}
-        if annotations_count is not None:
-            params["dataInfo"]["annotationsCount"] = annotations_count
-        if data_count is not None:
-            params["dataInfo"]["dataCount"] = data_count
-    
-    return params

spb_onprem/predictions/params/delete_prediction_from_data.py

@@ -1,20 +0,0 @@
-def delete_prediction_from_data_params(
-    dataset_id: str, 
-    data_id: str, 
-    prediction_set_id: str
-):
-    """Generate variables for delete prediction from data GraphQL mutation.
-    
-    Args:
-        dataset_id (str): The ID of the dataset.
-        data_id (str): The ID of the data.
-        prediction_set_id (str): The ID of the prediction set.
-        
-    Returns:
-        dict: Variables dictionary for the GraphQL mutation.
-    """
-    return {
-        "dataset_id": dataset_id,
-        "data_id": data_id,
-        "set_id": prediction_set_id
-    }

spb_onprem/predictions/params/delete_prediction_set.py

@@ -1,14 +0,0 @@
-def delete_prediction_set_params(dataset_id: str, prediction_set_id: str):
-    """Generate variables for delete prediction set GraphQL mutation.
-    
-    Args:
-        dataset_id (str): The ID of the dataset.
-        prediction_set_id (str): The ID of the prediction set to delete.
-        
-    Returns:
-        dict: Variables dictionary for the GraphQL mutation.
-    """
-    return {
-        "dataset_id": dataset_id,
-        "id": prediction_set_id
-    }

spb_onprem/predictions/params/get_prediction_set.py

@@ -1,14 +0,0 @@
-def get_prediction_set_params(dataset_id: str, prediction_set_id: str):
-    """Generate variables for get prediction set GraphQL query.
-    
-    Args:
-        dataset_id (str): The ID of the dataset.
-        prediction_set_id (str): The ID of the prediction set.
-        
-    Returns:
-        dict: Variables dictionary for the GraphQL query.
-    """
-    return {
-        "dataset_id": dataset_id,
-        "id": prediction_set_id
-    }

spb_onprem/predictions/params/get_prediction_sets.py

@@ -1,29 +0,0 @@
-def get_prediction_sets_params(
-    dataset_id: str,
-    filter: dict = None,
-    cursor: str = None,
-    length: int = 50
-):
-    """Generate variables for get prediction sets GraphQL query.
-    
-    Args:
-        dataset_id (str): The ID of the dataset.
-        filter (dict, optional): Filter for prediction sets.
-        cursor (str, optional): Cursor for pagination.
-        length (int): Number of items to retrieve per page.
-        
-    Returns:
-        dict: Variables dictionary for the GraphQL query.
-    """
-    params = {
-        "dataset_id": dataset_id,
-        "length": length
-    }
-    
-    if filter is not None:
-        params["filter"] = filter
-        
-    if cursor is not None:
-        params["cursor"] = cursor
-        
-    return params

spb_onprem/predictions/params/update_prediction_set_data_info.py

@@ -1,28 +0,0 @@
-from typing import Dict, Any
-
-
-def update_prediction_set_data_info_params(
-    dataset_id: str,
-    id: str,
-    annotation_count: int,
-    data_count: int
-) -> Dict[str, Any]:
-    """Convert parameters for update_prediction_set_data_info GraphQL mutation.
-    
-    Args:
-        dataset_id (str): The dataset ID
-        id (str): The prediction set ID to update
-        annotation_count (int): Number of annotations
-        data_count (int): Number of data items
-        
-    Returns:
-        Dict[str, Any]: Parameters formatted for GraphQL mutation
-    """
-    return {
-        "datasetId": dataset_id,
-        "updatePredictionSetId": id,
-        "dataInfo": {
-            "annotationsCount": annotation_count,
-            "dataCount": data_count,
-        }
-    }

spb_onprem/predictions/queries.py

@@ -1,110 +0,0 @@
-from .params import (
-    get_prediction_sets_params,
-    get_prediction_set_params,
-    delete_prediction_set_params,
-    delete_prediction_from_data_params,
-    create_prediction_set_params,
-    update_prediction_set_data_info_params,
-)
-
-
-class Queries:
-    GET_PREDICTION_SETS = {
-        "name": "getPredictionSets",
-        "query": '''
-            query GetPredictionSets($dataset_id: String!, $filter: PredictionSetFilter, $cursor: String, $length: Int) {
-                predictionSets(datasetId: $dataset_id, filter: $filter, cursor: $cursor, length: $length) {
-                    predictionSets {
-                        id
-                        name
-                    }
-                    next
-                    totalCount
-                }
-            }
-        ''',
-        "variables": get_prediction_sets_params
-    }
-    
-    GET_PREDICTION_SET = {
-        "name": "getPredictionSet",
-        "query": '''
-            query GetPredictionSet($dataset_id: String!, $id: String!) {
-                predictionSet(datasetId: $dataset_id, id: $id) {
-                    id
-                    name
-                    annotationsContents
-                    evaluationResultContent {
-                        id
-                    }
-                }
-            }
-        ''',
-        "variables": get_prediction_set_params
-    }
-    
-    DELETE_PREDICTION_SET = {
-        "name": "deletePredictionSet",
-        "query": '''
-            mutation DeletePredictionSet($dataset_id: String!, $id: String!) {
-                deletePredictionSet(datasetId: $dataset_id, id: $id)
-            }
-        ''',
-        "variables": delete_prediction_set_params
-    }
-    
-    DELETE_PREDICTION_FROM_DATA = {
-        "name": "deletePredictionFromData",
-        "query": '''
-            mutation DeletePrediction($dataset_id: String!, $data_id: String!, $set_id: String!) {
-                deletePrediction(datasetId: $dataset_id, dataId: $data_id, setId: $set_id)
-            }
-        ''',
-        "variables": delete_prediction_from_data_params
-    }
-    
-    CREATE_PREDICTION_SET = {
-        "name": "createPredictionSet",
-        "query": '''
-            mutation CreatePredictionSet(
-                $datasetId: ID!,
-                $modelId: ID!,
-                $name: String!,
-                $description: String,
-                $type: PredictionSetTypes!,
-                $dataInfo: PredictionSetDataInfoInput
-            ) {
-                createPredictionSet(
-                    datasetId: $datasetId,
-                    modelId: $modelId,
-                    name: $name,
-                    description: $description,
-                    type: $type,
-                    dataInfo: $dataInfo
-                ) {
-                    id
-                }
-            }
-        ''',
-        "variables": create_prediction_set_params
-    }
-    
-    UPDATE_PREDICTION_SET_DATA_INFO = {
-        "name": "updatePredictionSet",
-        "query": '''
-            mutation UpdatePredictionSet(
-                $datasetId: ID!,
-                $updatePredictionSetId: ID!,
-                $dataInfo: PredictionSetDataInfoInput
-            ) {
-                updatePredictionSet(
-                    datasetId: $datasetId,
-                    id: $updatePredictionSetId,
-                    dataInfo: $dataInfo
-                ) {
-                    id
-                }
-            }
-        ''',
-        "variables": update_prediction_set_data_info_params
-    }

spb_onprem/predictions/service.py

@@ -1,225 +0,0 @@
-from typing import Optional, Dict, Any, List, Tuple, Union
-
-from spb_onprem.base_service import BaseService
-from spb_onprem.base_types import Undefined, UndefinedType
-from spb_onprem.exceptions import BadParameterError
-from .queries import Queries
-from .entities import PredictionSet
-
-
-class PredictionService(BaseService):
-    """Service class for handling prediction set operations."""
-    
-    def get_prediction_sets(
-        self,
-        dataset_id: str,
-        filter: Union[UndefinedType, Dict[str, Any]] = Undefined,
-        cursor: Union[UndefinedType, str] = Undefined,
-        length: int = 50
-    ) -> Tuple[List[PredictionSet], Optional[str], int]:
-        """Get paginated list of prediction sets for a dataset.
-        
-        Args:
-            dataset_id (str): The dataset ID.
-            filter (Union[UndefinedType, Dict[str, Any]]): Filter for prediction sets.
-            cursor (Union[UndefinedType, str]): Cursor for pagination.
-            length (int): Number of items to retrieve per page.
-        
-        Returns:
-            Tuple[List[PredictionSet], Optional[str], int]: A tuple containing prediction sets, next cursor, and total count.
-        """
-        if dataset_id is None:
-            raise BadParameterError("dataset_id is required.")
-
-        response = self.request_gql(
-            Queries.GET_PREDICTION_SETS,
-            Queries.GET_PREDICTION_SETS["variables"](
-                dataset_id=dataset_id,
-                filter=filter,
-                cursor=cursor,
-                length=length
-            )
-        )
-        prediction_sets_list = response.get("predictionSets", [])
-        return (
-            [PredictionSet.model_validate(ps) for ps in prediction_sets_list],
-            response.get("next"),
-            response.get("totalCount", 0)
-        )
-    
-    def get_prediction_set(
-        self,
-        dataset_id: str,
-        prediction_set_id: str
-    ) -> PredictionSet:
-        """Get detailed prediction set information including content IDs.
-        
-        Args:
-            dataset_id (str): The dataset ID.
-            prediction_set_id (str): The prediction set ID.
-        
-        Returns:
-            PredictionSet: The prediction set entity.
-        """
-        if dataset_id is None:
-            raise BadParameterError("dataset_id is required.")
-        if prediction_set_id is None:
-            raise BadParameterError("prediction_set_id is required.")
-
-        response = self.request_gql(
-            Queries.GET_PREDICTION_SET,
-            Queries.GET_PREDICTION_SET["variables"](
-                dataset_id=dataset_id,
-                prediction_set_id=prediction_set_id
-            )
-        )
-        prediction_set_dict = response.get("predictionSet", {})
-        return PredictionSet.model_validate(prediction_set_dict)
-    
-    def delete_prediction_set(
-        self,
-        dataset_id: str,
-        prediction_set_id: str
-    ) -> bool:
-        """Delete a prediction set from the dataset.
-        
-        Args:
-            dataset_id (str): The dataset ID.
-            prediction_set_id (str): The prediction set ID to delete.
-        
-        Returns:
-            bool: True if deletion was successful.
-        """
-        if dataset_id is None:
-            raise BadParameterError("dataset_id is required.")
-        if prediction_set_id is None:
-            raise BadParameterError("prediction_set_id is required.")
-
-        response = self.request_gql(
-            Queries.DELETE_PREDICTION_SET,
-            Queries.DELETE_PREDICTION_SET["variables"](
-                dataset_id=dataset_id,
-                prediction_set_id=prediction_set_id
-            )
-        )
-        return response
-    
-    def delete_prediction_from_data(
-        self,
-        dataset_id: str,
-        data_id: str,
-        prediction_set_id: str
-    ) -> bool:
-        """Delete predictions from a specific data item for a given prediction set.
-        
-        Args:
-            dataset_id (str): The dataset ID.
-            data_id (str): The data ID.
-            prediction_set_id (str): The prediction set ID.
-        
-        Returns:
-            bool: True if deletion was successful.
-        """
-        if dataset_id is None:
-            raise BadParameterError("dataset_id is required.")
-        if data_id is None:
-            raise BadParameterError("data_id is required.")
-        if prediction_set_id is None:
-            raise BadParameterError("prediction_set_id is required.")
-
-        response = self.request_gql(
-            Queries.DELETE_PREDICTION_FROM_DATA,
-            Queries.DELETE_PREDICTION_FROM_DATA["variables"](
-                dataset_id=dataset_id,
-                data_id=data_id,
-                prediction_set_id=prediction_set_id
-            )
-        )
-        return response.get("deletePrediction") is not None
-
-    def create_prediction_set(
-        self,
-        dataset_id: str,
-        model_id: str,
-        name: str,
-        type: str,
-        description: Optional[str] = None,
-        annotations_count: Optional[int] = None,
-        data_count: Optional[int] = None,
-    ) -> Optional[str]:
-        """Create a new prediction set.
-        
-        Args:
-            dataset_id (str): The dataset ID.
-            model_id (str): The model ID.
-            name (str): Name of the prediction set.
-            type (str): Type of the prediction set.
-            description (Optional[str]): Description of the prediction set.
-            annotations_count (Optional[int]): Number of annotations.
-            data_count (Optional[int]): Number of data items.
-        
-        Returns:
-            Optional[str]: The created prediction set ID if successful, None otherwise.
-        """
-        if dataset_id is None:
-            raise BadParameterError("dataset_id is required.")
-        if model_id is None:
-            raise BadParameterError("model_id is required.")
-        if name is None:
-            raise BadParameterError("name is required.")
-        if type is None:
-            raise BadParameterError("type is required.")
-
-        response = self.request_gql(
-            Queries.CREATE_PREDICTION_SET,
-            Queries.CREATE_PREDICTION_SET["variables"](
-                dataset_id=dataset_id,
-                model_id=model_id,
-                name=name,
-                type=type,
-                description=description,
-                annotations_count=annotations_count,
-                data_count=data_count
-            )
-        )
-        prediction_set = response.get("createPredictionSet")
-        return prediction_set.get("id") if prediction_set else None
-
-    def update_prediction_set_data_info(
-        self,
-        dataset_id: str,
-        id: str,
-        annotation_count: int,
-        data_count: int
-    ) -> Optional[str]:
-        """Update the data info of a prediction set.
-        
-        Args:
-            dataset_id (str): The dataset ID.
-            id (str): The prediction set ID to update.
-            annotation_count (int): Number of annotations.
-            data_count (int): Number of data items.
-        
-        Returns:
-            Optional[str]: The updated prediction set ID if successful, None otherwise.
-        """
-        if dataset_id is None:
-            raise BadParameterError("dataset_id is required.")
-        if id is None:
-            raise BadParameterError("id is required.")
-        if annotation_count is None:
-            raise BadParameterError("annotation_count is required.")
-        if data_count is None:
-            raise BadParameterError("data_count is required.")
-
-        response = self.request_gql(
-            Queries.UPDATE_PREDICTION_SET_DATA_INFO,
-            Queries.UPDATE_PREDICTION_SET_DATA_INFO["variables"](
-                dataset_id=dataset_id,
-                id=id,
-                annotation_count=annotation_count,
-                data_count=data_count
-            )
-        )
-        prediction_set = response.get("updatePredictionSet")
-        return prediction_set.get("id") if prediction_set else None

tests/models/__init__.py

@@ -1 +0,0 @@
-# Models test package