rapidata 2.12.0__py3-none-any.whl → 2.13.1__py3-none-any.whl

rapidata/api_client/models/datapoint_state.py

@@ -0,0 +1,38 @@
+# 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 DatapointState(str, Enum):
+    """
+    DatapointState
+    """
+
+    """
+    allowed enum values
+    """
+    READY = 'Ready'
+    PENDING = 'Pending'
+    FAILED = 'Failed'
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self:
+        """Create an instance of DatapointState from a JSON string"""
+        return cls(json.loads(json_str))
+
+

rapidata/api_client/models/demographic.py

@@ -0,0 +1,89 @@
+# 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 pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, StrictFloat, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Union
+from typing import Optional, Set
+from typing_extensions import Self
+
+class Demographic(BaseModel):
+    """
+    Demographic
+    """ # noqa: E501
+    value: StrictStr
+    confidence: Union[StrictFloat, StrictInt]
+    __properties: ClassVar[List[str]] = ["value", "confidence"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of Demographic from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of Demographic from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "value": obj.get("value"),
+            "confidence": obj.get("confidence")
+        })
+        return _obj
+
+

rapidata/api_client/models/demographic_metadata_model.py

@@ -17,8 +17,9 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictFloat, StrictInt, StrictStr, field_validator
-from typing import Any, ClassVar, Dict, List, Union
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from rapidata.api_client.models.demographic import Demographic
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -27,10 +28,8 @@ class DemographicMetadataModel(BaseModel):
     DemographicMetadataModel
     """ # noqa: E501
     t: StrictStr = Field(description="Discriminator value for DemographicMetadata", alias="_t")
-    confidence: Union[StrictFloat, StrictInt]
-    value: StrictStr
-    identifier: StrictStr
-    __properties: ClassVar[List[str]] = ["_t", "confidence", "value", "identifier"]
+    demographics: Optional[Dict[str, Demographic]] = None
+    __properties: ClassVar[List[str]] = ["_t", "demographics"]
 
     @field_validator('t')
     def t_validate_enum(cls, value):
@@ -78,6 +77,13 @@ class DemographicMetadataModel(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
+        # override the default output from pydantic by calling `to_dict()` of each value in demographics (dict)
+        _field_dict = {}
+        if self.demographics:
+            for _key_demographics in self.demographics:
+                if self.demographics[_key_demographics]:
+                    _field_dict[_key_demographics] = self.demographics[_key_demographics].to_dict()
+            _dict['demographics'] = _field_dict
         return _dict
 
     @classmethod
@@ -91,9 +97,12 @@ class DemographicMetadataModel(BaseModel):
 
         _obj = cls.model_validate({
             "_t": obj.get("_t") if obj.get("_t") is not None else 'DemographicMetadata',
-            "confidence": obj.get("confidence"),
-            "value": obj.get("value"),
-            "identifier": obj.get("identifier")
+            "demographics": dict(
+                (_k, Demographic.from_dict(_v))
+                for _k, _v in obj["demographics"].items()
+            )
+            if obj.get("demographics") is not None
+            else None
         })
         return _obj
 

rapidata/api_client/models/elo_config.py

@@ -0,0 +1,91 @@
+# 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 pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class EloConfig(BaseModel):
+    """
+    EloConfig
+    """ # noqa: E501
+    starting_elo: Optional[StrictInt] = Field(default=None, alias="startingElo")
+    k_factor: Optional[StrictInt] = Field(default=None, alias="kFactor")
+    scaling_factor: Optional[StrictInt] = Field(default=None, alias="scalingFactor")
+    __properties: ClassVar[List[str]] = ["startingElo", "kFactor", "scalingFactor"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of EloConfig from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of EloConfig from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "startingElo": obj.get("startingElo"),
+            "kFactor": obj.get("kFactor"),
+            "scalingFactor": obj.get("scalingFactor")
+        })
+        return _obj
+
+

rapidata/api_client/models/elo_config_model.py

@@ -0,0 +1,91 @@
+# 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 pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class EloConfigModel(BaseModel):
+    """
+    These parameters affect how the ELO algorithms behaves
+    """ # noqa: E501
+    starting_elo: Optional[StrictInt] = Field(default=None, description="The starting ELO score for each datapoint.", alias="startingElo")
+    k_factor: Optional[StrictInt] = Field(default=None, description="The K-factor to use in the ELO calculation.  Determines the maximum possible change in a player's Elo rating after a single match.  Higher K-Factor values result in larger rating changes.", alias="kFactor")
+    scaling_factor: Optional[StrictInt] = Field(default=None, description="Scaling factor to use in the ELO calculation.  Adjusts the sensitivity of the Elo rating system to differences in player ratings.  It affects how much the rating changes based on the expected outcome versus the actual outcome.", alias="scalingFactor")
+    __properties: ClassVar[List[str]] = ["startingElo", "kFactor", "scalingFactor"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of EloConfigModel from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of EloConfigModel from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "startingElo": obj.get("startingElo"),
+            "kFactor": obj.get("kFactor"),
+            "scalingFactor": obj.get("scalingFactor")
+        })
+        return _obj
+
+

rapidata/api_client/models/file_asset_model.py

@@ -19,7 +19,7 @@ import json
 
 from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
 from typing import Any, ClassVar, Dict, List
-from rapidata.api_client.models.file_asset_model_metadata_inner import FileAssetModelMetadataInner
+from rapidata.api_client.models.file_asset_model_metadata_value import FileAssetModelMetadataValue
 from typing import Optional, Set
 from typing_extensions import Self
 
@@ -27,17 +27,17 @@ class FileAssetModel(BaseModel):
     """
     FileAssetModel
     """ # noqa: E501
-    t: StrictStr = Field(description="Discriminator value for FileAssetModel", alias="_t")
+    t: StrictStr = Field(description="Discriminator value for FileAsset", alias="_t")
     file_name: StrictStr = Field(alias="fileName")
-    metadata: List[FileAssetModelMetadataInner]
+    metadata: Dict[str, FileAssetModelMetadataValue]
     identifier: StrictStr
     __properties: ClassVar[List[str]] = ["_t", "fileName", "metadata", "identifier"]
 
     @field_validator('t')
     def t_validate_enum(cls, value):
         """Validates the enum"""
-        if value not in set(['FileAssetModel']):
-            raise ValueError("must be one of enum values ('FileAssetModel')")
+        if value not in set(['FileAsset']):
+            raise ValueError("must be one of enum values ('FileAsset')")
         return value
 
     model_config = ConfigDict(
@@ -79,13 +79,13 @@ class FileAssetModel(BaseModel):
             exclude=excluded_fields,
             exclude_none=True,
         )
-        # override the default output from pydantic by calling `to_dict()` of each item in metadata (list)
-        _items = []
+        # override the default output from pydantic by calling `to_dict()` of each value in metadata (dict)
+        _field_dict = {}
         if self.metadata:
-            for _item_metadata in self.metadata:
-                if _item_metadata:
-                    _items.append(_item_metadata.to_dict())
-            _dict['metadata'] = _items
+            for _key_metadata in self.metadata:
+                if self.metadata[_key_metadata]:
+                    _field_dict[_key_metadata] = self.metadata[_key_metadata].to_dict()
+            _dict['metadata'] = _field_dict
         return _dict
 
     @classmethod
@@ -98,9 +98,14 @@ class FileAssetModel(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "_t": obj.get("_t") if obj.get("_t") is not None else 'FileAssetModel',
+            "_t": obj.get("_t") if obj.get("_t") is not None else 'FileAsset',
             "fileName": obj.get("fileName"),
-            "metadata": [FileAssetModelMetadataInner.from_dict(_item) for _item in obj["metadata"]] if obj.get("metadata") is not None else None,
+            "metadata": dict(
+                (_k, FileAssetModelMetadataValue.from_dict(_v))
+                for _k, _v in obj["metadata"].items()
+            )
+            if obj.get("metadata") is not None
+            else None,
             "identifier": obj.get("identifier")
         })
         return _obj