Skip to content

Dataset Types API

Description

A dataset type defines the type of a specific Dataset.

The following dataset types are pre-defined, along with their dataset_type_id:

Dataset Type dataset_type_id
Default 0
Sensor 1
Trait 2
Script 3
Model 4
Procedure 5
Other 6

Module

This module defines the DatasetType class, which represents a type or category for datasets.

It includes methods for creating, retrieving, updating, and deleting dataset types, as well as methods for checking existence, searching, and managing additional information.

This module includes the following methods:

  • exists: Check if a dataset type with the given name exists.
  • create: Create a new dataset type.
  • get: Retrieve a dataset type by its name.
  • get_by_id: Retrieve a dataset type by its ID.
  • get_all: Retrieve all dataset types.
  • search: Search for dataset types based on various criteria.
  • update: Update the details of a dataset type.
  • delete: Delete a dataset type.
  • refresh: Refresh the dataset type's data from the database.
  • get_info: Get the additional information of the dataset type.
  • set_info: Set the additional information of the dataset type.

DatasetType

Bases: APIBase

Represents a type or category for datasets.

Attributes:

Name Type Description
id Optional[ID]

The unique identifier of the dataset type.
dataset_type_name str

The name of the dataset type.
dataset_type_info Optional[dict]

Additional information about the dataset type.
Source code in gemini/api/dataset_type.py 
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
class DatasetType(APIBase):
    """
    Represents a type or category for datasets.

    Attributes:
        id (Optional[ID]): The unique identifier of the dataset type.
        dataset_type_name (str): The name of the dataset type.
        dataset_type_info (Optional[dict]): Additional information about the dataset type.
    """

    id: Optional[ID] = Field(None, validation_alias=AliasChoices("id", "dataset_type_id"))

    dataset_type_name: str
    dataset_type_info: Optional[dict] = None

    def __str__(self):
        """Return a string representation of the DatasetType object."""
        return f"DatasetType(dataset_type_name={self.dataset_type_name}, id={self.id})"

    def __repr__(self):
        """Return a detailed string representation of the DatasetType object."""
        return f"DatasetType(dataset_type_name={self.dataset_type_name}, id={self.id})"

    @classmethod
    def exists(
        cls,
        dataset_type_name: str
    ) -> bool:
        """
        Check if a dataset type with the given name exists.

        Examples:
            >>> DatasetType.exists("example_dataset_type")
            True
            >>> DatasetType.exists("non_existent_type")
            False

        Args:
            dataset_type_name (str): The name of the dataset type.
        Returns:
            bool: True if the dataset type exists, False otherwise.
        """
        try:
            exists = DatasetTypeModel.exists(dataset_type_name=dataset_type_name)
            return exists
        except Exception as e:
            logger.error(f"Error checking existence of dataset type: {e}")
            return False

    @classmethod
    def create(
        cls,
        dataset_type_name: str,
        dataset_type_info: dict = None,
    ) -> Optional["DatasetType"]:
        """
        Create a new dataset type. If a dataset type with same name already exists, it will return the existing one.

        Examples:
            >>> DatasetType.create("example_dataset_type", {"description": "An example dataset type"})
            DatasetType(dataset_type_name='example_dataset_type', id=...)

        Args:
            dataset_type_name (str): The name of the dataset type.
            dataset_type_info (dict, optional): Additional information about the dataset type. Defaults to {{}}.
        Returns:
            Optional["DatasetType"]: The created dataset type, or None if an error occurred.
        """
        try:
            db_instance = DatasetTypeModel.get_or_create(
                dataset_type_name=dataset_type_name,
                dataset_type_info=dataset_type_info,
            )
            instance = cls.model_validate(db_instance)
            return instance
        except Exception as e:
            logger.error(f"Error creating dataset type: {e}")
            return None

    @classmethod
    def get(cls, dataset_type_name: str) -> Optional["DatasetType"]:
        """
        Retrieve a dataset type by its name.

        Examples:
            >>> DatasetType.get("example_dataset_type")
            DatasetType(dataset_type_name='example_dataset_type', id=...)

        Args:
            dataset_type_name (str): The name of the dataset type.
        Returns:
            Optional["DatasetType"]: The dataset type, or None if not found.
        """
        try:
            db_instance = DatasetTypeModel.get_by_parameters(dataset_type_name=dataset_type_name)
            if not db_instance:
                logger.debug(f"Dataset type with name {dataset_type_name} not found.")
                return None
            instance = cls.model_validate(db_instance)
            return instance
        except Exception as e:
            logger.error(f"Error getting dataset type: {e}")
            return None

    @classmethod
    def get_by_id(cls, id: UUID | int | str) -> Optional["DatasetType"]:
        """
        Retrieve a dataset type by its ID.

        Examples:
            >>> DatasetType.get_by_id(...)
            DatasetType(dataset_type_name='example_dataset_type', id=...)

        Args:
            id (UUID | int | str): The ID of the dataset type.
        Returns:
            Optional["DatasetType"]: The dataset type, or None if not found.
        """
        try:
            db_instance = DatasetTypeModel.get(id)
            if not db_instance:
                logger.warning(f"Dataset type with ID {id} does not exist.")
                return None
            instance = cls.model_validate(db_instance)
            return instance
        except Exception as e:
            logger.error(f"Error getting dataset type by ID: {e}")
            return None

    @classmethod
    def get_all(cls, limit: int = None, offset: int = None) -> Optional[List["DatasetType"]]:
        """
        Retrieve all dataset types.

        Examples:
            >>> DatasetType.get_all()
            [DatasetType(dataset_type_name='example_dataset_type', id=...), DatasetType(dataset_type_name='another_dataset_type', id=...)]


        Returns:
            Optional[List["DatasetType"]]: A list of all dataset types, or None if an error occurred.
        """
        try:
            instances = DatasetTypeModel.all(limit=limit, offset=offset)
            if not instances or len(instances) == 0:
                logger.info("No dataset types found.")
                return None
            instances = [cls.model_validate(instance) for instance in instances]
            return instances
        except Exception as e:
            logger.error(f"Error getting all dataset types: {e}")
            return None

    @classmethod
    def search(
        cls,
        dataset_type_name: str = None,
        dataset_type_info: dict = None
    ) -> Optional[List["DatasetType"]]:
        """
        Search for dataset types based on various criteria.

        Examples:
            >>> DatasetType.search(dataset_type_name="example_dataset_type")
            [DatasetType(dataset_type_name='example_dataset_type', id=...)]


        Args:
            dataset_type_name (str, optional): The name of the dataset type. Defaults to None.
            dataset_type_info (dict, optional): Additional information about the dataset type. Defaults to None.
        Returns:
            Optional[List["DatasetType"]]: A list of matching dataset types, or None if an error occurred.
        """
        try:
            if not any([dataset_type_name, dataset_type_info]):
                logger.warning("At least one search parameter must be provided.")
                return None

            instances = DatasetTypeModel.search(
                dataset_type_name=dataset_type_name,
                dataset_type_info=dataset_type_info
            )
            if not instances or len(instances) == 0:
                logger.info("No dataset types found with the provided search parameters.")
                return None
            instances = [cls.model_validate(instance) for instance in instances]
            return instances
        except Exception as e:
            logger.error(f"Error searching dataset types: {e}")
            return None

    def update(
            self,
            dataset_type_name: str = None,
            dataset_type_info: dict = None
        ) -> Optional["DatasetType"]:
        """
        Update the details of the dataset type.

        Examples:
            >>> dataset_type = DatasetType.get("example_dataset_type")
            >>> updated_dataset_type = dataset_type.update(dataset_type_name="new_name", dataset_type_info{"description": "Updated description"})
            >>> print(updated_dataset_type)
            DatasetType(dataset_type_name='new_name', id=...)

        Args:
            dataset_type_name (str, optional): The new name of the dataset type. Defaults to None.
            dataset_type_info (dict, optional): The new information. Defaults to None.
        Returns:
            Optional["DatasetType"]: The updated dataset type, or None if an error occurred.
        """
        try:
            if not any([dataset_type_name, dataset_type_info]):
                logger.warning("At least one parameter must be provided for update.")
                return None

            current_id = self.id
            dataset_type = DatasetTypeModel.get(current_id)
            if not dataset_type:
                 logger.warning(f"Dataset type with ID {current_id} does not exist.")
                 return None

            dataset_type = DatasetTypeModel.update(
                dataset_type,
                dataset_type_name=dataset_type_name,
                dataset_type_info=dataset_type_info,
            )
            instance = self.model_validate(dataset_type)
            self.refresh()
            return instance
        except Exception as e:
            logger.error(f"Error updating dataset type: {e}")
            return None

    def delete(self) -> bool:
        """
        Delete the dataset type.

        Examples:
            >>> dataset_type = DatasetType.get("example_dataset_type")
            >>> success = dataset_type.delete()
            >>> print(success)
            True

        Returns:
            bool: True if the dataset type was deleted, False otherwise.
        """
        try:
            current_id = self.id
            dataset_type = DatasetTypeModel.get(current_id)
            if not dataset_type:
                 logger.warning(f"Dataset type with ID {current_id} does not exist.")
                 return False
            DatasetTypeModel.delete(dataset_type)
            return True
        except Exception as e:
            logger.error(f"Error deleting dataset type: {e}")
            return False

    def refresh(self) -> Optional["DatasetType"]:
        """
        Refresh the dataset type's data from the database. It is rarely called by the user
        as it is automatically called on access.

        Examples:
            >>> dataset_type = DatasetType.get("example_dataset_type")
            >>> refreshed_dataset_type = dataset_type.refresh()
            >>> print(refreshed_dataset_type)
            DatasetType(dataset_type_name='example_dataset_type', id=...)

        Returns:
            Optional["DatasetType"]: The refreshed dataset type, or None if an error occurred.
        """
        try:
            db_instance = DatasetTypeModel.get(self.id)
            if not db_instance:
                logger.warning(f"Dataset type with ID {self.id} does not exist.")
                return self
            instance = self.model_validate(db_instance)
            for key, value in instance.model_dump().items():
                if hasattr(self, key) and key != "id":
                    setattr(self, key, value)
            return self
        except Exception as e:
            logger.error(f"Error refreshing dataset type: {e}")
            return None

    def get_info(self) -> Optional[dict]:
        """
        Get the additional information of the dataset type.

        Examples:
            >>> dataset_type = DatasetType.get("example_dataset_type")
            >>> info = dataset_type.get_info()
            >>> print(info)
            {'description': 'An example dataset type'}

        Returns:
            Optional[dict]: The dataset type's info, or None if not found.
        """
        try:
            current_id = self.id
            dataset_type = DatasetTypeModel.get(current_id)
            if not dataset_type:
                logger.warning(f"Dataset type with ID {current_id} does not exist.")
                return None
            dataset_type_info = dataset_type.dataset_type_info
            if not dataset_type_info:
                logger.info("DatasetType info is empty.")
                return None
            return dataset_type_info
        except Exception as e:
            logger.error(f"Error getting dataset type info: {e}")
            return None

    def set_info(self, dataset_type_info: dict) -> Optional["DatasetType"]:
        """
        Set the additional information of the dataset type.

        Examples:
            >>> dataset_type = DatasetType.get("example_dataset_type")
            >>> updated_dataset_type = dataset_type.set_info({"description": "Updated description"})
            >>> print(updated_dataset_type.get_info())
            {'description': 'Updated description'}

        Args:
            dataset_type_info (dict): The new information to set.
        Returns:
            Optional["DatasetType"]: The updated dataset type, or None if an error occurred.
        """
        try:
            current_id = self.id
            dataset_type = DatasetTypeModel.get(current_id)
            if not dataset_type:
                logger.warning(f"Dataset type with ID {current_id} does not exist.")
                return None
            dataset_type = DatasetTypeModel.update(
                dataset_type,
                dataset_type_info=dataset_type_info,
            )
            instance = self.model_validate(dataset_type)
            self.refresh()
            return instance
        except Exception as e:
            logger.error(f"Error setting dataset type info: {e}")
            return None

