Skip to content

Trait Levels API

Description

A trait level defines the level at which is a specific Trait is defined.

The following trait levels are pre-defined, along with their trait_level_id:

Trait Level ID
Default 0
Plot 1
Plant 2

Module

This module defines the TraitLevel class, which represents a level or category for traits.

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

This module includes the following methods:

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

TraitLevel

Bases: APIBase

Represents a level or category for traits.

Attributes:

Name Type Description
id Optional[ID]

The unique identifier of the trait level.
trait_level_name str

The name of the trait level.
trait_level_info Optional[dict]

Additional information about the trait level.
Source code in gemini/api/trait_level.py 
 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
379
class TraitLevel(APIBase):
    """
    Represents a level or category for traits.

    Attributes:
        id (Optional[ID]): The unique identifier of the trait level.
        trait_level_name (str): The name of the trait level.
        trait_level_info (Optional[dict]): Additional information about the trait level.
    """

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

    trait_level_name: str
    trait_level_info: Optional[dict] = None

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

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

    @classmethod
    def exists(
        cls,
        trait_level_name: str
    ) -> bool:
        """
        Check if a trait level with the given name exists.

        Examples:
            >>> TraitLevel.exists("example_trait_level")
            True

            >>> TraitLevel.exists("non_existent_trait_level")
            False

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

    @classmethod
    def create(
        cls,
        trait_level_name: str,
        trait_level_info: dict = None,
    ) -> Optional["TraitLevel"]:
        """
        Create a new trait level.

        Examples:
            >>> TraitLevel.create("example_trait_level", {"description": "An example trait level"})
            TraitLevel(trait_level_name='example_trait_level', id=UUID('...'))


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

    @classmethod
    def get(cls, trait_level_name: str) -> Optional["TraitLevel"]:
        """
        Retrieve a trait level by its name.

        Examples:
            >>> TraitLevel.get("example_trait_level")
            TraitLevel(trait_level_name='example_trait_level', id=UUID('...'))

        Args:
            trait_level_name (str): The name of the trait level.
        Returns:
            Optional[TraitLevel]: The trait level, or None if not found.
        """
        try:
            db_instance = TraitLevelModel.get_by_parameters(trait_level_name=trait_level_name)
            if not db_instance:
                logger.debug(f"Trait level with name {trait_level_name} not found.")
                return None
            instance = cls.model_validate(db_instance)
            return instance
        except Exception as e:
            logger.error(f"Error getting trait level: {e}")
            return None

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

        Examples:
            >>> TraitLevel.get_by_id(UUID('...'))
            TraitLevel(trait_level_name='example_trait_level', id=UUID('...'))

        Args:
            id (UUID | int | str): The ID of the trait level.
        Returns:
            Optional[TraitLevel]: The trait level, or None if not found.
        """
        try:
            db_instance = TraitLevelModel.get(id)
            if not db_instance:
                logger.warning(f"Trait level 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 trait level by ID: {e}")
            return None

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

        Examples:
            >>> TraitLevel.get_all()
            [TraitLevel(trait_level_name='example_trait_level', id=UUID('...')),
             TraitLevel(trait_level_name='another_trait_level', id=UUID('...'))]

        Returns:
            Optional[List[TraitLevel]]: List of all trait levels, or None if not found.
        """
        try:
            instances = TraitLevelModel.all(limit=limit, offset=offset)
            if not instances or len(instances) == 0:
                logger.info("No trait levels found.")
                return None
            instances = [cls.model_validate(instance) for instance in instances]
            return instances
        except Exception as e:
            logger.error(f"Error getting all trait levels: {e}")
            return None

    @classmethod
    def search(
        cls,
        trait_level_name: str = None,
        trait_level_info: dict = None
    ) -> Optional[List["TraitLevel"]]:
        """
        Search for trait levels based on various criteria.

        Examples:
            >>> TraitLevel.search(trait_level_name="example_trait_level")
            [TraitLevel(trait_level_name='example_trait_level', id=UUID('...'))]

        Args:
            trait_level_name (str, optional): The name of the trait level. Defaults to None.
            trait_level_info (dict, optional): Additional information. Defaults to None.
        Returns:
            Optional[List[TraitLevel]]: List of matching trait levels, or None if not found.
        """
        try:
            if not any([trait_level_name, trait_level_info]):
                logger.warning("At least one search parameter must be provided.")
                return None

            instances = TraitLevelModel.search(
                trait_level_name=trait_level_name,
                trait_level_info=trait_level_info
            )
            if not instances or len(instances) == 0:
                logger.info("No trait levels 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 trait levels: {e}")
            return None

    def update(
            self,
            trait_level_name: str = None,
            trait_level_info: dict = None
        ) -> Optional["TraitLevel"]:
        """
        Update the details of the trait level.

        Examples:
            >>> trait_level = TraitLevel.get("example_trait_level")
            >>> updated_trait_level = trait_level.update(trait_level_name="new_name", trait_level_info={"description": "Updated description"})
            >>> print(updated_trait_level)
            TraitLevel(trait_level_name='new_name', id=UUID('...'))

        Args:
            trait_level_name (str, optional): The new name. Defaults to None.
            trait_level_info (dict, optional): The new information. Defaults to None.
        Returns:
            Optional[TraitLevel]: The updated trait level, or None if an error occurred.
        """
        try:
            if not any([trait_level_name, trait_level_info]):
                logger.warning("At least one parameter must be provided for update.")
                return None

            current_id = self.id
            trait_level = TraitLevelModel.get(current_id)
            if not trait_level:
                 logger.warning(f"Trait level with ID {current_id} does not exist.")
                 return None

            trait_level = TraitLevelModel.update(
                trait_level,
                trait_level_name=trait_level_name,
                trait_level_info=trait_level_info,
            )
            instance = self.model_validate(trait_level)
            self.refresh()
            return instance
        except Exception as e:
            logger.error(f"Error updating trait level: {e}")
            return None

    def delete(self) -> bool:
        """
        Delete the trait level.

        Examples:
            >>> trait_level = TraitLevel.get("example_trait_level")
            >>> deleted = trait_level.delete()
            >>> print(deleted)
            True

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

    def refresh(self) -> Optional["TraitLevel"]:
        """
        Refresh the trait level's data from the database.

        Examples:
            >>> trait_level = TraitLevel.get("example_trait_level")
            >>> refreshed_trait_level = trait_level.refresh()
            >>> print(refreshed_trait_level)
            TraitLevel(trait_level_name='example_trait_level', id=UUID('...'))

        Returns:
            Optional[TraitLevel]: The refreshed trait level, or None if an error occurred.
        """
        try:
            db_instance = TraitLevelModel.get(self.id)
            if not db_instance:
                logger.warning(f"Trait level 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 trait level: {e}")
            return None

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

        Examples:
            >>> trait_level = TraitLevel.get("example_trait_level")
            >>> info = trait_level.get_info()
            >>> print(info)
            {'description': 'An example trait level'}

        Returns:
            Optional[dict]: The trait level's info, or None if not found.
        """
        try:
            current_id = self.id
            trait_level = TraitLevelModel.get(current_id)
            if not trait_level:
                logger.warning(f"Trait level with ID {current_id} does not exist.")
                return None
            trait_level_info = trait_level.trait_level_info
            if not trait_level_info:
                logger.info("TraitLevel info is empty.")
                return None
            return trait_level_info
        except Exception as e:
            logger.error(f"Error getting trait level info: {e}")
            return None

    def set_info(self, trait_level_info: dict) -> Optional["TraitLevel"]:
        """
        Set the additional information of the trait level.

        Examples:
            >>> trait_level = TraitLevel.get("example_trait_level")
            >>> updated_trait_level = trait_level.set_info({"description": "Updated description"})
            >>> print(updated_trait_level.get_info())
            {'description': 'Updated description'}

        Args:
            trait_level_info (dict): The new information to set.
        Returns:
            Optional[TraitLevel]: The updated trait level, or None if an error occurred.
        """
        try:
            current_id = self.id
            trait_level = TraitLevelModel.get(current_id)
            if not trait_level:
                logger.warning(f"Trait level with ID {current_id} does not exist.")
                return None
            trait_level = TraitLevelModel.update(
                trait_level,
                trait_level_info=trait_level_info,
            )
            instance = self.model_validate(trait_level)
            self.refresh()
            return instance
        except Exception as e:
            logger.error(f"Error setting trait level info: {e}")
            return None

