superb-ai-onprem 0.1.0__py3-none-any.whl

spb_onprem/data/enums/scene_type.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class SceneType(str, Enum):
+    """
+    The scene type of the data.
+    This is used to determine the type of the file.
+    """
+    IMAGE = "IMAGE"
+    ETC = "ETC"

spb_onprem/data/params/__init__.py

@@ -0,0 +1,59 @@
+from .data_list import (
+    AnnotationFilter,
+    DataListFilter,
+    DataFilterOptions,
+    get_data_id_list_params,
+    get_data_list_params,
+)
+from .create_data import (
+    create_params
+)
+from .update_data import (
+    update_params
+)
+from .data import (
+    get_params
+)
+from .insert_data_to_slice import (
+    insert_data_to_slice_params
+)
+from .remove_data_from_slice import (
+    remove_data_from_slice_params
+)
+from .delete_data import (
+    delete_data_params,
+)
+from .insert_prediction import (
+    insert_prediction_params,
+)
+from .delete_prediction import (
+    delete_prediction_params,
+)
+from .update_annotation import (
+    update_annotation_params,
+)
+from .insert_annotation_version import (
+    insert_annotation_version_params,
+)
+from .delete_annotation_version import (
+    delete_annotation_version_params,
+)
+
+__all__ = (
+    "AnnotationFilter",
+    "DataListFilter",
+    "DataFilterOptions",
+    "create_params",
+    "update_params",
+    "get_params",
+    "get_data_id_list_params",
+    "get_data_list_params",
+    "insert_data_to_slice_params",
+    "remove_data_from_slice_params",
+    "delete_data_params",
+    "insert_prediction_params",
+    "delete_prediction_params",
+    "update_annotation_params",
+    "insert_annotation_version_params",
+    "delete_annotation_version_params",
+)

spb_onprem/data/params/create_data.py

@@ -0,0 +1,68 @@
+from spb_onprem.data.entities import Data
+
+
+def create_params(
+    data: Data,
+):
+    """Make the variables for the createData query.
+
+    Args:
+        data (Data): The data object what you want to create.
+    """
+    return {
+        "datasetId": data.dataset_id,
+        "key": data.key,
+        "type": data.type.value,
+        "slices": data.slice_ids if data.slice_ids is not None else [],
+        "scene": [
+            {
+                "type": scene.type.value,
+                "content": {
+                    "id": scene.content.id,
+                },
+                "meta": scene.meta,
+            }
+            for scene in data.scene
+        ] if data.scene is not None else None,
+        "thumbnail": {
+            "id": data.thumbnail.id,
+        } if data.thumbnail is not None else None,
+        "annotation": {
+            "versions": [
+                {
+                    "content": {
+                        "id": version.content.id,
+                    },
+                    "meta": version.meta,
+                }
+                for version in data.annotation.versions
+            ],
+            "meta": data.annotation.meta
+        } if data.annotation is not None else None,
+        "predictions": [
+            {
+                "setId": prediction.set_id,
+                "content": {
+                    "id": prediction.content.id,
+                },
+                "meta": prediction.meta,
+            }
+            for prediction in data.predictions
+        ] if data.predictions is not None else [],
+        "meta": [
+            {
+                "key": meta.key,
+                "type": meta.type.value,
+                "value": meta.value,
+            }
+            for meta in data.meta
+        ] if data.meta is not None else None,
+        "systemMeta": [
+            {
+                "key": meta.key,
+                "type": meta.type.value,
+                "value": meta.value,
+            }
+            for meta in data.system_meta
+        ] if data.system_meta is not None else None,
+    }

spb_onprem/data/params/data.py

