rapidata 2.42.2__py3-none-any.whl → 2.42.4__py3-none-any.whl

rapidata/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.42.2"
+__version__ = "2.42.4"
 
 from .rapidata_client import (
     RapidataClient,
@@ -31,7 +31,6 @@ from .rapidata_client import (
     AgeGroup,
     GenderFilter,
     Gender,
-    CountryCodes,
     Box,
     Datapoint,
     PromptMetadata,

rapidata/rapidata_client/__init__.py

@@ -28,7 +28,6 @@ from .settings import (
     AllowNeitherBoth,
     SwapContextInstruction,
 )
-from .country_codes import CountryCodes
 from .filter import (
     CountryFilter,
     LanguageFilter,

rapidata/rapidata_client/datapoints/metadata/_media_asset_metadata.py

@@ -6,13 +6,11 @@ from rapidata.api_client.models.multi_asset_input_assets_inner import (
     ExistingAssetInput,
     MultiAssetInputAssetsInner,
 )
+from pydantic import BaseModel
 
 
-class MediaAssetMetadata(Metadata):
-
-    def __init__(self, internal_file_name: str):
-        super().__init__()
-        self._internal_file_name = internal_file_name
+class MediaAssetMetadata(Metadata, BaseModel):
+    internal_file_name: str
 
     def to_model(self):
         return PromptAssetMetadataInput(
@@ -20,7 +18,7 @@ class MediaAssetMetadata(Metadata):
             asset=MultiAssetInputAssetsInner(
                 actual_instance=ExistingAssetInput(
                     _t="ExistingAssetInput",
-                    name=self._internal_file_name,
+                    name=self.internal_file_name,
                 ),
             ),
         )

rapidata/rapidata_client/datapoints/metadata/_private_text_metadata.py

@@ -2,16 +2,15 @@ from rapidata.api_client.models.private_text_metadata_input import (
     PrivateTextMetadataInput,
 )
 from rapidata.rapidata_client.datapoints.metadata._base_metadata import Metadata
+from pydantic import BaseModel
 
 
-class PrivateTextMetadata(Metadata):
+class PrivateTextMetadata(Metadata, BaseModel):
 
-    def __init__(self, text: str, identifier: str = "private_text"):
-        super().__init__()
-        self._identifier = identifier
-        self._text = text
+    text: str
+    identifier: str = "private_text"
 
     def to_model(self):
         return PrivateTextMetadataInput(
-            _t="PrivateTextMetadataInput", identifier=self._identifier, text=self._text
+            _t="PrivateTextMetadataInput", identifier=self.identifier, text=self.text
         )

rapidata/rapidata_client/datapoints/metadata/_prompt_identifier_metadata.py

@@ -2,14 +2,13 @@ from rapidata.rapidata_client.datapoints.metadata._base_metadata import Metadata
 from rapidata.api_client.models.private_text_metadata_input import (
     PrivateTextMetadataInput,
 )
+from pydantic import BaseModel
 
 
-class PromptIdentifierMetadata(Metadata):
-    def __init__(self, identifier: str):
-        super().__init__()
-        self._identifier = identifier
+class PromptIdentifierMetadata(Metadata, BaseModel):
+    identifier: str
 
     def to_model(self):
         return PrivateTextMetadataInput(
-            _t="PrivateTextMetadataInput", identifier="prompt-id", text=self._identifier
+            _t="PrivateTextMetadataInput", identifier="prompt-id", text=self.identifier
         )

rapidata/rapidata_client/datapoints/metadata/_prompt_metadata.py

@@ -1,17 +1,12 @@
 from rapidata.rapidata_client.datapoints.metadata._base_metadata import Metadata
 from rapidata.api_client.models.prompt_metadata_input import PromptMetadataInput
+from pydantic import BaseModel
 
 
-class PromptMetadata(Metadata):
+class PromptMetadata(Metadata, BaseModel):
     """The PromptMetadata class is used to display a prompt to the user."""
 
-    def __init__(self, prompt: str):
-        super().__init__()
-
-        if not isinstance(prompt, str):
-            raise ValueError("Prompt must be a string")
-
-        self._prompt = prompt
+    prompt: str
 
     def to_model(self):
-        return PromptMetadataInput(_t="PromptMetadataInput", prompt=self._prompt)
+        return PromptMetadataInput(_t="PromptMetadataInput", prompt=self.prompt)

rapidata/rapidata_client/datapoints/metadata/_public_text_metadata.py

@@ -2,16 +2,15 @@ from rapidata.api_client.models.public_text_metadata_input import (
     PublicTextMetadataInput,
 )
 from rapidata.rapidata_client.datapoints.metadata._base_metadata import Metadata
+from pydantic import BaseModel
 
 
-class PublicTextMetadata(Metadata):
+class PublicTextMetadata(Metadata, BaseModel):
 
-    def __init__(self, text: str, identifier: str = "public_text"):
-        super().__init__()
-        self._identifier = identifier
-        self._text = text
+    text: str
+    identifier: str = "public_text"
 
     def to_model(self):
         return PublicTextMetadataInput(
-            _t="PublicTextMetadataInput", identifier=self._identifier, text=self._text
+            _t="PublicTextMetadataInput", identifier=self.identifier, text=self.text
         )

rapidata/rapidata_client/datapoints/metadata/_select_words_metadata.py

@@ -2,14 +2,13 @@ from rapidata.api_client.models.transcription_metadata_input import (
     TranscriptionMetadataInput,
 )
 from rapidata.rapidata_client.datapoints.metadata._base_metadata import Metadata
+from pydantic import BaseModel
 
 
-class SelectWordsMetadata(Metadata):
+class SelectWordsMetadata(Metadata, BaseModel):
     """SelectWordsMetadata Class is used to define the Sentence that will be display to the user."""
 
-    def __init__(self, select_words: str):
-        super().__init__()
-        self.select_words = select_words
+    select_words: str
 
     def to_model(self):
         return TranscriptionMetadataInput(

rapidata/rapidata_client/demographic/demographic_manager.py

@@ -1,4 +1,3 @@
-from argparse import Action
 from rapidata.api_client import ExistingAssetInput
 from rapidata.api_client.models.create_demographic_rapid_model_asset import (
     CreateDemographicRapidModelAsset,

rapidata/rapidata_client/filter/_base_filter.py

@@ -19,15 +19,15 @@ class RapidataFilter:
         # If self is already an OrFilter, extend its filters list
         if isinstance(self, OrFilter):
             if isinstance(other, OrFilter):
-                return OrFilter(self.filters + other.filters)
+                return OrFilter(filters=self.filters + other.filters)
             else:
-                return OrFilter(self.filters + [other])
+                return OrFilter(filters=self.filters + [other])
         # If other is an OrFilter, prepend self to its filters
         elif isinstance(other, OrFilter):
-            return OrFilter([self] + other.filters)
+            return OrFilter(filters=[self] + other.filters)
         # Neither is an OrFilter, create a new one
         else:
-            return OrFilter([self, other])
+            return OrFilter(filters=[self, other])
 
     def __and__(self, other):
         """Enable the & operator to create AndFilter combinations."""
@@ -39,15 +39,15 @@ class RapidataFilter:
         # If self is already an AndFilter, extend its filters list
         if isinstance(self, AndFilter):
             if isinstance(other, AndFilter):
-                return AndFilter(self.filters + other.filters)
+                return AndFilter(filters=self.filters + other.filters)
             else:
-                return AndFilter(self.filters + [other])
+                return AndFilter(filters=self.filters + [other])
         # If other is an AndFilter, prepend self to its filters
         elif isinstance(other, AndFilter):
-            return AndFilter([self] + other.filters)
+            return AndFilter(filters=[self] + other.filters)
         # Neither is an AndFilter, create a new one
         else:
-            return AndFilter([self, other])
+            return AndFilter(filters=[self, other])
 
     def __invert__(self):
         """Enable the ~ operator to create NotFilter negations."""
@@ -58,10 +58,4 @@ class RapidataFilter:
             return self.filter
         # Create a new NotFilter
         else:
-            return NotFilter(self)
-
-    def __str__(self) -> str:
-        return f"{self.__class__.__name__}()"
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}()"
+            return NotFilter(filter=self)

rapidata/rapidata_client/filter/age_filter.py

@@ -1,29 +1,23 @@
-from typing import Any
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.age_user_filter_model import AgeUserFilterModel
 from rapidata.rapidata_client.filter.models.age_group import AgeGroup
+from pydantic import BaseModel, ConfigDict
 
 
-class AgeFilter(RapidataFilter):
+class AgeFilter(RapidataFilter, BaseModel):
     """AgeFilter Class
 
     Can be used to filter who to target based on age groups.
 
-
     Args:
         age_groups (list[AgeGroup]): List of age groups to filter by."""
 
-    def __init__(self, age_groups: list[AgeGroup]):
-        self.age_groups = age_groups
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    age_groups: list[AgeGroup]
 
     def _to_model(self):
         return AgeUserFilterModel(
             _t="AgeFilter",
             ageGroups=[age_group._to_backend_model() for age_group in self.age_groups],
         )
-
-    def __str__(self) -> str:
-        return f"AgeFilter(age_groups={self.age_groups})"
-
-    def __repr__(self) -> str:
-        return f"AgeFilter(age_groups={self.age_groups!r})"

rapidata/rapidata_client/filter/and_filter.py

@@ -4,9 +4,10 @@ from rapidata.api_client.models.and_user_filter_model import AndUserFilterModel
 from rapidata.api_client.models.and_user_filter_model_filters_inner import (
     AndUserFilterModelFiltersInner,
 )
+from pydantic import BaseModel, ConfigDict
 
 
-class AndFilter(RapidataFilter):
+class AndFilter(RapidataFilter, BaseModel):
     """A filter that combines multiple filters with a logical AND operation.
     This class implements a logical AND operation on a list of filters, where the condition is met if all of the filters' conditions are met.
 
@@ -23,11 +24,9 @@ class AndFilter(RapidataFilter):
         This will match users who have their phone set to English AND are located in the United States.
     """
 
-    def __init__(self, filters: list[RapidataFilter]):
-        if not all(isinstance(filter, RapidataFilter) for filter in filters):
-            raise ValueError("Filters must be a RapidataFilter object")
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
-        self.filters = filters
+    filters: list[RapidataFilter]
 
     def _to_model(self):
         return AndUserFilterModel(
@@ -37,9 +36,3 @@ class AndFilter(RapidataFilter):
                 for filter in self.filters
             ],
         )
-
-    def __str__(self) -> str:
-        return f"AndFilter(filters={self.filters})"
-
-    def __repr__(self) -> str:
-        return f"AndFilter(filters={self.filters!r})"

rapidata/rapidata_client/filter/campaign_filter.py

@@ -1,11 +1,11 @@
-from typing import Any
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.campaign_user_filter_model import (
     CampaignUserFilterModel,
 )
+from pydantic import BaseModel
 
 
-class CampaignFilter(RapidataFilter):
+class CampaignFilter(RapidataFilter, BaseModel):
     """CampaignFilter Class
 
     Can be used to filter who to target based on campaign IDs.
@@ -16,17 +16,10 @@ class CampaignFilter(RapidataFilter):
         campaign_ids (list[str]): List of campaign IDs to filter by.
     """
 
-    def __init__(self, campaign_ids: list[str]):
-        self.campaign_ids = campaign_ids
+    campaign_ids: list[str]
 
     def _to_model(self):
         return CampaignUserFilterModel(
             _t="CampaignFilter",
             campaignIds=self.campaign_ids,
         )
-
-    def __str__(self) -> str:
-        return f"CampaignFilter(campaign_ids={self.campaign_ids})"
-
-    def __repr__(self) -> str:
-        return f"CampaignFilter(campaign_ids={self.campaign_ids!r})"

rapidata/rapidata_client/filter/country_filter.py

@@ -1,9 +1,10 @@
-from typing import Any
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.country_user_filter_model import CountryUserFilterModel
+from pydantic import BaseModel, field_validator
+from rapidata.rapidata_client.config import logger
 
 
-class CountryFilter(RapidataFilter):
+class CountryFilter(RapidataFilter, BaseModel):
     """CountryFilter Class
 
     Can be used to filter who to target based on country codes.
@@ -12,21 +13,23 @@ class CountryFilter(RapidataFilter):
         country_codes (list[str]): List of country codes (capitalized) to filter by.
     """
 
-    def __init__(self, country_codes: list[str]):
-        # check that all characters in the country codes are uppercase
-        if not isinstance(country_codes, list):
-            raise ValueError("Country codes must be a list")
-
-        if not all([code.isupper() for code in country_codes]):
-            raise ValueError("Country codes must be uppercase")
-
-        self.country_codes = country_codes
+    country_codes: list[str]
+
+    @field_validator("country_codes")
+    @classmethod
+    def validate_country_codes(cls, codes: list[str]) -> list[str]:
+        validated = []
+        for code in codes:
+            if len(code) != 2:
+                raise ValueError(
+                    f"Country codes must be length 2. Invalid code: '{code}'"
+                )
+            if code != code.upper():
+                logger.warning(
+                    f"Country code '{code}' should be uppercase. It will be uppercased automatically."
+                )
+            validated.append(code.upper())
+        return validated
 
     def _to_model(self):
         return CountryUserFilterModel(_t="CountryFilter", countries=self.country_codes)
-
-    def __str__(self) -> str:
-        return f"CountryFilter(country_codes={self.country_codes})"
-
-    def __repr__(self) -> str:
-        return f"CountryFilter(country_codes={self.country_codes!r})"

rapidata/rapidata_client/filter/custom_filter.py

@@ -1,9 +1,9 @@
-from typing import Any
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.custom_user_filter_model import CustomUserFilterModel
+from pydantic import BaseModel
 
 
-class CustomFilter(RapidataFilter):
+class CustomFilter(RapidataFilter, BaseModel):
     """CustomFilter Class
 
     Can be used to filter who to target based on custom filters.
@@ -17,9 +17,8 @@ class CustomFilter(RapidataFilter):
         values (list[str]): List of values to filter by.
     """
 
-    def __init__(self, identifier: str, values: list[str]):
-        self.identifier = identifier
-        self.values = values
+    identifier: str
+    values: list[str]
 
     def _to_model(self):
         return CustomUserFilterModel(
@@ -27,9 +26,3 @@ class CustomFilter(RapidataFilter):
             identifier=self.identifier,
             values=self.values,
         )
-
-    def __str__(self) -> str:
-        return f"CustomFilter(identifier={self.identifier}, values={self.values})"
-
-    def __repr__(self) -> str:
-        return f"CustomFilter(identifier={self.identifier!r}, values={self.values!r})"

rapidata/rapidata_client/filter/gender_filter.py

@@ -1,10 +1,10 @@
-from typing import Any
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.gender_user_filter_model import GenderUserFilterModel
 from rapidata.rapidata_client.filter.models.gender import Gender
+from pydantic import BaseModel, ConfigDict
 
 
-class GenderFilter(RapidataFilter):
+class GenderFilter(RapidataFilter, BaseModel):
     """GenderFilter Class
 
     Can be used to filter who to target based on their gender.
@@ -13,17 +13,12 @@ class GenderFilter(RapidataFilter):
     Args:
         genders (list[Gender]): List of genders to filter by."""
 
-    def __init__(self, genders: list[Gender]):
-        self.genders = genders
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    genders: list[Gender]
 
     def _to_model(self):
         return GenderUserFilterModel(
             _t="GenderFilter",
             genders=[gender._to_backend_model() for gender in self.genders],
         )
-
-    def __str__(self) -> str:
-        return f"GenderFilter(genders={self.genders})"
-
-    def __repr__(self) -> str:
-        return f"GenderFilter(genders={self.genders!r})"

rapidata/rapidata_client/filter/language_filter.py

@@ -1,11 +1,12 @@
-from typing import Any
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.language_user_filter_model import (
     LanguageUserFilterModel,
 )
+from pydantic import BaseModel, field_validator
+from rapidata.rapidata_client.config import logger
 
 
-class LanguageFilter(RapidataFilter):
+class LanguageFilter(RapidataFilter, BaseModel):
     """LanguageFilter Class
 
     Can be used to filter who to target based on language codes.
@@ -20,25 +21,26 @@ class LanguageFilter(RapidataFilter):
         This will limit the order to be shown to only people who have their phone set to english or german
     """
 
-    def __init__(self, language_codes: list[str]):
-        if not isinstance(language_codes, list):
-            raise ValueError("Language codes must be a list")
-
-        # check that all characters in the language codes are lowercase
-        if not all([code.islower() for code in language_codes]):
-            raise ValueError("Language codes must be lowercase")
-
-        for code in language_codes:
-            if not len(code) == 2:
-                raise ValueError("Language codes must be two characters long")
-
-        self.languages = language_codes
+    language_codes: list[str]
+
+    @field_validator("language_codes")
+    @classmethod
+    def validate_language_codes(cls, codes: list[str]) -> list[str]:
+        validated = []
+        for code in codes:
+            if len(code) != 2:
+                raise ValueError(
+                    f"Language codes must be length 2. Invalid code: '{code}'"
+                )
+            if code != code.lower():
+                logger.warning(
+                    f"Language code '{code}' should be lowercase. It will be lowercased automatically."
+                )
+            validated.append(code.lower())
+        return validated
 
     def _to_model(self):
-        return LanguageUserFilterModel(_t="LanguageFilter", languages=self.languages)
-
-    def __str__(self):
-        return f"LanguageFilter({self.languages})"
-
-    def __repr__(self):
-        return f"LanguageFilter({self.languages})"
+        return LanguageUserFilterModel(
+            _t="LanguageFilter",
+            languages=self.language_codes,
+        )

rapidata/rapidata_client/filter/not_filter.py

@@ -4,9 +4,10 @@ from rapidata.api_client.models.not_user_filter_model import NotUserFilterModel
 from rapidata.api_client.models.and_user_filter_model_filters_inner import (
     AndUserFilterModelFiltersInner,
 )
+from pydantic import BaseModel, ConfigDict
 
 
-class NotFilter(RapidataFilter):
+class NotFilter(RapidataFilter, BaseModel):
     """A filter that negates another filter's condition.
     This class implements a logical NOT operation on a given filter, inverting its results.
 
@@ -23,20 +24,12 @@ class NotFilter(RapidataFilter):
         This will limit the order to be shown to only people who have their phone set to a language other than English.
     """
 
-    def __init__(self, filter: RapidataFilter):
-        if not isinstance(filter, RapidataFilter):
-            raise ValueError("Filter must be a RapidataFilter object")
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
-        self.filter = filter
+    filter: RapidataFilter
 
     def _to_model(self):
         return NotUserFilterModel(
             _t="NotFilter",
             filter=AndUserFilterModelFiltersInner(self.filter._to_model()),
         )
-
-    def __str__(self) -> str:
-        return f"NotFilter(filter={self.filter})"
-
-    def __repr__(self) -> str:
-        return f"NotFilter(filter={self.filter!r})"

rapidata/rapidata_client/filter/or_filter.py

@@ -1,12 +1,12 @@
-from typing import Any
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.or_user_filter_model import OrUserFilterModel
 from rapidata.api_client.models.and_user_filter_model_filters_inner import (
     AndUserFilterModelFiltersInner,
 )
+from pydantic import BaseModel, ConfigDict
 
 
-class OrFilter(RapidataFilter):
+class OrFilter(RapidataFilter, BaseModel):
     """A filter that combines multiple filters with a logical OR operation.
     This class implements a logical OR operation on a list of filters, where the condition is met if any of the filters' conditions are met.
 
@@ -23,11 +23,9 @@ class OrFilter(RapidataFilter):
         This will match users who either have their phone set to English OR are located in the United States.
     """
 
-    def __init__(self, filters: list[RapidataFilter]):
-        if not all(isinstance(filter, RapidataFilter) for filter in filters):
-            raise ValueError("Filters must be a RapidataFilter object")
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
-        self.filters = filters
+    filters: list[RapidataFilter]
 
     def _to_model(self):
         return OrUserFilterModel(
@@ -37,9 +35,3 @@ class OrFilter(RapidataFilter):
                 for filter in self.filters
             ],
         )
-
-    def __str__(self) -> str:
-        return f"OrFilter(filters={self.filters})"
-
-    def __repr__(self) -> str:
-        return f"OrFilter(filters={self.filters!r})"

rapidata/rapidata_client/filter/response_count_filter.py

@@ -4,9 +4,10 @@ from rapidata.api_client.models.response_count_user_filter_model import (
     ResponseCountUserFilterModel,
 )
 from rapidata.api_client.models.comparison_operator import ComparisonOperator
+from pydantic import BaseModel, ConfigDict
 
 
-class ResponseCountFilter(RapidataFilter):
+class ResponseCountFilter(RapidataFilter, BaseModel):
     """ResponseCountFilter Class
     Can be used to filter users based on the number of responses they have given on validation tasks with the specified dimension.
 
@@ -34,13 +35,11 @@ class ResponseCountFilter(RapidataFilter):
         This will filter users who have a response count greater than 10 for the "electrical" dimension.
     """
 
-    def __init__(
-        self, response_count: int, dimension: str, operator: ComparisonOperator
-    ):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
-        self.response_count = response_count
-        self.dimension = dimension
-        self.operator = operator
+    response_count: int
+    dimension: str
+    operator: ComparisonOperator
 
     def _to_model(self):
         return ResponseCountUserFilterModel(
@@ -49,9 +48,3 @@ class ResponseCountFilter(RapidataFilter):
             dimension=self.dimension,
             operator=self.operator,
         )
-
-    def __str__(self) -> str:
-        return f"ResponseCountFilter(response_count={self.response_count}, dimension={self.dimension}, operator={self.operator})"
-
-    def __repr__(self) -> str:
-        return f"ResponseCountFilter(response_count={self.response_count!r}, dimension={self.dimension!r}, operator={self.operator!r})"

rapidata/rapidata_client/filter/user_score_filter.py

@@ -1,11 +1,12 @@
-from typing import Any
+from pydantic_core.core_schema import FieldValidationInfo
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.user_score_user_filter_model import (
     UserScoreUserFilterModel,
 )
+from pydantic import BaseModel, field_validator, model_validator
 
 
-class UserScoreFilter(RapidataFilter):
+class UserScoreFilter(RapidataFilter, BaseModel):
     """UserScoreFilter Class
 
     Can be used to filter who to target based on their user score.
@@ -22,22 +23,22 @@ class UserScoreFilter(RapidataFilter):
         This will only show the order to users that have a UserScore of >=0.5 and <=0.9
     """
 
-    def __init__(
-        self,
-        lower_bound: float = 0.0,
-        upper_bound: float = 1.0,
-        dimension: str | None = None,
-    ):
-        if lower_bound < 0 or lower_bound > 1:
-            raise ValueError("The lower bound must be between 0 and 1.")
-        if upper_bound < 0 or upper_bound > 1:
-            raise ValueError("The upper bound must be between 0 and 1.")
-        if lower_bound >= upper_bound:
-            raise ValueError("The lower bound must be less than the upper bound.")
-
-        self.upper_bound = upper_bound
-        self.lower_bound = lower_bound
-        self.dimension = dimension
+    lower_bound: float = 0.0
+    upper_bound: float = 1.0
+    dimension: str | None = None
+
+    @field_validator("lower_bound", "upper_bound")
+    @classmethod
+    def validate_bounds(cls, v: float, info: FieldValidationInfo) -> float:
+        if v < 0 or v > 1:
+            raise ValueError(f"{info.field_name} must be between 0 and 1")
+        return v
+
+    @model_validator(mode="after")
+    def validate_bounds_relationship(self) -> "UserScoreFilter":
+        if self.lower_bound >= self.upper_bound:
+            raise ValueError("lower_bound must be less than upper_bound")
+        return self
 
     def _to_model(self):
         return UserScoreUserFilterModel(
@@ -46,9 +47,3 @@ class UserScoreFilter(RapidataFilter):
             lowerbound=self.lower_bound,
             dimension=self.dimension,
         )
-
-    def __str__(self) -> str:
-        return f"UserScoreFilter(lower_bound={self.lower_bound}, upper_bound={self.upper_bound}, dimension={self.dimension})"
-
-    def __repr__(self) -> str:
-        return f"UserScoreFilter(lower_bound={self.lower_bound!r}, upper_bound={self.upper_bound!r}, dimension={self.dimension!r})"

rapidata/rapidata_client/order/_rapidata_order_builder.py

@@ -1,4 +1,4 @@
-from typing import Literal, Optional, Sequence
+from typing import Literal, Optional, Sequence, get_args
 import random
 import urllib.parse
 import webbrowser
@@ -43,6 +43,8 @@ from rapidata.rapidata_client.api.rapidata_api_client import (
     suppress_rapidata_error_logging,
 )
 
+StickyStateLiteral = Literal["Temporary", "Permanent", "Passive"]
+
 
 class RapidataOrderBuilder:
     """Builder object for creating Rapidata orders.
@@ -71,9 +73,7 @@ class RapidataOrderBuilder:
         self.__selections: list[RapidataSelection] = []
         self.__priority: int | None = None
         self.__datapoints: list[Datapoint] = []
-        self.__sticky_state_value: Literal["None", "Temporary", "Permanent"] | None = (
-            None
-        )
+        self.__sticky_state_value: StickyStateLiteral | None = None
         self.__validation_set_manager: ValidationSetManager = ValidationSetManager(
             self.__openapi_service
         )
@@ -147,6 +147,7 @@ class RapidataOrderBuilder:
                         self.__openapi_service.validation_api.validation_set_recommended_get(
                             asset_type=[self.__datapoints[0].get_asset_type()],
                             modality=[self.__workflow.modality],
+                            instruction=self.__workflow._get_instruction(),
                             prompt_type=[
                                 t.value for t in self.__datapoints[0].get_prompt_type()
                             ],
@@ -453,18 +454,16 @@ class RapidataOrderBuilder:
         return self
 
     def _sticky_state(
-        self, sticky_state: Literal["None", "Temporary", "Permanent"] | None = None
+        self, sticky_state: StickyStateLiteral | None = None
     ) -> "RapidataOrderBuilder":
         """
         Set the sticky state for the order.
         """
-        if sticky_state is not None and sticky_state not in [
-            "None",
-            "Temporary",
-            "Permanent",
-        ]:
-            raise TypeError(
-                "Sticky state must be of type Literal['None', 'Temporary', 'Permanent']."
+        sticky_state_valid_values = get_args(StickyStateLiteral)
+
+        if sticky_state is not None and sticky_state not in sticky_state_valid_values:
+            raise ValueError(
+                f"Sticky state must be one of {sticky_state_valid_values} or None"
             )
 
         self.__sticky_state_value = sticky_state

rapidata/rapidata_client/order/rapidata_order_manager.py

@@ -1,4 +1,4 @@
-from typing import Sequence, Optional, Literal
+from typing import Sequence, Optional, Literal, get_args
 from itertools import zip_longest
 
 from rapidata.rapidata_client.config.tracer import tracer
@@ -41,7 +41,7 @@ from rapidata.api_client.models.filter import Filter
 from rapidata.api_client.models.filter_operator import FilterOperator
 from rapidata.api_client.models.sort_criterion import SortCriterion
 from rapidata.api_client.models.sort_direction import SortDirection
-
+from rapidata.rapidata_client.order._rapidata_order_builder import StickyStateLiteral
 
 from tqdm import tqdm
 
@@ -61,7 +61,7 @@ class RapidataOrderManager:
         self.settings = RapidataSettings
         self.selections = RapidataSelections
         self.__priority: int | None = None
-        self.__sticky_state: Literal["None", "Temporary", "Permanent"] | None = None
+        self.__sticky_state: StickyStateLiteral | None = None
         self.__asset_uploader = AssetUploader(openapi_service)
         logger.debug("RapidataOrderManager initialized")
 
@@ -172,21 +172,21 @@ class RapidataOrderManager:
         logger.debug("Order created: %s", order)
         return order
 
-    def _set_priority(self, priority: int):
-        if not isinstance(priority, int):
-            raise TypeError("Priority must be an integer")
+    def _set_priority(self, priority: int | None):
+        if priority is not None and not isinstance(priority, int):
+            raise TypeError("Priority must be an integer or None")
 
-        if priority < 0:
-            raise ValueError("Priority must be greater than 0")
+        if priority is not None and priority < 0:
+            raise ValueError("Priority must be greater than 0 or None")
 
         self.__priority = priority
 
-    def _set_sticky_state(
-        self, sticky_state: Literal["None", "Temporary", "Permanent"]
-    ):
-        if sticky_state not in ["None", "Temporary", "Permanent"]:
+    def _set_sticky_state(self, sticky_state: StickyStateLiteral | None):
+        sticky_state_valid_values = get_args(StickyStateLiteral)
+
+        if sticky_state is not None and sticky_state not in sticky_state_valid_values:
             raise ValueError(
-                "Sticky state must be one of 'None', 'Temporary', 'Permanent'"
+                f"Sticky state must be one of {sticky_state_valid_values} or None"
             )
 
         self.__sticky_state = sticky_state

rapidata/rapidata_client/workflow/_base_workflow.py

@@ -44,6 +44,10 @@ class Workflow(ABC):
     ):
         pass
 
+    @abstractmethod
+    def _get_instruction(self) -> str:
+        pass
+
     @abstractmethod
     def _to_model(
         self,

rapidata/rapidata_client/workflow/_classify_workflow.py

@@ -35,6 +35,9 @@ class ClassifyWorkflow(Workflow):
         self._instruction = instruction
         self._answer_options = answer_options
 
+    def _get_instruction(self) -> str:
+        return self._instruction
+
     def _to_dict(self) -> dict[str, Any]:
         return {
             **super()._to_dict(),

rapidata/rapidata_client/workflow/_compare_workflow.py

@@ -31,6 +31,9 @@ class CompareWorkflow(Workflow):
         self._instruction = instruction
         self._a_b_names = a_b_names
 
+    def _get_instruction(self) -> str:
+        return self._instruction
+
     def _to_dict(self) -> dict[str, Any]:
         return {
             **super()._to_dict(),

rapidata/rapidata_client/workflow/_draw_workflow.py

@@ -16,6 +16,9 @@ class DrawWorkflow(Workflow):
         super().__init__(type="SimpleWorkflowConfig")
         self._target = target
 
+    def _get_instruction(self) -> str:
+        return self._target
+
     def _to_model(self) -> SimpleWorkflowModel:
         blueprint = LineRapidBlueprint(_t="LineBlueprint", target=self._target)
 

rapidata/rapidata_client/workflow/_evaluation_workflow.py

@@ -22,6 +22,9 @@ class EvaluationWorkflow(Workflow):
         self.validation_set_id = validation_set_id
         self.should_accept_incorrect = should_accept_incorrect
 
+    def _get_instruction(self) -> str:
+        return ""
+
     def _to_model(self):
         return EvaluationWorkflowModel(
             _t="EvaluationWorkflow",

rapidata/rapidata_client/workflow/_free_text_workflow.py

@@ -33,6 +33,9 @@ class FreeTextWorkflow(Workflow):
         self._instruction = instruction
         self._validation_system_prompt = validation_system_prompt
 
+    def _get_instruction(self) -> str:
+        return self._instruction
+
     def _to_dict(self) -> dict[str, Any]:
         return {
             **super()._to_dict(),

rapidata/rapidata_client/workflow/_locate_workflow.py

@@ -16,6 +16,9 @@ class LocateWorkflow(Workflow):
         super().__init__(type="SimpleWorkflowConfig")
         self._target = target
 
+    def _get_instruction(self) -> str:
+        return self._target
+
     def _to_model(self) -> SimpleWorkflowModel:
         blueprint = LocateRapidBlueprint(_t="LocateBlueprint", target=self._target)
 

rapidata/rapidata_client/workflow/_ranking_workflow.py

@@ -47,10 +47,12 @@ class RankingWorkflow(Workflow):
                 file_uploader is not None
             ), "File uploader is required if media_context is provided"
             self.metadatas.append(
-                MediaAssetMetadata(file_uploader.upload_asset(media_context))
+                MediaAssetMetadata(
+                    internal_file_name=file_uploader.upload_asset(media_context)
+                )
             )
         if context:
-            self.metadatas.append(PromptMetadata(context))
+            self.metadatas.append(PromptMetadata(prompt=context))
 
         self.criteria = criteria
         self.total_comparison_budget = total_comparison_budget
@@ -73,6 +75,9 @@ class RankingWorkflow(Workflow):
             scalingFactor=elo_scaling_factor,
         )
 
+    def _get_instruction(self) -> str:
+        return self.criteria
+
     def _to_model(self) -> CompareWorkflowModel:
 
         return CompareWorkflowModel(

rapidata/rapidata_client/workflow/_select_words_workflow.py

@@ -31,6 +31,9 @@ class SelectWordsWorkflow(Workflow):
         super().__init__(type="SimpleWorkflowConfig")
         self._instruction = instruction
 
+    def _get_instruction(self) -> str:
+        return self._instruction
+
     def _to_model(self) -> SimpleWorkflowModel:
         blueprint = TranscriptionRapidBlueprint(
             _t="TranscriptionBlueprint", title=self._instruction

rapidata/rapidata_client/workflow/_timestamp_workflow.py

@@ -29,6 +29,9 @@ class TimestampWorkflow(Workflow):
         super().__init__(type="SimpleWorkflowConfig")
         self._instruction = instruction
 
+    def _get_instruction(self) -> str:
+        return self._instruction
+
     def _to_model(self) -> SimpleWorkflowModel:
         blueprint = ScrubRapidBlueprint(_t="ScrubBlueprint", target=self._instruction)
 

rapidata/types/__init__.py

@@ -92,7 +92,6 @@ from rapidata.rapidata_client.exceptions.failed_upload_exception import (
 )
 
 # Utility Types
-from rapidata.rapidata_client.country_codes.country_codes import CountryCodes
 from rapidata.rapidata_client.demographic.demographic_manager import DemographicManager
 
 # API Client Types

{rapidata-2.42.2.dist-info → rapidata-2.42.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rapidata
-Version: 2.42.2
+Version: 2.42.4
 Summary: Rapidata package containing the Rapidata Python Client to interact with the Rapidata Web API in an easy way.
 License: Apache-2.0
 License-File: LICENSE

{rapidata-2.42.2.dist-info → rapidata-2.42.4.dist-info}/RECORD

@@ -1,4 +1,4 @@
-rapidata/__init__.py,sha256=JE3wmzFPMDBFCoTTrU5UkvBELIuoQtdUwG6wPOUZbD0,875
+rapidata/__init__.py,sha256=AzEtXzIsctxegCTuNV6z2LvoGylidqI_UEVC0SgmTS8,857
 rapidata/api_client/__init__.py,sha256=Rh2aAoa6nDv09Z7cpTNdrPotXixBcNN_2VevCDD1goc,37144
 rapidata/api_client/api/__init__.py,sha256=CaZJ54mxbAEzAFd0Cjy0mfiUabD-d_7tqVOgjU4RxZI,1749
 rapidata/api_client/api/asset_api.py,sha256=buYMBGvg5_SLkJ7aG07c7_1rT6TXTCqoLfoV8O2nJhM,34442
@@ -599,7 +599,7 @@ rapidata/api_client/models/workflow_state.py,sha256=5LAK1se76RCoozeVB6oxMPb8p_5b
 rapidata/api_client/models/zip_entry_file_wrapper.py,sha256=-c8uJo-Dd-FGYPLzUR8sHV2waucFoDwEaJ_ztDGW7vc,5830
 rapidata/api_client/rest.py,sha256=rtIMcgINZOUaDFaJIinJkXRSddNJmXvMRMfgO2Ezk2o,10835
 rapidata/api_client_README.md,sha256=0AWEwcE005y5Q8IBzgEWgOa-iwqImdbY99RnQnlei70,63261
-rapidata/rapidata_client/__init__.py,sha256=8ofFfjLRWUvd6Ei2w3gQmycYNnnkZpR2dW6ifxC5OWY,1120
+rapidata/rapidata_client/__init__.py,sha256=j9nyFoKDOu8LyV9jcYaOqOL4kAbLf_TYaZkAg20969c,1080
 rapidata/rapidata_client/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rapidata/rapidata_client/api/rapidata_api_client.py,sha256=9385bND7sDuXfmq0AFgea_RrtuT73NA2CWG_9aIoGok,8945
 rapidata/rapidata_client/benchmark/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -618,8 +618,6 @@ rapidata/rapidata_client/config/order_config.py,sha256=XxRZERzUUA9md6-PVlV__eCw8
 rapidata/rapidata_client/config/rapidata_config.py,sha256=mURnKdl5-2sE4e_IYY9-aBkix6a12t47otEErGE_q0c,1507
 rapidata/rapidata_client/config/tracer.py,sha256=9P27QybtkjJ0U5ocPkIu58DUQB-MgVksQOMhuwKHKcY,4687
 rapidata/rapidata_client/config/upload_config.py,sha256=hjefl-w9WaCNeCEe6hdnrAQEMjgDy-r1zgUUIFR68wk,473
-rapidata/rapidata_client/country_codes/__init__.py,sha256=FB9Dcks44J6C6YBSYmTmNZ71tE130x6NO_3aLJ8fKzQ,40
-rapidata/rapidata_client/country_codes/country_codes.py,sha256=ePHqeb7y9DWQZAnddBzPx1puYBcrgUjdR2sbFijuFD8,283
 rapidata/rapidata_client/datapoints/__init__.py,sha256=pRjH6YQLbIHOumykMgplKxFfhj6g7a2Dh2FPdFNyNsg,222
 rapidata/rapidata_client/datapoints/_asset_uploader.py,sha256=ie9MZfzhxa0ZrRveJ516cgwvA6QIeVIxN3g5ikwLOH0,2605
 rapidata/rapidata_client/datapoints/_datapoint.py,sha256=ZRsZJRy3r4zZOMAgcMgNd7crqMDcj7qxuYfkEbU8bWk,2929
@@ -628,39 +626,39 @@ rapidata/rapidata_client/datapoints/assets/__init__.py,sha256=47DEQpj8HBSa-_TImW
 rapidata/rapidata_client/datapoints/assets/constants.py,sha256=AwQGQyPqQ1ozAhFdQvRYWi-DUcRQ32jJD4tWy7htQfs,257
 rapidata/rapidata_client/datapoints/metadata/__init__.py,sha256=RC0x5Qr5JUII9ItmPMrRB7EtGtJmO-yquUfbrdCx7EM,368
 rapidata/rapidata_client/datapoints/metadata/_base_metadata.py,sha256=t2kFqaz5BkEaYYj93Pw3h7zWVDq_S5ZkDxjDIRd21_I,189
-rapidata/rapidata_client/datapoints/metadata/_media_asset_metadata.py,sha256=Qq6M_FPEryd9YjZ3-5ZGfXM6xKh-j1pN-xorHxFyq0E,828
-rapidata/rapidata_client/datapoints/metadata/_private_text_metadata.py,sha256=pQWyOy1icL9071OEcFRjmFqclTHV8SgcBcLjV7q61Us,546
-rapidata/rapidata_client/datapoints/metadata/_prompt_identifier_metadata.py,sha256=TjnxZ4YpJUUu4pnoFZTySTV7z3PsA8d2Kuywe8rFRG8,497
-rapidata/rapidata_client/datapoints/metadata/_prompt_metadata.py,sha256=U5-lSZ-RSiFc5pOXai9-a9nDfArO413D1AYIpVr2Txg,572
-rapidata/rapidata_client/datapoints/metadata/_public_text_metadata.py,sha256=tX8GIOQzMsbHlchJqaR7k_9I74z52aXMeYudvx56YYU,540
-rapidata/rapidata_client/datapoints/metadata/_select_words_metadata.py,sha256=T8wnF_QOssDxXbD646QczDZ-IWToly1JvSvd8w5qvdc,605
+rapidata/rapidata_client/datapoints/metadata/_media_asset_metadata.py,sha256=nhP71MW5gyJIPmd4cmFsqnIQ6feqBckWXpkXxdGsHtw,766
+rapidata/rapidata_client/datapoints/metadata/_private_text_metadata.py,sha256=vuvGs1NKPLBqhm2S-UCMvKaZ9MoGJ2CtWDr20yUOk-M,477
+rapidata/rapidata_client/datapoints/metadata/_prompt_identifier_metadata.py,sha256=m8-3lvexHIf79U4KO53qNRvGsCQJ2f-hb2pozoCvNyU,452
+rapidata/rapidata_client/datapoints/metadata/_prompt_metadata.py,sha256=rHfwP89kpNMN0rKCCKXyMcc5scnI07d9nhqZZct56Oo,437
+rapidata/rapidata_client/datapoints/metadata/_public_text_metadata.py,sha256=pNwOdeh41iMbDAMlzoAfwU4Sf7dyV_LrJ4m6aSAZkN8,471
+rapidata/rapidata_client/datapoints/metadata/_select_words_metadata.py,sha256=v8SHwxU1yh7FqrjDmMqYiX1tM5iN5YXJOOHeLW5AJzg,558
 rapidata/rapidata_client/demographic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rapidata/rapidata_client/demographic/demographic_manager.py,sha256=l-QXPTzV_oJpQA2l902x4zmaDdqoPNTjEk-hYH6XOSY,1828
+rapidata/rapidata_client/demographic/demographic_manager.py,sha256=qMqBOFzpcMUnmAYZANaaE3DPwGlq6cfE_RWdHuvQBZ0,1800
 rapidata/rapidata_client/exceptions/__init__.py,sha256=2hbWRgjlCGuoLPVDloQmmH81uzm9F2OAX2iFGCJyRu8,59
 rapidata/rapidata_client/exceptions/failed_upload_exception.py,sha256=m_HE-JOzbNxMsLhaFENM4pgV9dknACc7p6jcvpzsBJQ,675
 rapidata/rapidata_client/filter/__init__.py,sha256=j_Kfz_asNVxwp56SAN2saB7ZAHg3smL5_W2sSitmuJY,548
-rapidata/rapidata_client/filter/_base_filter.py,sha256=NVa2oWgtXD9kmXWyMkYZZ-2RYzgcN0hO76uGrEXXLEs,2384
-rapidata/rapidata_client/filter/age_filter.py,sha256=mVZaKyBoK-mml_oFox97l1yUXvINPk-2cEimuU_FJac,908
-rapidata/rapidata_client/filter/and_filter.py,sha256=6RL4hbC6UjiC_ID8Oc2OaFz_QlDFIRtxODL65eK62yI,1586
-rapidata/rapidata_client/filter/campaign_filter.py,sha256=jvcQWwVb_L9Vl3R7hojzwLQbi0HKigGsSVR8JtZzR2Y,930
-rapidata/rapidata_client/filter/country_filter.py,sha256=bRxRVXcpH2vkAGZUZ9rQdyXpdWewUYQvVBIkHdbE-9Q,1137
-rapidata/rapidata_client/filter/custom_filter.py,sha256=TGbqTUm7UAhbYLSGRpi04EqZMb8AQNHEcExeJ81LNf0,1109
-rapidata/rapidata_client/filter/gender_filter.py,sha256=vzGE2qf9EpI_D_ynfur2--LSzBUaA5waVS86t6-vAYg,887
-rapidata/rapidata_client/filter/language_filter.py,sha256=BoHBagrPfUurNOjGEY3tCd4Ao4aoRlwHwys9IEg-8_k,1429
+rapidata/rapidata_client/filter/_base_filter.py,sha256=Axfi7kb303p-oQWRc22Ge22NpylKyqixQOVF_4NWg1Q,2300
+rapidata/rapidata_client/filter/age_filter.py,sha256=fBfiAUcUYMz7bIyKgFuD1r_TvBj0ujR-RUBQrcsg5tE,760
+rapidata/rapidata_client/filter/and_filter.py,sha256=bc3BjeJChbW87wQdymg_YKU5dO8c3pNDLprdQje-dIM,1329
+rapidata/rapidata_client/filter/campaign_filter.py,sha256=rZQ7aw5rXRJrAgU0MjytgJDREClQ0MxA8KHGe-ndiV0,688
+rapidata/rapidata_client/filter/country_filter.py,sha256=P8QbANGHArtB0eGYDFgfNpjByBBpYO4Cp_pRIDWIwfc,1242
+rapidata/rapidata_client/filter/custom_filter.py,sha256=27hWLuAe39uxFuE--ifI19nx8x2N8jDz_B68-dubmPg,811
+rapidata/rapidata_client/filter/gender_filter.py,sha256=_MIrJ2GbzCvHmVE4v7lJf4qxHzegTFchRS_vZDmS7CE,752
+rapidata/rapidata_client/filter/language_filter.py,sha256=9WK2TTGsqMzJR7nGVne9njHzVk5t_7NiMcIasl6vrKc,1475
 rapidata/rapidata_client/filter/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rapidata/rapidata_client/filter/models/age_group.py,sha256=nmsT7DOsngNoJ4SeYy_C92VOjNnZOfNiIM0HTGfzWbc,1191
 rapidata/rapidata_client/filter/models/gender.py,sha256=oG2AgpRasK1YYkEivFzccjaifWmfCW61Um4APvaWV1g,621
 rapidata/rapidata_client/filter/new_user_filter.py,sha256=HT0gXct1j2_0AdbSn-9DhrwWtLSGLECWNGZKQCoglFM,344
-rapidata/rapidata_client/filter/not_filter.py,sha256=PlVcMMuByBJ4iaZoFD8QHTdgLtgSBWcHV0vcRCc7fv0,1376
-rapidata/rapidata_client/filter/or_filter.py,sha256=4SDVWRh2yv87GjwGpQBIVyuZ23MqyDVpb9pQKuFLzLU,1580
+rapidata/rapidata_client/filter/not_filter.py,sha256=_ruxjgktj7cPIvel695sKYHYEqRsMlWhuJX-COlDL7w,1153
+rapidata/rapidata_client/filter/or_filter.py,sha256=veiKokeoq5v9tz13UKuL_UQLin7B_JiWcLSDsoRRQEU,1302
 rapidata/rapidata_client/filter/rapidata_filters.py,sha256=B8ptQsaAn1e14Grv8xBYQ4qcU0Vt2VTjEpkk-tyOCTo,2201
-rapidata/rapidata_client/filter/response_count_filter.py,sha256=i2u2YQD3_RLQRZyqAceAGLQS3es97Q2n8KTlgfDYMko,2332
-rapidata/rapidata_client/filter/user_score_filter.py,sha256=4B3Zzp7aosDFmte3nLPTlXMN4zatT6Wcq5QLIoXqhgI,1910
+rapidata/rapidata_client/filter/response_count_filter.py,sha256=ncOF8eI1KnWnyfnnFbZiwG-czIHi1Mb6U4Sgmj9keGM,1975
+rapidata/rapidata_client/filter/user_score_filter.py,sha256=JmmJxfH0UZ24TJywPWMLkRucWyASp5ToOVITr7FAzkw,1678
 rapidata/rapidata_client/order/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-rapidata/rapidata_client/order/_rapidata_order_builder.py,sha256=RZwRyPzxR_D3aVZU-K98-FqIbOpzXNmmkJzzmYwYJnU,16828
+rapidata/rapidata_client/order/_rapidata_order_builder.py,sha256=FTJJRCW9KehIlqELOXmKeLhuGcLj9m9ImEU1agOIRa4,16915
 rapidata/rapidata_client/order/dataset/_rapidata_dataset.py,sha256=8EhoRVBxWMbp1mtS56Uogg2dwFC2vySw5hNqTPDTHzM,6345
 rapidata/rapidata_client/order/rapidata_order.py,sha256=w41HUWE6q9L2Stx0ScZdKb7qLjWFIUPMMDOe2fElLvM,14481
-rapidata/rapidata_client/order/rapidata_order_manager.py,sha256=_IS2ONiINmq4ga_2oWsbSluwC-SEv03yo_aKWluOGQk,40823
+rapidata/rapidata_client/order/rapidata_order_manager.py,sha256=Ya8s40hzigIIpo9WphL67sguuqY_3q-Z4AL8IHmX-ZI,41028
 rapidata/rapidata_client/order/rapidata_results.py,sha256=weL4S14fzug3ZOJbQk9Oj-4tv2jx5aZAMp7VJ-a6Qq4,8437
 rapidata/rapidata_client/rapidata_client.py,sha256=5BJMstjJFmBwkflC_YnzlhoOF3SKP3u2wQ56G_hvB3Q,5862
 rapidata/rapidata_client/referee/__init__.py,sha256=J8oZJNUduPr-Tmn8iJwR-qBiSv7owhUFcEzXTRETecw,155
@@ -702,22 +700,22 @@ rapidata/rapidata_client/validation/rapids/rapids.py,sha256=E4O4p2br0g9lgB3tOdfE
 rapidata/rapidata_client/validation/rapids/rapids_manager.py,sha256=YqGxnqJ2vYfAywXJDujQEBrYnlf0URdLxQ7hTR1JeOI,16225
 rapidata/rapidata_client/validation/validation_set_manager.py,sha256=uBKdf-13LKeetvVz425292L6jSYBNrsM08S-n9xEXAw,35099
 rapidata/rapidata_client/workflow/__init__.py,sha256=6kfMN7TQVpiQNGjNHg3X7KdnCyYe3K2TIq7ZVEatQcU,476
-rapidata/rapidata_client/workflow/_base_workflow.py,sha256=UoB9mh0azAf8_IgH6ujGsRQS9PxSiVCSDsAfLjV7wgM,1570
-rapidata/rapidata_client/workflow/_classify_workflow.py,sha256=gJ-Us3bCzbgiTyIKWLFjCJQS6ClqAnObLtZgCJGUASI,2546
-rapidata/rapidata_client/workflow/_compare_workflow.py,sha256=AwLlV6246Nd2PvsTUw4loZekK44HANv_pNOZWkPWZiE,2177
-rapidata/rapidata_client/workflow/_draw_workflow.py,sha256=CKbNGp1NdlvipO_Rc-We_JkocRsE2NY32iXg-pPBvtM,1347
-rapidata/rapidata_client/workflow/_evaluation_workflow.py,sha256=3b71NpxAdmYfRTZCZHq-UoQFqY7CDlMup6VwE7412kc,1732
-rapidata/rapidata_client/workflow/_free_text_workflow.py,sha256=d5vZDZ_ZdzP4Crecm-cm-vBhkJkx5EPtAFAuSVH2EwI,2664
-rapidata/rapidata_client/workflow/_locate_workflow.py,sha256=zqE5XZALqdcyEW_e_gVF61pLOmt85O7sDRU28qLuAa4,1371
-rapidata/rapidata_client/workflow/_ranking_workflow.py,sha256=Rtc-Yj99gpM3JY4hH7QqGeL0o5LSClv2xxNCl-9leVA,4436
-rapidata/rapidata_client/workflow/_select_words_workflow.py,sha256=huxVRP4G9nhHr3i37A9r91SHSUq5YXTvC0qe92W9RGM,2210
-rapidata/rapidata_client/workflow/_timestamp_workflow.py,sha256=k1MZ1_nYysibDYWJ5aogiIOjRYFiFTTEnxsK2kCXAtw,1774
+rapidata/rapidata_client/workflow/_base_workflow.py,sha256=ctbCiQ1VKR9mTKl3MRubtSChrPcbjjZ-xP61f1PBBwc,1643
+rapidata/rapidata_client/workflow/_classify_workflow.py,sha256=KDdASQL9u-PSosHrtvKAYc5P_Hy94RcB16gK2RtbacE,2619
+rapidata/rapidata_client/workflow/_compare_workflow.py,sha256=Yf8NLxrK8MHbmXLvghy3-xvQosVW3CpYy9uRO1y2xpg,2250
+rapidata/rapidata_client/workflow/_draw_workflow.py,sha256=O7r_bltnGfxQV_TOzyC_5Z2-VeAPH-yMSA5WDEu4NzE,1415
+rapidata/rapidata_client/workflow/_evaluation_workflow.py,sha256=F4-K-bDYh9qjq8S_L8VL5E9pzAO1iTRec47srFVTL3U,1790
+rapidata/rapidata_client/workflow/_free_text_workflow.py,sha256=pf2z2lanj7v6Zo-nYc0x8XVghK4JfX7bfsHk-TVOV1c,2737
+rapidata/rapidata_client/workflow/_locate_workflow.py,sha256=7UXapQBmuUsFMpvG6TPk0D9g9PrCa9y92Y4nb1ecjcw,1439
+rapidata/rapidata_client/workflow/_ranking_workflow.py,sha256=4a9bK-AQJ_q9ud0u6vMfBaTgOdgd9nR35nN9S6Z3KUk,4569
+rapidata/rapidata_client/workflow/_select_words_workflow.py,sha256=b3APwuDuMphtOVefOaaOVebcaRcnnVQ6NltZkEPXnCo,2283
+rapidata/rapidata_client/workflow/_timestamp_workflow.py,sha256=totcKhAItkPS7HMrjbr6_CGgKMKzohzpdCxMu0X-vCw,1847
 rapidata/service/__init__.py,sha256=ULBu1tCwgp055OifUXZKtExkzqXeTa_LRROzjMWAd90,69
 rapidata/service/credential_manager.py,sha256=T3yL4tXVnibRytxjQkOC-ex3kFGQR5KcKUUAtao4PFw,8698
 rapidata/service/local_file_service.py,sha256=0Q4LdoEtPFKzgXK2oZ1cQ-X7FipakscjGnnBH8dRFRQ,855
 rapidata/service/openapi_service.py,sha256=E2zVagI_ri15PK06ITO_VNKYDJ0VZQG1YQ1T6bEIVsY,5566
-rapidata/types/__init__.py,sha256=gSGrmWV5gEA6pPfAR5vwSy_DvibO5IjCZDiB7LtlMOQ,6134
-rapidata-2.42.2.dist-info/METADATA,sha256=E5-4G2VCDEv5xV4NuLau3VIG3Cb66V8VT6qTH1fTOeY,1479
-rapidata-2.42.2.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-rapidata-2.42.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-rapidata-2.42.2.dist-info/RECORD,,
+rapidata/types/__init__.py,sha256=NLRuTGbTImRv3yIp8we_oqVvCuBd7TDNVlAzkVGs9oo,6056
+rapidata-2.42.4.dist-info/METADATA,sha256=e6zUfiBRzdClJ3UEBQ8uV5QrDgUY_OJHfOwTQ5hnN94,1479
+rapidata-2.42.4.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+rapidata-2.42.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+rapidata-2.42.4.dist-info/RECORD,,

rapidata/rapidata_client/country_codes/__init__.py

@@ -1 +0,0 @@
-from .country_codes import CountryCodes

rapidata/rapidata_client/country_codes/country_codes.py

@@ -1,19 +0,0 @@
-class CountryCodes:
-
-    ENGLISH_SPEAKING = [
-        "AU",
-        "BE",
-        "CA",
-        "DK",
-        "FI",
-        "IE",
-        "LU",
-        "NL",
-        "NZ",
-        "NO",
-        "SG",
-        "SE",
-        "GB",
-        "US",
-    ]
-    GERMAN_SPEAKING = ["AT", "DE"]