__repr__()

Return a detailed string representation of the TraitLevel object.

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

__str__()

Return a string representation of the TraitLevel object.

Source code in gemini/api/trait_level.py 
49
50
51
def __str__(self):
    """Return a string representation of the TraitLevel object."""
    return f"TraitLevel(trait_level_name={self.trait_level_name}, id={self.id})"

create(trait_level_name, trait_level_info=None) classmethod

Create a new trait level.

Examples:

>>> TraitLevel.create("example_trait_level", {"description": "An example trait level"})
TraitLevel(trait_level_name='example_trait_level', id=UUID('...'))

Parameters:

Name Type Description Default
trait_level_name str

The name of the trait level.

 required
trait_level_info dict

Additional information about the trait level. Defaults to {{}}.

 None

Returns: Optional[TraitLevel]: The created trait level, or None if an error occurred.

Source code in gemini/api/trait_level.py 
 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
@classmethod
def create(
    cls,
    trait_level_name: str,
    trait_level_info: dict = None,
) -> Optional["TraitLevel"]:
    """
    Create a new trait level.

    Examples:
        >>> TraitLevel.create("example_trait_level", {"description": "An example trait level"})
        TraitLevel(trait_level_name='example_trait_level', id=UUID('...'))


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

delete()

Delete the trait level.

Examples:

>>> trait_level = TraitLevel.get("example_trait_level")
>>> deleted = trait_level.delete()
>>> print(deleted)
True

Returns:

Name Type Description
bool bool

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

    Examples:
        >>> trait_level = TraitLevel.get("example_trait_level")
        >>> deleted = trait_level.delete()
        >>> print(deleted)
        True

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

exists(trait_level_name) classmethod

Check if a trait level with the given name exists.

Examples:

>>> TraitLevel.exists("example_trait_level")
True

>>> TraitLevel.exists("non_existent_trait_level")
False

Parameters:

Name Type Description Default
trait_level_name str

The name of the trait level.

 required

Returns: bool: True if the trait level exists, False otherwise.

Source code in gemini/api/trait_level.py 
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
@classmethod
def exists(
    cls,
    trait_level_name: str
) -> bool:
    """
    Check if a trait level with the given name exists.

    Examples:
        >>> TraitLevel.exists("example_trait_level")
        True

        >>> TraitLevel.exists("non_existent_trait_level")
        False

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