__repr__()

Return a detailed string representation of the DatasetType object.

Source code in gemini/api/dataset_type.py 
52
53
54
def __repr__(self):
    """Return a detailed string representation of the DatasetType object."""
    return f"DatasetType(dataset_type_name={self.dataset_type_name}, id={self.id})"

__str__()

Return a string representation of the DatasetType object.

Source code in gemini/api/dataset_type.py 
48
49
50
def __str__(self):
    """Return a string representation of the DatasetType object."""
    return f"DatasetType(dataset_type_name={self.dataset_type_name}, id={self.id})"

create(dataset_type_name, dataset_type_info=None) classmethod

Create a new dataset type. If a dataset type with same name already exists, it will return the existing one.

Examples:

>>> DatasetType.create("example_dataset_type", {"description": "An example dataset type"})
DatasetType(dataset_type_name='example_dataset_type', id=...)

Parameters:

Name Type Description Default
dataset_type_name str

The name of the dataset type.

 required
dataset_type_info dict

Additional information about the dataset type. Defaults to {{}}.

 None

Returns: Optional["DatasetType"]: The created dataset type, or None if an error occurred.

Source code in gemini/api/dataset_type.py 
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
@classmethod
def create(
    cls,
    dataset_type_name: str,
    dataset_type_info: dict = None,
) -> Optional["DatasetType"]:
    """
    Create a new dataset type. If a dataset type with same name already exists, it will return the existing one.

    Examples:
        >>> DatasetType.create("example_dataset_type", {"description": "An example dataset type"})
        DatasetType(dataset_type_name='example_dataset_type', id=...)

    Args:
        dataset_type_name (str): The name of the dataset type.
        dataset_type_info (dict, optional): Additional information about the dataset type. Defaults to {{}}.
    Returns:
        Optional["DatasetType"]: The created dataset type, or None if an error occurred.
    """
    try:
        db_instance = DatasetTypeModel.get_or_create(
            dataset_type_name=dataset_type_name,
            dataset_type_info=dataset_type_info,
        )
        instance = cls.model_validate(db_instance)
        return instance
    except Exception as e:
        logger.error(f"Error creating dataset type: {e}")
        return None