@@ -0,0 +1,24 @@
+from typing import Union
+from spb_onprem.base_types import Undefined, UndefinedType
+
+
+def get_params(
+    dataset_id: str,
+    data_id: Union[str, UndefinedType] = Undefined,
+    data_key: Union[str, UndefinedType] = Undefined,
+):
+    """Make the variables for the data query.
+
+    Args:
+        data_id (Union[str, UndefinedType], optional): The ID of the data. Defaults to Undefined.
+        data_key (Union[str, UndefinedType], optional): The key of the data. Defaults to Undefined.
+
+    Returns:
+        dict: The variables for the data query.
+    """
+    
+    return {
+        "dataset_id": dataset_id,
+        "key": data_key,
+        "id": data_id,
+    }

spb_onprem/data/params/data_list.py

@@ -0,0 +1,96 @@
+from typing import (
+    Optional,
+    List
+)
+from spb_onprem.base_model import CustomBaseModel, Field
+from spb_onprem.data.enums import DataType
+from spb_onprem.exceptions import BadParameterError
+
+class AnnotationFilter(CustomBaseModel):
+    type: Optional[str] = None
+    key: Optional[str] = None
+
+
+class DataFilterOptions(CustomBaseModel):
+    id_in: Optional[List[str]] = Field(None, alias="idIn")
+    slice_id: Optional[str] = Field(None, alias="sliceId")
+    slice_id_in: Optional[List[str]] = Field(None, alias="sliceIdIn")
+    key_contains: Optional[str] = Field(None, alias="keyContains")
+    key_matches: Optional[str] = Field(None, alias="keyMatches")
+    type_in: Optional[List[DataType]] = Field(None, alias="typeIn")
+    annotation_in: Optional[List[AnnotationFilter]] = Field(None, alias="annotationIn")
+    annotation_exists: Optional[bool] = Field(None, alias="annotationExists")
+    prediction_set_id_in: Optional[List[str]] = Field(None, alias="predictionSetIdIn")
+    prediction_set_id_exists: Optional[bool] = Field(None, alias="predictionSetIdExists")
+
+
+class DataListFilter(CustomBaseModel):
+    must_filter: Optional[DataFilterOptions] = Field(None, alias="must")
+    not_filter: Optional[DataFilterOptions] = Field(None, alias="not")
+
+
+def get_data_id_list_params(
+    dataset_id: str,
+    data_list_filter: Optional[DataListFilter] = None,
+    cursor: Optional[str] = None,
+    length: Optional[int] = 50,
+):
+    """Make the variables for the dataIdList query.
+
+    Args:
+        dataset_id (str): The dataset id.
+        data_list_filter (Optional[DataListFilter], optional): The filter for the data list. Defaults to None.
+        cursor (Optional[str], optional): The cursor for the data list. Defaults to None.
+        length (Optional[int], optional): The length of the data list. Defaults to 50.
+
+    Raises:
+        BadParameterError: The maximum length is 200.
+
+    Returns:
+        dict: The variables for the dataIdList query.
+    """
+    if length > 200:
+        raise BadParameterError("The maximum length is 200.")
+
+    return {
+        "dataset_id": dataset_id,
+        "filter": data_list_filter.model_dump(
+            by_alias=True, exclude_unset=True
+        ) if data_list_filter else None,
+        "cursor": cursor,
+        "length": length
+    }
+
+
+def get_data_list_params(
+    dataset_id: str,
+    data_list_filter: Optional[DataListFilter] = None,
+    cursor: Optional[str] = None,
+    length: Optional[int] = 10,
+):
+    """Make the variables for the dataList query.
+
+    Args:
+        dataset_id (str): The dataset id.
+        data_list_filter (Optional[DataListFilter], optional): The filter for the data list. Defaults to None.
+        cursor (Optional[str], optional): The cursor for the data list. Defaults to None.
+        length (Optional[int], optional): The length of the data list. Defaults to 10.
+
+    Raises:
+        BadParameterError: The maximum length is 50.
+
+    Returns:
+        dict: The variables for the dataList query.
+    """
+
+    if length > 50:
+        raise BadParameterError("The maximum length is 50.")
+
+    return {
+        "dataset_id": dataset_id,
+        "filter": data_list_filter.model_dump(
+            by_alias=True, exclude_unset=True
+        ) if data_list_filter else None,
+        "cursor": cursor,
+        "length": length
+    }

