rapidata 2.36.0__py3-none-any.whl → 2.36.2__py3-none-any.whl

rapidata/api_client/models/__init__.py

@@ -21,7 +21,6 @@ from rapidata.api_client.models.add_validation_rapid_model import AddValidationR
 from rapidata.api_client.models.add_validation_rapid_model_payload import AddValidationRapidModelPayload
 from rapidata.api_client.models.add_validation_rapid_model_truth import AddValidationRapidModelTruth
 from rapidata.api_client.models.add_validation_rapid_result import AddValidationRapidResult
-from rapidata.api_client.models.add_validation_text_rapid_model import AddValidationTextRapidModel
 from rapidata.api_client.models.age_group import AgeGroup
 from rapidata.api_client.models.age_user_filter_model import AgeUserFilterModel
 from rapidata.api_client.models.aggregator_type import AggregatorType
@@ -183,6 +182,7 @@ from rapidata.api_client.models.get_pipeline_by_id_result_artifacts_value import
 from rapidata.api_client.models.get_public_orders_result import GetPublicOrdersResult
 from rapidata.api_client.models.get_public_responses_result import GetPublicResponsesResult
 from rapidata.api_client.models.get_rapid_responses_result import GetRapidResponsesResult
+from rapidata.api_client.models.get_recommended_validation_set_result import GetRecommendedValidationSetResult
 from rapidata.api_client.models.get_responses_result import GetResponsesResult
 from rapidata.api_client.models.get_sample_by_id_result import GetSampleByIdResult
 from rapidata.api_client.models.get_simple_workflow_results_model import GetSimpleWorkflowResultsModel
@@ -228,7 +228,6 @@ from rapidata.api_client.models.location_metadata import LocationMetadata
 from rapidata.api_client.models.location_metadata_exists_filter_config import LocationMetadataExistsFilterConfig
 from rapidata.api_client.models.location_metadata_model import LocationMetadataModel
 from rapidata.api_client.models.logic_operator import LogicOperator
-from rapidata.api_client.models.metadata_visibilities import MetadataVisibilities
 from rapidata.api_client.models.multi_asset import MultiAsset
 from rapidata.api_client.models.multi_asset_input import MultiAssetInput
 from rapidata.api_client.models.multi_asset_input1 import MultiAssetInput1
@@ -285,6 +284,7 @@ from rapidata.api_client.models.preview_order_model import PreviewOrderModel
 from rapidata.api_client.models.private_text_metadata_input import PrivateTextMetadataInput
 from rapidata.api_client.models.probabilistic_attach_category_referee_config import ProbabilisticAttachCategoryRefereeConfig
 from rapidata.api_client.models.probabilistic_attach_category_referee_info import ProbabilisticAttachCategoryRefereeInfo
+from rapidata.api_client.models.problem_details import ProblemDetails
 from rapidata.api_client.models.prompt_asset_metadata_input import PromptAssetMetadataInput
 from rapidata.api_client.models.prompt_asset_metadata_input_asset import PromptAssetMetadataInputAsset
 from rapidata.api_client.models.prompt_by_benchmark_result import PromptByBenchmarkResult
@@ -378,6 +378,7 @@ from rapidata.api_client.models.unlock_order_result import UnlockOrderResult
 from rapidata.api_client.models.update_benchmark_name_model import UpdateBenchmarkNameModel
 from rapidata.api_client.models.update_dataset_name_model import UpdateDatasetNameModel
 from rapidata.api_client.models.update_dimensions_model import UpdateDimensionsModel
+from rapidata.api_client.models.update_leaderboard_model import UpdateLeaderboardModel
 from rapidata.api_client.models.update_leaderboard_name_model import UpdateLeaderboardNameModel
 from rapidata.api_client.models.update_leaderboard_response_config_model import UpdateLeaderboardResponseConfigModel
 from rapidata.api_client.models.update_order_name_model import UpdateOrderNameModel

rapidata/api_client/models/add_validation_rapid_model.py