delete()

Delete the dataset type.

Examples:

>>> dataset_type = DatasetType.get("example_dataset_type")
>>> success = dataset_type.delete()
>>> print(success)
True

Returns:

Name Type Description
bool bool

True if the dataset type was deleted, False otherwise.
Source code in gemini/api/dataset_type.py 
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
def delete(self) -> bool:
    """
    Delete the dataset type.

    Examples:
        >>> dataset_type = DatasetType.get("example_dataset_type")
        >>> success = dataset_type.delete()
        >>> print(success)
        True

    Returns:
        bool: True if the dataset type was deleted, False otherwise.
    """
    try:
        current_id = self.id
        dataset_type = DatasetTypeModel.get(current_id)
        if not dataset_type:
             logger.warning(f"Dataset type with ID {current_id} does not exist.")
             return False
        DatasetTypeModel.delete(dataset_type)
        return True
    except Exception as e:
        logger.error(f"Error deleting dataset type: {e}")
        return False

exists(dataset_type_name) classmethod

Check if a dataset type with the given name exists.

Examples:

>>> DatasetType.exists("example_dataset_type")
True
>>> DatasetType.exists("non_existent_type")
False

Parameters:

Name Type Description Default
dataset_type_name str

The name of the dataset type.

 required

Returns: bool: True if the dataset type exists, False otherwise.