spb_onprem/data/params/delete_annotation_version.py

@@ -0,0 +1,20 @@
+
+
+def delete_annotation_version_params(
+    dataset_id: str,
+    data_id: str,
+    version_id: str,
+):
+    """Delete annotation version from selected data.
+
+    Args:
+        dataset_id (str): dataset id which the data belongs to
+        data_id (str): data id to be deleted
+        version_id (str): annotation version id to be deleted
+    """
+    
+    return {
+        "dataset_id": dataset_id,
+        "data_id": data_id,
+        "id": version_id,
+    }

spb_onprem/data/params/delete_data.py

@@ -0,0 +1,17 @@
+
+
+def delete_data_params(
+    dataset_id: str,
+    data_id: str,
+):
+    """Delete the data from dataset.
+
+    Args:
+        dataset_id (str): the dataset id which the data belongs to.
+        data_id (str): the data id to delete.
+    """
+    
+    return {
+        "dataset_id": dataset_id,
+        "id": data_id,
+    }

spb_onprem/data/params/delete_prediction.py

@@ -0,0 +1,22 @@
+
+
+def delete_prediction_params (
+    dataset_id: str,
+    data_id: str,
+    set_id: str,
+):
+    """Delete prediction from selected data.
+
+    Args:
+        dataset_id (str): dataset id which the data belongs to
+        data_id (str): data id to be deleted
+        set_id (str): set id to be deleted
+        
+    Returns:
+        dict: the params for graphql query
+    """
+    return {
+        "dataset_id": dataset_id,
+        "data_id": data_id,
+        "set_id": set_id,
+    }

spb_onprem/data/params/delete_scene.py

@@ -0,0 +1,22 @@
+
+
+def delete_scene_params(
+    dataset_id: str,
+    data_id: str,
+    scene_id: str,
+):
+    """Delete scene from selected data.
+
+    Args:
+        dataset_id (str): dataset id which the data belongs to
+        data_id (str): data id to be deleted
+        scene_id (str): scene id to be deleted
+        
+    Returns:
+        dict: the params for graphql query
+    """
+    return {
+        "dataset_id": dataset_id,
+        "data_id": data_id,
+        "scene_id": scene_id,
+    }

spb_onprem/data/params/insert_annotation_version.py

@@ -0,0 +1,29 @@
+from spb_onprem.data.entities import AnnotationVersion
+
+
+def insert_annotation_version_params(
+    dataset_id: str,
+    data_id: str,
+    version: AnnotationVersion,
+):
+    """Insert annotation version to selected data.
+
+    Args:
+        dataset_id (str): dataset id which the data belongs to
+        data_id (str): data id to be inserted
+        annotation (AnnotationVersion): annotation version to be inserted
+
+    Returns:
+        dict: the params for graphql query
+    """
+
+    return {
+        "dataset_id": dataset_id,
+        "data_id": data_id,
+        "version": {
+        "content": version.content.model_dump(
+                by_alias=True, exclude_unset=True
+            ),
+            "meta": version.meta
+        },
+    }

spb_onprem/data/params/insert_data_to_slice.py

@@ -0,0 +1,22 @@
+
+
+def insert_data_to_slice_params(
+    dataset_id: str,
+    data_id: str,
+    slice_id: str,
+):
+    """Insert data to selected slice.
+
+    Args:
+        dataset_id (str): dataset id which the data belongs to
+        data_id (str): data id to be inserted
+        slice_id (str): slice id to be inserted
+
+    Returns:
+        dict: the params for graphql query
+    """
+    return {
+        "dataset_id": dataset_id,
+        "data_id": data_id,
+        "slice_id": slice_id,
+    }

spb_onprem/data/params/insert_prediction.py