@@ -22,6 +22,7 @@ from typing import Any, ClassVar, Dict, List, Optional, Union
 from rapidata.api_client.models.add_validation_rapid_model_payload import AddValidationRapidModelPayload
 from rapidata.api_client.models.add_validation_rapid_model_truth import AddValidationRapidModelTruth
 from rapidata.api_client.models.dataset_dataset_id_datapoints_post_request_metadata_inner import DatasetDatasetIdDatapointsPostRequestMetadataInner
+from rapidata.api_client.models.feature_flag_model import FeatureFlagModel
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -30,11 +31,12 @@ class AddValidationRapidModel(BaseModel):
     The model for adding a validation rapid.
     """ # noqa: E501
     payload: AddValidationRapidModelPayload
-    metadata: List[DatasetDatasetIdDatapointsPostRequestMetadataInner] = Field(description="Some metadata to attach to the rapid.")
-    truth: AddValidationRapidModelTruth
+    metadata: Optional[List[DatasetDatasetIdDatapointsPostRequestMetadataInner]] = Field(default=None, description="Some metadata to attach to the rapid.")
+    truth: Optional[AddValidationRapidModelTruth] = None
     random_correct_probability: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The probability for an answer to be correct when randomly guessing.", alias="randomCorrectProbability")
     explanation: Optional[StrictStr] = Field(default=None, description="An explanation for the users if they answer the rapid incorrectly.")
-    __properties: ClassVar[List[str]] = ["payload", "metadata", "truth", "randomCorrectProbability", "explanation"]
+    feature_flags: Optional[List[FeatureFlagModel]] = Field(default=None, description="The feature flags to enable for the rapid.", alias="featureFlags")
+    __properties: ClassVar[List[str]] = ["payload", "metadata", "truth", "randomCorrectProbability", "explanation", "featureFlags"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -88,6 +90,23 @@ class AddValidationRapidModel(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of truth
         if self.truth:
             _dict['truth'] = self.truth.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in feature_flags (list)
+        _items = []
+        if self.feature_flags:
+            for _item_feature_flags in self.feature_flags:
+                if _item_feature_flags:
+                    _items.append(_item_feature_flags.to_dict())
+            _dict['featureFlags'] = _items
+        # set to None if metadata (nullable) is None
+        # and model_fields_set contains the field
+        if self.metadata is None and "metadata" in self.model_fields_set:
+            _dict['metadata'] = None
+
+        # set to None if truth (nullable) is None
+        # and model_fields_set contains the field
+        if self.truth is None and "truth" in self.model_fields_set:
+            _dict['truth'] = None
+
         # set to None if random_correct_probability (nullable) is None
         # and model_fields_set contains the field
         if self.random_correct_probability is None and "random_correct_probability" in self.model_fields_set:
@@ -98,6 +117,11 @@ class AddValidationRapidModel(BaseModel):
         if self.explanation is None and "explanation" in self.model_fields_set:
             _dict['explanation'] = None
 
+        # set to None if feature_flags (nullable) is None
+        # and model_fields_set contains the field
+        if self.feature_flags is None and "feature_flags" in self.model_fields_set:
+            _dict['featureFlags'] = None
+
         return _dict
 
     @classmethod
@@ -114,7 +138,8 @@ class AddValidationRapidModel(BaseModel):
             "metadata": [DatasetDatasetIdDatapointsPostRequestMetadataInner.from_dict(_item) for _item in obj["metadata"]] if obj.get("metadata") is not None else None,
             "truth": AddValidationRapidModelTruth.from_dict(obj["truth"]) if obj.get("truth") is not None else None,
             "randomCorrectProbability": obj.get("randomCorrectProbability"),
-            "explanation": obj.get("explanation")
+            "explanation": obj.get("explanation"),
+            "featureFlags": [FeatureFlagModel.from_dict(_item) for _item in obj["featureFlags"]] if obj.get("featureFlags") is not None else None
         })
         return _obj
 

rapidata/api_client/models/add_validation_rapid_model_truth.py

@@ -87,6 +87,9 @@ class AddValidationRapidModelTruth(BaseModel):
 
     @field_validator('actual_instance')
     def actual_instance_must_validate_oneof(cls, v):
+        if v is None:
+            return v
+
         instance = AddValidationRapidModelTruth.model_construct()
         error_messages = []
         match = 0
@@ -164,9 +167,12 @@ class AddValidationRapidModelTruth(BaseModel):
         return cls.from_json(json.dumps(obj))
 
     @classmethod
-    def from_json(cls, json_str: str) -> Self:
+    def from_json(cls, json_str: Optional[str]) -> Self:
         """Returns the object represented by the json string"""
         instance = cls.model_construct()
+        if json_str is None:
+            return instance
+
         error_messages = []
         match = 0
 

rapidata/api_client/models/asset_metadata.py

@@ -28,7 +28,7 @@ class AssetMetadata(BaseModel):
     """ # noqa: E501
     t: StrictStr = Field(description="Discriminator value for AssetMetadata", alias="_t")
     asset: AssetMetadataAsset