Source code in gemini/api/dataset_type.py 
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
@classmethod
def exists(
    cls,
    dataset_type_name: str
) -> bool:
    """
    Check if a dataset type with the given name exists.

    Examples:
        >>> DatasetType.exists("example_dataset_type")
        True
        >>> DatasetType.exists("non_existent_type")
        False

    Args:
        dataset_type_name (str): The name of the dataset type.
    Returns:
        bool: True if the dataset type exists, False otherwise.
    """
    try:
        exists = DatasetTypeModel.exists(dataset_type_name=dataset_type_name)
        return exists
    except Exception as e:
        logger.error(f"Error checking existence of dataset type: {e}")
        return False

get(dataset_type_name) classmethod

Retrieve a dataset type by its name.

Examples:

>>> DatasetType.get("example_dataset_type")
DatasetType(dataset_type_name='example_dataset_type', id=...)

Parameters:

Name Type Description Default
dataset_type_name str

The name of the dataset type.

 required

Returns: Optional["DatasetType"]: The dataset type, or None if not found.

Source code in gemini/api/dataset_type.py 
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
@classmethod
def get(cls, dataset_type_name: str) -> Optional["DatasetType"]:
    """
    Retrieve a dataset type by its name.

    Examples:
        >>> DatasetType.get("example_dataset_type")
        DatasetType(dataset_type_name='example_dataset_type', id=...)

    Args:
        dataset_type_name (str): The name of the dataset type.
    Returns:
        Optional["DatasetType"]: The dataset type, or None if not found.
    """
    try:
        db_instance = DatasetTypeModel.get_by_parameters(dataset_type_name=dataset_type_name)
        if not db_instance:
            logger.debug(f"Dataset type with name {dataset_type_name} not found.")
            return None
        instance = cls.model_validate(db_instance)
        return instance
    except Exception as e:
        logger.error(f"Error getting dataset type: {e}")
        return None