@@ -0,0 +1,25 @@
+from spb_onprem.data.entities import Prediction
+
+
+def insert_prediction_params (
+    dataset_id: str,
+    data_id: str,
+    prediction: Prediction,
+):
+    """Insert prediction to selected data.
+
+    Args:
+        dataset_id (str): dataset id which the data belongs to
+        data_id (str): data id to be inserted
+        prediction (Prediction): prediction to be inserted
+
+    Returns:
+        dict: the params for graphql query
+    """
+    return {
+        "dataset_id": dataset_id,
+        "data_id": data_id,
+        "prediction": prediction.model_dump(
+            by_alias=True, exclude_unset=True
+        ),
+    }

spb_onprem/data/params/insert_scene.py

@@ -0,0 +1,32 @@
+from spb_onprem.data.entities import Scene
+
+
+def insert_scene_params(
+    dataset_id: str,
+    data_id: str,
+    scene: Scene
+):
+    """Insert scene to selected data.
+
+    Args:
+        dataset_id (str): dataset id which the data belongs to
+        data_id (str): data id to be inserted
+        scene (Scene): scene to be inserted
+
+    Returns:
+        dict: the params for graphql query
+    """
+
+    if not isinstance(scene, Scene):
+        raise ValueError("scene must be an instance of Scene.")
+    else:
+        if scene.type is None:
+            raise ValueError("scene.type must be provided.")
+
+    return {
+        "dataset_id": dataset_id,
+        "data_id": data_id,
+        "scene": scene.model_dump(
+            by_alias=True, exclude_unset=True
+        ),
+    }

spb_onprem/data/params/remove_data_from_slice.py

@@ -0,0 +1,22 @@
+
+
+def remove_data_from_slice_params(
+    dataset_id: str,
+    data_id: str,
+    slice_id: str,
+):
+    """Insert data to selected slice.
+
+    Args:
+        dataset_id (str): dataset id which the data belongs to
+        data_id (str): data id to be removed
+        slice_id (str): slice id to be removed
+
+    Returns:
+        dict: the params for graphql query
+    """
+    return {
+        "dataset_id": dataset_id,
+        "data_id": data_id,
+        "slice_id": slice_id,
+    }

spb_onprem/data/params/remove_data_meta.py

@@ -0,0 +1,64 @@
+from typing import (
+    List, Union, Optional
+)
+
+from spb_onprem.base_types import (
+    Undefined,
+    UndefinedType,
+)
+from spb_onprem.data.entities import (
+    DataMeta,
+)
+
+def remove_data_meta_params(
+    dataset_id: str,
+    data_id: str,
+    meta: Union[
+        Optional[List[DataMeta]],
+        UndefinedType
+    ] = Undefined,
+    system_meta: Union[
+        Optional[List[DataMeta]],
+        UndefinedType
+    ] = Undefined,
+):
+    """Remove meta and system meta of the selected data.
+
+    Args:
+        dataset_id (str): dataset id of the data to be removed
+        data_id (str): data id to be removed
+        meta (Union[ Optional[List[DataMeta]], UndefinedType ], optional): the meta to be deleted. Defaults to Undefined.
+        system_meta (Union[ Optional[List[DataMeta]], UndefinedType ], optional): the system meta to be deleted. Defaults to Undefined.
+    
+    Returns:
+        dict: the params for graphql query
+    """
+    
+    variables = {
+        "dataset_id": dataset_id,
+        "data_id": data_id,
+    }
+    
+    if meta is not Undefined:
+        if meta is not None and not isinstance(meta, list):
+            raise ValueError("meta must be a list of DataMeta or None.")
+        variables["meta"] = [
+            {
+                "key": item.key,
+                "type": item.type.value,
+            }
+            for item in meta
+        ] if meta is not None else None
+    
+    if system_meta is not Undefined:
+        if system_meta is not None and not isinstance(system_meta, list):
+            raise ValueError("system_meta must be a list of DataMeta or None.")
+        variables["system_meta"] = [
+            {
+                "key": item.key,
+                "type": item.type.value,
+            }
+            for item in system_meta
+        ] if system_meta is not None else None
+    
+    return variables