-    visibilities: StrictStr
+    visibilities: List[StrictStr]
     __properties: ClassVar[List[str]] = ["_t", "asset", "visibilities"]
 
     @field_validator('t')
@@ -38,6 +38,14 @@ class AssetMetadata(BaseModel):
             raise ValueError("must be one of enum values ('AssetMetadata')")
         return value
 
+    @field_validator('visibilities')
+    def visibilities_validate_enum(cls, value):
+        """Validates the enum"""
+        for i in value:
+            if i not in set(['None', 'Users', 'Customers', 'Admins', 'Dashboard', 'All']):
+                raise ValueError("each list item must be one of ('None', 'Users', 'Customers', 'Admins', 'Dashboard', 'All')")
+        return value
+
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,

rapidata/api_client/models/asset_type.py

@@ -0,0 +1,40 @@
+# coding: utf-8
+
+"""
+    Rapidata.Dataset
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: v1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import json
+from enum import Enum
+from typing_extensions import Self
+
+
+class AssetType(str, Enum):
+    """
+    AssetType
+    """
+
+    """
+    allowed enum values
+    """
+    NONE = 'None'
+    IMAGE = 'Image'
+    VIDEO = 'Video'
+    AUDIO = 'Audio'
+    TEXT = 'Text'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of AssetType from a JSON string"""
+        return cls(json.loads(json_str))
+
+

rapidata/api_client/models/boost_query_result.py

@@ -17,8 +17,10 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
 from typing import Any, ClassVar, Dict, List
+from rapidata.api_client.models.boost_mode import BoostMode
+from rapidata.api_client.models.boost_status import BoostStatus
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -26,27 +28,13 @@ class BoostQueryResult(BaseModel):
     """
     BoostQueryResult
     """ # noqa: E501
-    status: StrictStr
-    mode: StrictStr
+    status: BoostStatus
+    mode: BoostMode
     active_campaigns: List[StrictStr] = Field(alias="activeCampaigns")
     inactive_campaigns: List[StrictStr] = Field(alias="inactiveCampaigns")
     unknown_campaigns: List[StrictInt] = Field(alias="unknownCampaigns")
     __properties: ClassVar[List[str]] = ["status", "mode", "activeCampaigns", "inactiveCampaigns", "unknownCampaigns"]
 
-    @field_validator('status')
-    def status_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in set(['Active', 'Inactive', 'Partial', 'Unknown']):
-            raise ValueError("must be one of enum values ('Active', 'Inactive', 'Partial', 'Unknown')")
-        return value
-
-    @field_validator('mode')
-    def mode_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in set(['Automatic', 'Manual']):
-            raise ValueError("must be one of enum values ('Automatic', 'Manual')")
-        return value
-
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,

rapidata/api_client/models/campaign_query_result.py