get_all(limit=None, offset=None) classmethod

Retrieve all dataset types.

Examples:

>>> DatasetType.get_all()
[DatasetType(dataset_type_name='example_dataset_type', id=...), DatasetType(dataset_type_name='another_dataset_type', id=...)]

Returns:

Type Description
Optional[List[DatasetType]]

Optional[List["DatasetType"]]: A list of all dataset types, or None if an error occurred.
Source code in gemini/api/dataset_type.py 
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
@classmethod
def get_all(cls, limit: int = None, offset: int = None) -> Optional[List["DatasetType"]]:
    """
    Retrieve all dataset types.

    Examples:
        >>> DatasetType.get_all()
        [DatasetType(dataset_type_name='example_dataset_type', id=...), DatasetType(dataset_type_name='another_dataset_type', id=...)]


    Returns:
        Optional[List["DatasetType"]]: A list of all dataset types, or None if an error occurred.
    """
    try:
        instances = DatasetTypeModel.all(limit=limit, offset=offset)
        if not instances or len(instances) == 0:
            logger.info("No dataset types found.")
            return None
        instances = [cls.model_validate(instance) for instance in instances]
        return instances
    except Exception as e:
        logger.error(f"Error getting all dataset types: {e}")
        return None

get_by_id(id) classmethod

Retrieve a dataset type by its ID.

Examples:

>>> DatasetType.get_by_id(...)
DatasetType(dataset_type_name='example_dataset_type', id=...)

Parameters:

Name Type Description Default
id UUID | int | str

The ID of the dataset type.

 required

Returns: Optional["DatasetType"]: The dataset type, or None if not found.

Source code in gemini/api/dataset_type.py 
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
@classmethod
def get_by_id(cls, id: UUID | int | str) -> Optional["DatasetType"]:
    """
    Retrieve a dataset type by its ID.

    Examples:
        >>> DatasetType.get_by_id(...)
        DatasetType(dataset_type_name='example_dataset_type', id=...)

    Args:
        id (UUID | int | str): The ID of the dataset type.
    Returns:
        Optional["DatasetType"]: The dataset type, or None if not found.
    """
    try:
        db_instance = DatasetTypeModel.get(id)
        if not db_instance:
            logger.warning(f"Dataset type with ID {id} does not exist.")
            return None
        instance = cls.model_validate(db_instance)
        return instance
    except Exception as e:
        logger.error(f"Error getting dataset type by ID: {e}")
        return None

get_info()

Get the additional information of the dataset type.

Examples:

>>> dataset_type = DatasetType.get("example_dataset_type")
>>> info = dataset_type.get_info()
>>> print(info)
{'description': 'An example dataset type'}

Returns:

Type Description
Optional[dict]

Optional[dict]: The dataset type's info, or None if not found.
Source code in gemini/api/dataset_type.py 
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
def get_info(self) -> Optional[dict]:
    """
    Get the additional information of the dataset type.

    Examples:
        >>> dataset_type = DatasetType.get("example_dataset_type")
        >>> info = dataset_type.get_info()
        >>> print(info)
        {'description': 'An example dataset type'}

    Returns:
        Optional[dict]: The dataset type's info, or None if not found.
    """
    try:
        current_id = self.id
        dataset_type = DatasetTypeModel.get(current_id)
        if not dataset_type:
            logger.warning(f"Dataset type with ID {current_id} does not exist.")
            return None
        dataset_type_info = dataset_type.dataset_type_info
        if not dataset_type_info:
            logger.info("DatasetType info is empty.")
            return None
        return dataset_type_info
    except Exception as e:
        logger.error(f"Error getting dataset type info: {e}")
        return None

refresh()

Refresh the dataset type's data from the database. It is rarely called by the user as it is automatically called on access.

Examples:

>>> dataset_type = DatasetType.get("example_dataset_type")
>>> refreshed_dataset_type = dataset_type.refresh()
>>> print(refreshed_dataset_type)
DatasetType(dataset_type_name='example_dataset_type', id=...)

Returns:

Type Description
Optional[DatasetType]

Optional["DatasetType"]: The refreshed dataset type, or None if an error occurred.
Source code in gemini/api/dataset_type.py 
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
def refresh(self) -> Optional["DatasetType"]:
    """
    Refresh the dataset type's data from the database. It is rarely called by the user
    as it is automatically called on access.

    Examples:
        >>> dataset_type = DatasetType.get("example_dataset_type")
        >>> refreshed_dataset_type = dataset_type.refresh()
        >>> print(refreshed_dataset_type)
        DatasetType(dataset_type_name='example_dataset_type', id=...)

    Returns:
        Optional["DatasetType"]: The refreshed dataset type, or None if an error occurred.
    """
    try:
        db_instance = DatasetTypeModel.get(self.id)
        if not db_instance:
            logger.warning(f"Dataset type with ID {self.id} does not exist.")
            return self
        instance = self.model_validate(db_instance)
        for key, value in instance.model_dump().items():
            if hasattr(self, key) and key != "id":
                setattr(self, key, value)
        return self
    except Exception as e:
        logger.error(f"Error refreshing dataset type: {e}")
        return None

search(dataset_type_name=None, dataset_type_info=None) classmethod

Search for dataset types based on various criteria.

Examples:

>>> DatasetType.search(dataset_type_name="example_dataset_type")
[DatasetType(dataset_type_name='example_dataset_type', id=...)]

Parameters:

Name Type Description Default
dataset_type_name str

The name of the dataset type. Defaults to None.

 None
dataset_type_info dict

Additional information about the dataset type. Defaults to None.

 None

Returns: Optional[List["DatasetType"]]: A list of matching dataset types, or None if an error occurred.

Source code in gemini/api/dataset_type.py 
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
@classmethod
def search(
    cls,
    dataset_type_name: str = None,
    dataset_type_info: dict = None
) -> Optional[List["DatasetType"]]:
    """
    Search for dataset types based on various criteria.

    Examples:
        >>> DatasetType.search(dataset_type_name="example_dataset_type")
        [DatasetType(dataset_type_name='example_dataset_type', id=...)]


    Args:
        dataset_type_name (str, optional): The name of the dataset type. Defaults to None.
        dataset_type_info (dict, optional): Additional information about the dataset type. Defaults to None.
    Returns:
        Optional[List["DatasetType"]]: A list of matching dataset types, or None if an error occurred.
    """
    try:
        if not any([dataset_type_name, dataset_type_info]):
            logger.warning("At least one search parameter must be provided.")
            return None

        instances = DatasetTypeModel.search(
            dataset_type_name=dataset_type_name,
            dataset_type_info=dataset_type_info
        )
        if not instances or len(instances) == 0:
            logger.info("No dataset types found with the provided search parameters.")
            return None
        instances = [cls.model_validate(instance) for instance in instances]
        return instances
    except Exception as e:
        logger.error(f"Error searching dataset types: {e}")
        return None