get(trait_level_name) classmethod

Retrieve a trait level by its name.

Examples:

>>> TraitLevel.get("example_trait_level")
TraitLevel(trait_level_name='example_trait_level', id=UUID('...'))

Parameters:

Name Type Description Default
trait_level_name str

The name of the trait level.

 required

Returns: Optional[TraitLevel]: The trait level, or None if not found.

Source code in gemini/api/trait_level.py 
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
@classmethod
def get(cls, trait_level_name: str) -> Optional["TraitLevel"]:
    """
    Retrieve a trait level by its name.

    Examples:
        >>> TraitLevel.get("example_trait_level")
        TraitLevel(trait_level_name='example_trait_level', id=UUID('...'))

    Args:
        trait_level_name (str): The name of the trait level.
    Returns:
        Optional[TraitLevel]: The trait level, or None if not found.
    """
    try:
        db_instance = TraitLevelModel.get_by_parameters(trait_level_name=trait_level_name)
        if not db_instance:
            logger.debug(f"Trait level with name {trait_level_name} not found.")
            return None
        instance = cls.model_validate(db_instance)
        return instance
    except Exception as e:
        logger.error(f"Error getting trait level: {e}")
        return None

get_all(limit=None, offset=None) classmethod

Retrieve all trait levels.

Examples:

>>> TraitLevel.get_all()
[TraitLevel(trait_level_name='example_trait_level', id=UUID('...')),
 TraitLevel(trait_level_name='another_trait_level', id=UUID('...'))]

Returns:

Type Description
Optional[List[TraitLevel]]

Optional[List[TraitLevel]]: List of all trait levels, or None if not found.
Source code in gemini/api/trait_level.py 
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
@classmethod
def get_all(cls, limit: int = None, offset: int = None) -> Optional[List["TraitLevel"]]:
    """
    Retrieve all trait levels.

    Examples:
        >>> TraitLevel.get_all()
        [TraitLevel(trait_level_name='example_trait_level', id=UUID('...')),
         TraitLevel(trait_level_name='another_trait_level', id=UUID('...'))]

    Returns:
        Optional[List[TraitLevel]]: List of all trait levels, or None if not found.
    """
    try:
        instances = TraitLevelModel.all(limit=limit, offset=offset)
        if not instances or len(instances) == 0:
            logger.info("No trait levels found.")
            return None
        instances = [cls.model_validate(instance) for instance in instances]
        return instances
    except Exception as e:
        logger.error(f"Error getting all trait levels: {e}")
        return None