@@ -18,8 +18,9 @@ import re  # noqa: F401
 import json
 
 from datetime import datetime
-from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr, field_validator
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
 from typing import Any, ClassVar, Dict, List
+from rapidata.api_client.models.campaign_status import CampaignStatus
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -30,18 +31,11 @@ class CampaignQueryResult(BaseModel):
     id: StrictStr
     owner_mail: StrictStr = Field(alias="ownerMail")
     name: StrictStr
-    status: StrictStr
+    status: CampaignStatus
     priority: StrictInt
     created_at: datetime = Field(alias="createdAt")
     __properties: ClassVar[List[str]] = ["id", "ownerMail", "name", "status", "priority", "createdAt"]
 
-    @field_validator('status')
-    def status_validate_enum(cls, value):
-        """Validates the enum"""
-        if value not in set(['Created', 'Preview', 'Active', 'Analysis', 'Paused', 'Completed']):
-            raise ValueError("must be one of enum values ('Created', 'Preview', 'Active', 'Analysis', 'Paused', 'Completed')")
-        return value
-
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,

rapidata/api_client/models/classification_metadata.py

@@ -28,7 +28,7 @@ class ClassificationMetadata(BaseModel):
     """ # noqa: E501
     t: StrictStr = Field(description="Discriminator value for ClassificationMetadata", alias="_t")
     classification: StrictStr
-    visibilities: Optional[StrictStr] = None
+    visibilities: Optional[List[StrictStr]] = None
     __properties: ClassVar[List[str]] = ["_t", "classification", "visibilities"]
 
     @field_validator('t')
@@ -38,6 +38,17 @@ class ClassificationMetadata(BaseModel):
             raise ValueError("must be one of enum values ('ClassificationMetadata')")
         return value
 
+    @field_validator('visibilities')
+    def visibilities_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        for i in value:
+            if i not in set(['None', 'Users', 'Customers', 'Admins', 'Dashboard', 'All']):
+                raise ValueError("each list item must be one of ('None', 'Users', 'Customers', 'Admins', 'Dashboard', 'All')")
+        return value
+
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,

rapidata/api_client/models/compare_workflow_config.py

@@ -23,6 +23,7 @@ from rapidata.api_client.models.compare_workflow_config_metadata_value import Co
 from rapidata.api_client.models.compare_workflow_config_pair_maker_config import CompareWorkflowConfigPairMakerConfig
 from rapidata.api_client.models.compare_workflow_model1_referee import CompareWorkflowModel1Referee
 from rapidata.api_client.models.elo_config import EloConfig
+from rapidata.api_client.models.feature_flag import FeatureFlag
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -32,12 +33,13 @@ class CompareWorkflowConfig(BaseModel):
     """ # noqa: E501
     t: StrictStr = Field(description="Discriminator value for CompareWorkflowConfig", alias="_t")
     criteria: StrictStr
-    elo_config: Optional[EloConfig] = Field(default=None, alias="eloConfig")
-    pair_maker_config: Optional[CompareWorkflowConfigPairMakerConfig] = Field(default=None, alias="pairMakerConfig")
     referee: CompareWorkflowModel1Referee
     target_country_codes: List[StrictStr] = Field(alias="targetCountryCodes")
     metadata: Dict[str, CompareWorkflowConfigMetadataValue]
-    __properties: ClassVar[List[str]] = ["_t", "criteria", "eloConfig", "pairMakerConfig", "referee", "targetCountryCodes", "metadata"]
+    elo_config: Optional[EloConfig] = Field(default=None, alias="eloConfig")
+    pair_maker_config: Optional[CompareWorkflowConfigPairMakerConfig] = Field(default=None, alias="pairMakerConfig")
+    feature_flags: Optional[List[FeatureFlag]] = Field(default=None, alias="featureFlags")
+    __properties: ClassVar[List[str]] = ["_t", "criteria", "referee", "targetCountryCodes", "metadata", "eloConfig", "pairMakerConfig", "featureFlags"]
 
     @field_validator('t')
     def t_validate_enum(cls, value):