set_info(dataset_type_info)

Set the additional information of the dataset type.

Examples:

>>> dataset_type = DatasetType.get("example_dataset_type")
>>> updated_dataset_type = dataset_type.set_info({"description": "Updated description"})
>>> print(updated_dataset_type.get_info())
{'description': 'Updated description'}

Parameters:

Name Type Description Default
dataset_type_info dict

The new information to set.

 required

Returns: Optional["DatasetType"]: The updated dataset type, or None if an error occurred.

Source code in gemini/api/dataset_type.py 
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
def set_info(self, dataset_type_info: dict) -> Optional["DatasetType"]:
    """
    Set the additional information of the dataset type.

    Examples:
        >>> dataset_type = DatasetType.get("example_dataset_type")
        >>> updated_dataset_type = dataset_type.set_info({"description": "Updated description"})
        >>> print(updated_dataset_type.get_info())
        {'description': 'Updated description'}

    Args:
        dataset_type_info (dict): The new information to set.
    Returns:
        Optional["DatasetType"]: The updated dataset type, or None if an error occurred.
    """
    try:
        current_id = self.id
        dataset_type = DatasetTypeModel.get(current_id)
        if not dataset_type:
            logger.warning(f"Dataset type with ID {current_id} does not exist.")
            return None
        dataset_type = DatasetTypeModel.update(
            dataset_type,
            dataset_type_info=dataset_type_info,
        )
        instance = self.model_validate(dataset_type)
        self.refresh()
        return instance
    except Exception as e:
        logger.error(f"Error setting dataset type info: {e}")
        return None

update(dataset_type_name=None, dataset_type_info=None)

Update the details of the dataset type.

Examples:

>>> dataset_type = DatasetType.get("example_dataset_type")
>>> updated_dataset_type = dataset_type.update(dataset_type_name="new_name", dataset_type_info{"description": "Updated description"})
>>> print(updated_dataset_type)
DatasetType(dataset_type_name='new_name', id=...)

Parameters:

Name Type Description Default
dataset_type_name str

The new name of the dataset type. Defaults to None.

 None
dataset_type_info dict

The new information. Defaults to None.

 None

Returns: Optional["DatasetType"]: The updated dataset type, or None if an error occurred.

Source code in gemini/api/dataset_type.py 
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
def update(
        self,
        dataset_type_name: str = None,
        dataset_type_info: dict = None
    ) -> Optional["DatasetType"]:
    """
    Update the details of the dataset type.

    Examples:
        >>> dataset_type = DatasetType.get("example_dataset_type")
        >>> updated_dataset_type = dataset_type.update(dataset_type_name="new_name", dataset_type_info{"description": "Updated description"})
        >>> print(updated_dataset_type)
        DatasetType(dataset_type_name='new_name', id=...)

    Args:
        dataset_type_name (str, optional): The new name of the dataset type. Defaults to None.
        dataset_type_info (dict, optional): The new information. Defaults to None.
    Returns:
        Optional["DatasetType"]: The updated dataset type, or None if an error occurred.
    """
    try:
        if not any([dataset_type_name, dataset_type_info]):
            logger.warning("At least one parameter must be provided for update.")
            return None

        current_id = self.id
        dataset_type = DatasetTypeModel.get(current_id)
        if not dataset_type:
             logger.warning(f"Dataset type with ID {current_id} does not exist.")
             return None

        dataset_type = DatasetTypeModel.update(
            dataset_type,
            dataset_type_name=dataset_type_name,
            dataset_type_info=dataset_type_info,
        )
        instance = self.model_validate(dataset_type)
        self.refresh()
        return instance
    except Exception as e:
        logger.error(f"Error updating dataset type: {e}")
        return None