spb_onprem/data/params/update_annotation.py

@@ -0,0 +1,30 @@
+from typing import Union
+from spb_onprem.base_types import UndefinedType, Undefined
+from spb_onprem.exceptions import BadParameterError
+
+def update_annotation_params(
+    dataset_id: str,
+    data_id: str,
+    meta: Union[
+        dict,
+        UndefinedType,
+    ],
+):
+    """Make the variables for the updateAnnotation query.
+
+    Args:
+        dataset_id (str): The dataset ID of the data.
+        data_id (str): The ID of the data.
+        meta (dict): The meta of the data.
+    """
+    variables = {
+        "dataset_id": dataset_id,
+        "data_id": data_id,
+    }
+
+    if meta is not Undefined:
+        if meta is not None and not isinstance(meta, dict):
+            raise BadParameterError("meta must be a dict or None.")
+        variables["meta"] = meta
+
+    return variables

spb_onprem/data/params/update_data.py

@@ -0,0 +1,72 @@
+from typing import (
+    Union,
+    Optional,
+    List
+)
+from spb_onprem.base_types import (
+    Undefined,
+    UndefinedType,
+)
+from spb_onprem.data.entities import (
+    DataMeta,
+)
+
+
+def update_params(
+    dataset_id: str,
+    data_id: str,
+    key: Union[
+        Optional[str],
+        UndefinedType
+    ] = Undefined,
+    meta: Union[
+        Optional[List[DataMeta]],
+        UndefinedType
+    ] = Undefined,
+    system_meta: Union[
+        Optional[List[DataMeta]],
+        UndefinedType
+    ] = Undefined,
+):
+    """Make the variables for the updateData query.
+
+    Args:
+        dataset_id (str): The dataset ID of the data.
+        id (str): The ID of the data.
+        key (str): The key of the data.
+        meta (List[DataMeta]): The meta of the data.
+        system_meta (List[DataMeta]): The system meta of the data.
+    """
+    variables = {
+        "datasetId": dataset_id,
+        "id": data_id,
+    }
+    
+    if key is not Undefined:
+        variables["key"] = key
+    
+    if meta is not Undefined:
+        if meta is not None and not isinstance(meta, list):
+            raise ValueError("meta must be a list of DataMeta or None.")
+        variables["meta"] = [
+            {
+                "key": meta.key,
+                "type": meta.type.value,
+                "value": meta.value,
+            }
+            for meta in meta
+        ] if meta is not None else None
+    
+    if system_meta is not Undefined:
+        if system_meta is not None and not isinstance(system_meta, list):
+            raise ValueError("meta must be a list of DataMeta or None.")
+        variables["systemMeta"] = [
+            {
+                "key": meta.key,
+                "type": meta.type.value,
+                "value": meta.value,
+            }
+            for meta in system_meta
+        ] if system_meta is not None else None
+
+    return variables

spb_onprem/data/params/update_scene.py

@@ -0,0 +1,37 @@
+from spb_onprem.data.entities import Scene
+
+
+def update_scene_params(
+    dataset_id: str,
+    data_id: str,
+    scene: Scene
+):
+    """Update scene to selected data.
+
+    Args:
+        dataset_id (str): dataset id which the data belongs to
+        data_id (str): data id to be updated
+        scene (Scene): scene to be updated
+
+    Returns:
+        dict: the params for graphql query
+    """
+
+    if not isinstance(scene, Scene):
+        raise ValueError("scene must be an instance of Scene.")
+    else:
+        if scene.id is None:
+            raise ValueError("scene.id must be provided.")
+        if scene.type is None:
+            raise ValueError("scene.type must be provided.")
+
+    return {
+        "dataset_id": dataset_id,
+        "data_id": data_id,
+        "id": scene.id,
+        "scene": {
+            "content": scene.content,
+            "type": scene.type.value,
+            "meta": scene.meta,
+        },
+    }