@@ -85,12 +87,6 @@ class CompareWorkflowConfig(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of elo_config
-        if self.elo_config:
-            _dict['eloConfig'] = self.elo_config.to_dict()
-        # override the default output from pydantic by calling `to_dict()` of pair_maker_config
-        if self.pair_maker_config:
-            _dict['pairMakerConfig'] = self.pair_maker_config.to_dict()
         # override the default output from pydantic by calling `to_dict()` of referee
         if self.referee:
             _dict['referee'] = self.referee.to_dict()
@@ -101,6 +97,19 @@ class CompareWorkflowConfig(BaseModel):
                 if self.metadata[_key_metadata]:
                     _field_dict[_key_metadata] = self.metadata[_key_metadata].to_dict()
             _dict['metadata'] = _field_dict
+        # override the default output from pydantic by calling `to_dict()` of elo_config
+        if self.elo_config:
+            _dict['eloConfig'] = self.elo_config.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of pair_maker_config
+        if self.pair_maker_config:
+            _dict['pairMakerConfig'] = self.pair_maker_config.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in feature_flags (list)
+        _items = []
+        if self.feature_flags:
+            for _item_feature_flags in self.feature_flags:
+                if _item_feature_flags:
+                    _items.append(_item_feature_flags.to_dict())
+            _dict['featureFlags'] = _items
         return _dict
 
     @classmethod
@@ -115,8 +124,6 @@ class CompareWorkflowConfig(BaseModel):
         _obj = cls.model_validate({
             "_t": obj.get("_t") if obj.get("_t") is not None else 'CompareWorkflowConfig',
             "criteria": obj.get("criteria"),
-            "eloConfig": EloConfig.from_dict(obj["eloConfig"]) if obj.get("eloConfig") is not None else None,
-            "pairMakerConfig": CompareWorkflowConfigPairMakerConfig.from_dict(obj["pairMakerConfig"]) if obj.get("pairMakerConfig") is not None else None,
             "referee": CompareWorkflowModel1Referee.from_dict(obj["referee"]) if obj.get("referee") is not None else None,
             "targetCountryCodes": obj.get("targetCountryCodes"),
             "metadata": dict(
@@ -124,7 +131,10 @@ class CompareWorkflowConfig(BaseModel):
                 for _k, _v in obj["metadata"].items()
             )
             if obj.get("metadata") is not None
-            else None
+            else None,
+            "eloConfig": EloConfig.from_dict(obj["eloConfig"]) if obj.get("eloConfig") is not None else None,
+            "pairMakerConfig": CompareWorkflowConfigPairMakerConfig.from_dict(obj["pairMakerConfig"]) if obj.get("pairMakerConfig") is not None else None,
+            "featureFlags": [FeatureFlag.from_dict(_item) for _item in obj["featureFlags"]] if obj.get("featureFlags") is not None else None
         })
         return _obj
 

rapidata/api_client/models/compare_workflow_config_model.py

@@ -23,6 +23,7 @@ from rapidata.api_client.models.compare_workflow_config_metadata_value import Co
 from rapidata.api_client.models.compare_workflow_config_model_pair_maker_config import CompareWorkflowConfigModelPairMakerConfig
 from rapidata.api_client.models.compare_workflow_model1_referee import CompareWorkflowModel1Referee
 from rapidata.api_client.models.elo_config import EloConfig
+from rapidata.api_client.models.feature_flag import FeatureFlag
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -37,7 +38,8 @@ class CompareWorkflowConfigModel(BaseModel):
     target_country_codes: List[StrictStr] = Field(description="A list of country codes that this workflow is targeting.", alias="targetCountryCodes")
     elo_config: Optional[EloConfig] = Field(default=None, alias="eloConfig")
     metadata: Dict[str, CompareWorkflowConfigMetadataValue] = Field(description="The metadata is attached to every single rapid and can be used for something like the prompt.")
-    __properties: ClassVar[List[str]] = ["_t", "criteria", "pairMakerConfig", "referee", "targetCountryCodes", "eloConfig", "metadata"]
+    feature_flags: List[FeatureFlag] = Field(description="The list of feature flags that will be applied to the rapids created by this workflow.", alias="featureFlags")
+    __properties: ClassVar[List[str]] = ["_t", "criteria", "pairMakerConfig", "referee", "targetCountryCodes", "eloConfig", "metadata", "featureFlags"]
 
     @field_validator('t')
     def t_validate_enum(cls, value):
@@ -101,6 +103,13 @@ class CompareWorkflowConfigModel(BaseModel):
                 if self.metadata[_key_metadata]:
                     _field_dict[_key_metadata] = self.metadata[_key_metadata].to_dict()
             _dict['metadata'] = _field_dict
+        # override the default output from pydantic by calling `to_dict()` of each item in feature_flags (list)
+        _items = []
+        if self.feature_flags:
+            for _item_feature_flags in self.feature_flags:
+                if _item_feature_flags:
+                    _items.append(_item_feature_flags.to_dict())
+            _dict['featureFlags'] = _items
         return _dict
 
     @classmethod
@@ -124,7 +133,8 @@ class CompareWorkflowConfigModel(BaseModel):
                 for _k, _v in obj["metadata"].items()
             )
             if obj.get("metadata") is not None