get_by_id(id) classmethod

Retrieve a trait level by its ID.

Examples:

>>> TraitLevel.get_by_id(UUID('...'))
TraitLevel(trait_level_name='example_trait_level', id=UUID('...'))

Parameters:

Name Type Description Default
id UUID | int | str

The ID of the trait level.

 required

Returns: Optional[TraitLevel]: The trait level, or None if not found.

Source code in gemini/api/trait_level.py 
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
@classmethod
def get_by_id(cls, id: UUID | int | str) -> Optional["TraitLevel"]:
    """
    Retrieve a trait level by its ID.

    Examples:
        >>> TraitLevel.get_by_id(UUID('...'))
        TraitLevel(trait_level_name='example_trait_level', id=UUID('...'))

    Args:
        id (UUID | int | str): The ID of the trait level.
    Returns:
        Optional[TraitLevel]: The trait level, or None if not found.
    """
    try:
        db_instance = TraitLevelModel.get(id)
        if not db_instance:
            logger.warning(f"Trait level 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 trait level by ID: {e}")
        return None

get_info()

Get the additional information of the trait level.

Examples:

>>> trait_level = TraitLevel.get("example_trait_level")
>>> info = trait_level.get_info()
>>> print(info)
{'description': 'An example trait level'}

Returns:

Type Description
Optional[dict]

Optional[dict]: The trait level's info, or None if not found.
Source code in gemini/api/trait_level.py 
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
def get_info(self) -> Optional[dict]:
    """
    Get the additional information of the trait level.

    Examples:
        >>> trait_level = TraitLevel.get("example_trait_level")
        >>> info = trait_level.get_info()
        >>> print(info)
        {'description': 'An example trait level'}

    Returns:
        Optional[dict]: The trait level's info, or None if not found.
    """
    try:
        current_id = self.id
        trait_level = TraitLevelModel.get(current_id)
        if not trait_level:
            logger.warning(f"Trait level with ID {current_id} does not exist.")
            return None
        trait_level_info = trait_level.trait_level_info
        if not trait_level_info:
            logger.info("TraitLevel info is empty.")
            return None
        return trait_level_info
    except Exception as e:
        logger.error(f"Error getting trait level info: {e}")
        return None

refresh()

Refresh the trait level's data from the database.

Examples:

>>> trait_level = TraitLevel.get("example_trait_level")
>>> refreshed_trait_level = trait_level.refresh()
>>> print(refreshed_trait_level)
TraitLevel(trait_level_name='example_trait_level', id=UUID('...'))

Returns:

Type Description
Optional[TraitLevel]

Optional[TraitLevel]: The refreshed trait level, or None if an error occurred.
Source code in gemini/api/trait_level.py 
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
def refresh(self) -> Optional["TraitLevel"]:
    """
    Refresh the trait level's data from the database.

    Examples:
        >>> trait_level = TraitLevel.get("example_trait_level")
        >>> refreshed_trait_level = trait_level.refresh()
        >>> print(refreshed_trait_level)
        TraitLevel(trait_level_name='example_trait_level', id=UUID('...'))

    Returns:
        Optional[TraitLevel]: The refreshed trait level, or None if an error occurred.
    """
    try:
        db_instance = TraitLevelModel.get(self.id)
        if not db_instance:
            logger.warning(f"Trait level 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 trait level: {e}")
        return None

search(trait_level_name=None, trait_level_info=None) classmethod

Search for trait levels based on various criteria.

Examples:

>>> TraitLevel.search(trait_level_name="example_trait_level")
[TraitLevel(trait_level_name='example_trait_level', id=UUID('...'))]

Parameters:

Name Type Description Default
trait_level_name str

The name of the trait level. Defaults to None.

 None
trait_level_info dict

Additional information. Defaults to None.

 None

Returns: Optional[List[TraitLevel]]: List of matching trait levels, or None if not found.