-            else None
+            else None,
+            "featureFlags": [FeatureFlag.from_dict(_item) for _item in obj["featureFlags"]] if obj.get("featureFlags") is not None else None
         })
         return _obj
 

rapidata/api_client/models/compare_workflow_model.py

@@ -22,6 +22,7 @@ from typing import Any, ClassVar, Dict, List, Optional
 from rapidata.api_client.models.compare_workflow_model_pair_maker_config import CompareWorkflowModelPairMakerConfig
 from rapidata.api_client.models.dataset_dataset_id_datapoints_post_request_metadata_inner import DatasetDatasetIdDatapointsPostRequestMetadataInner
 from rapidata.api_client.models.elo_config_model import EloConfigModel
+from rapidata.api_client.models.feature_flag import FeatureFlag
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -34,7 +35,8 @@ class CompareWorkflowModel(BaseModel):
     pair_maker_config: Optional[CompareWorkflowModelPairMakerConfig] = Field(default=None, alias="pairMakerConfig")
     elo_config: Optional[EloConfigModel] = Field(default=None, alias="eloConfig")
     metadata: Optional[List[DatasetDatasetIdDatapointsPostRequestMetadataInner]] = Field(default=None, description="The metadata is attached to every single rapid and can be used for something like the prompt.")
-    __properties: ClassVar[List[str]] = ["_t", "criteria", "pairMakerConfig", "eloConfig", "metadata"]
+    feature_flags: Optional[List[FeatureFlag]] = Field(default=None, description="The list of feature flags that will be applied to the rapids created by this workflow.", alias="featureFlags")
+    __properties: ClassVar[List[str]] = ["_t", "criteria", "pairMakerConfig", "eloConfig", "metadata", "featureFlags"]
 
     @field_validator('t')
     def t_validate_enum(cls, value):
@@ -95,6 +97,13 @@ class CompareWorkflowModel(BaseModel):
                 if _item_metadata:
                     _items.append(_item_metadata.to_dict())
             _dict['metadata'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in feature_flags (list)
+        _items = []
+        if self.feature_flags:
+            for _item_feature_flags in self.feature_flags:
+                if _item_feature_flags:
+                    _items.append(_item_feature_flags.to_dict())
+            _dict['featureFlags'] = _items
         # set to None if metadata (nullable) is None
         # and model_fields_set contains the field
         if self.metadata is None and "metadata" in self.model_fields_set:
@@ -116,7 +125,8 @@ class CompareWorkflowModel(BaseModel):
             "criteria": obj.get("criteria"),
             "pairMakerConfig": CompareWorkflowModelPairMakerConfig.from_dict(obj["pairMakerConfig"]) if obj.get("pairMakerConfig") is not None else None,
             "eloConfig": EloConfigModel.from_dict(obj["eloConfig"]) if obj.get("eloConfig") is not None else None,
-            "metadata": [DatasetDatasetIdDatapointsPostRequestMetadataInner.from_dict(_item) for _item in obj["metadata"]] if obj.get("metadata") is not None else None
+            "metadata": [DatasetDatasetIdDatapointsPostRequestMetadataInner.from_dict(_item) for _item in obj["metadata"]] if obj.get("metadata") is not None else None,
+            "featureFlags": [FeatureFlag.from_dict(_item) for _item in obj["featureFlags"]] if obj.get("featureFlags") is not None else None
         })
         return _obj
 

rapidata/api_client/models/count_metadata.py

@@ -28,7 +28,7 @@ class CountMetadata(BaseModel):
     """ # noqa: E501
     t: StrictStr = Field(description="Discriminator value for CountMetadata", alias="_t")
     count: StrictInt
-    visibilities: Optional[StrictStr] = None
+    visibilities: Optional[List[StrictStr]] = None
     __properties: ClassVar[List[str]] = ["_t", "count", "visibilities"]
 
     @field_validator('t')
@@ -38,6 +38,17 @@ class CountMetadata(BaseModel):
             raise ValueError("must be one of enum values ('CountMetadata')")
         return value
 
+    @field_validator('visibilities')
+    def visibilities_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        for i in value:
+            if i not in set(['None', 'Users', 'Customers', 'Admins', 'Dashboard', 'All']):
+                raise ValueError("each list item must be one of ('None', 'Users', 'Customers', 'Admins', 'Dashboard', 'All')")
+        return value
+
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,

rapidata/api_client/models/create_demographic_rapid_model.py

@@ -18,8 +18,9 @@ import re  # noqa: F401
 import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictStr
-from typing import Any, ClassVar, Dict, List
+from typing import Any, ClassVar, Dict, List, Optional
 from rapidata.api_client.models.classify_payload import ClassifyPayload
+from rapidata.api_client.models.feature_flag import FeatureFlag
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -29,7 +30,8 @@ class CreateDemographicRapidModel(BaseModel):
     """ # noqa: E501
     key: StrictStr = Field(description="The identifier of the demographic classification.")
     payload: ClassifyPayload
-    __properties: ClassVar[List[str]] = ["key", "payload"]
+    feature_flags: Optional[List[FeatureFlag]] = Field(default=None, description="Optional feature flags to apply to the rapid.", alias="featureFlags")
+    __properties: ClassVar[List[str]] = ["key", "payload", "featureFlags"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -73,6 +75,18 @@ class CreateDemographicRapidModel(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of payload
         if self.payload:
             _dict['payload'] = self.payload.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in feature_flags (list)
+        _items = []
+        if self.feature_flags:
+            for _item_feature_flags in self.feature_flags:
+                if _item_feature_flags:
+                    _items.append(_item_feature_flags.to_dict())
+            _dict['featureFlags'] = _items
+        # set to None if feature_flags (nullable) is None
+        # and model_fields_set contains the field
+        if self.feature_flags is None and "feature_flags" in self.model_fields_set:
+            _dict['featureFlags'] = None
+
         return _dict
 
     @classmethod
@@ -86,7 +100,8 @@ class CreateDemographicRapidModel(BaseModel):
 
         _obj = cls.model_validate({
             "key": obj.get("key"),
-            "payload": ClassifyPayload.from_dict(obj["payload"]) if obj.get("payload") is not None else None
+            "payload": ClassifyPayload.from_dict(obj["payload"]) if obj.get("payload") is not None else None,
+            "featureFlags": [FeatureFlag.from_dict(_item) for _item in obj["featureFlags"]] if obj.get("featureFlags") is not None else None
         })
         return _obj