Source code in gemini/api/trait_level.py 
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
@classmethod
def search(
    cls,
    trait_level_name: str = None,
    trait_level_info: dict = None
) -> Optional[List["TraitLevel"]]:
    """
    Search for trait levels based on various criteria.

    Examples:
        >>> TraitLevel.search(trait_level_name="example_trait_level")
        [TraitLevel(trait_level_name='example_trait_level', id=UUID('...'))]

    Args:
        trait_level_name (str, optional): The name of the trait level. Defaults to None.
        trait_level_info (dict, optional): Additional information. Defaults to None.
    Returns:
        Optional[List[TraitLevel]]: List of matching trait levels, or None if not found.
    """
    try:
        if not any([trait_level_name, trait_level_info]):
            logger.warning("At least one search parameter must be provided.")
            return None

        instances = TraitLevelModel.search(
            trait_level_name=trait_level_name,
            trait_level_info=trait_level_info
        )
        if not instances or len(instances) == 0:
            logger.info("No trait levels 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 trait levels: {e}")
        return None

set_info(trait_level_info)

Set the additional information of the trait level.

Examples:

>>> trait_level = TraitLevel.get("example_trait_level")
>>> updated_trait_level = trait_level.set_info({"description": "Updated description"})
>>> print(updated_trait_level.get_info())
{'description': 'Updated description'}

Parameters:

Name Type Description Default
trait_level_info dict

The new information to set.

 required

Returns: Optional[TraitLevel]: The updated trait level, or None if an error occurred.

Source code in gemini/api/trait_level.py 
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
379
def set_info(self, trait_level_info: dict) -> Optional["TraitLevel"]:
    """
    Set the additional information of the trait level.

    Examples:
        >>> trait_level = TraitLevel.get("example_trait_level")
        >>> updated_trait_level = trait_level.set_info({"description": "Updated description"})
        >>> print(updated_trait_level.get_info())
        {'description': 'Updated description'}

    Args:
        trait_level_info (dict): The new information to set.
    Returns:
        Optional[TraitLevel]: The updated trait level, or None if an error occurred.
    """
    try:
        current_id = self.id
        trait_level = TraitLevelModel.get(current_id)
        if not trait_level:
            logger.warning(f"Trait level with ID {current_id} does not exist.")
            return None
        trait_level = TraitLevelModel.update(
            trait_level,
            trait_level_info=trait_level_info,
        )
        instance = self.model_validate(trait_level)
        self.refresh()
        return instance
    except Exception as e:
        logger.error(f"Error setting trait level info: {e}")
        return None

update(trait_level_name=None, trait_level_info=None)

Update the details of the trait level.

Examples:

>>> trait_level = TraitLevel.get("example_trait_level")
>>> updated_trait_level = trait_level.update(trait_level_name="new_name", trait_level_info={"description": "Updated description"})
>>> print(updated_trait_level)
TraitLevel(trait_level_name='new_name', id=UUID('...'))

Parameters:

Name Type Description Default
trait_level_name str

The new name. Defaults to None.

 None
trait_level_info dict

The new information. Defaults to None.

 None

Returns: Optional[TraitLevel]: The updated trait level, or None if an error occurred.

Source code in gemini/api/trait_level.py 
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
def update(
        self,
        trait_level_name: str = None,
        trait_level_info: dict = None
    ) -> Optional["TraitLevel"]:
    """
    Update the details of the trait level.

    Examples:
        >>> trait_level = TraitLevel.get("example_trait_level")
        >>> updated_trait_level = trait_level.update(trait_level_name="new_name", trait_level_info={"description": "Updated description"})
        >>> print(updated_trait_level)
        TraitLevel(trait_level_name='new_name', id=UUID('...'))

    Args:
        trait_level_name (str, optional): The new name. Defaults to None.
        trait_level_info (dict, optional): The new information. Defaults to None.
    Returns:
        Optional[TraitLevel]: The updated trait level, or None if an error occurred.
    """
    try:
        if not any([trait_level_name, trait_level_info]):
            logger.warning("At least one parameter must be provided for update.")
            return None

        current_id = self.id
        trait_level = TraitLevelModel.get(current_id)
        if not trait_level:
             logger.warning(f"Trait level with ID {current_id} does not exist.")
             return None

        trait_level = TraitLevelModel.update(
            trait_level,
            trait_level_name=trait_level_name,
            trait_level_info=trait_level_info,
        )
        instance = self.model_validate(trait_level)
        self.refresh()
        return instance
    except Exception as e:
        logger.error(f"Error updating trait level: {e}")
        return None