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

rapidata/rapidata_client/demographic/demographic_manager.py

@@ -1,29 +1,31 @@
 from rapidata.service.openapi_service import OpenAPIService
 from rapidata.rapidata_client.datapoints.assets import MediaAsset
-from rapidata.api_client.models.create_demographic_rapid_model import CreateDemographicRapidModel
+from rapidata.api_client.models.create_demographic_rapid_model import (
+    CreateDemographicRapidModel,
+)
 from rapidata.api_client.models.classify_payload import ClassifyPayload
-from rapidata.rapidata_client.logging import logger
+from rapidata.rapidata_client.config import logger
+
 
 class DemographicManager:
     def __init__(self, openapi_service: OpenAPIService):
         self._openapi_service = openapi_service
         logger.debug("DemographicManager initialized")
-    
-    def create_demographic_rapid(self, 
-                                 instruction: str,
-                                 answer_options: list[str],
-                                 datapoint: str,
-                                 key: str):
-        
+
+    def create_demographic_rapid(
+        self, instruction: str, answer_options: list[str], datapoint: str, key: str
+    ):
+
         media = MediaAsset(path=datapoint)
         model = CreateDemographicRapidModel(
             key=key,
             payload=ClassifyPayload(
                 _t="ClassifyPayload",
                 possibleCategories=answer_options,
-                title=instruction
-            )
+                title=instruction,
+            ),
+        )
+
+        self._openapi_service.rapid_api.rapid_demographic_post(
+            model=model, file=[media.to_file()]
         )
-        
-        self._openapi_service.rapid_api.rapid_demographic_post(model=model, file=[media.to_file()])
-        

rapidata/rapidata_client/filter/_base_filter.py

@@ -13,9 +13,9 @@ class RapidataFilter:
         """Enable the | operator to create OrFilter combinations."""
         if not isinstance(other, RapidataFilter):
             return NotImplemented
-        
+
         from rapidata.rapidata_client.filter.or_filter import OrFilter
-        
+
         # If self is already an OrFilter, extend its filters list
         if isinstance(self, OrFilter):
             if isinstance(other, OrFilter):
@@ -33,9 +33,9 @@ class RapidataFilter:
         """Enable the & operator to create AndFilter combinations."""
         if not isinstance(other, RapidataFilter):
             return NotImplemented
-        
+
         from rapidata.rapidata_client.filter.and_filter import AndFilter
-        
+
         # If self is already an AndFilter, extend its filters list
         if isinstance(self, AndFilter):
             if isinstance(other, AndFilter):
@@ -52,10 +52,16 @@ class RapidataFilter:
     def __invert__(self):
         """Enable the ~ operator to create NotFilter negations."""
         from rapidata.rapidata_client.filter.not_filter import NotFilter
-        
+
         # If self is already a NotFilter, return the original filter (double negation)
         if isinstance(self, NotFilter):
             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__}()"

rapidata/rapidata_client/filter/age_filter.py

@@ -6,10 +6,10 @@ from rapidata.rapidata_client.filter.models.age_group import AgeGroup
 
 class AgeFilter(RapidataFilter):
     """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."""
 
@@ -21,3 +21,9 @@ class AgeFilter(RapidataFilter):
             _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

@@ -1,7 +1,9 @@
 from typing import Any
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 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 rapidata.api_client.models.and_user_filter_model_filters_inner import (
+    AndUserFilterModelFiltersInner,
+)
 
 
 class AndFilter(RapidataFilter):
@@ -10,21 +12,34 @@ class AndFilter(RapidataFilter):
 
     Args:
         filters (list[RapidataFilter]): A list of filters to be combined with AND.
-        
+
     Example:
         ```python
         from rapidata import AndFilter, LanguageFilter, CountryFilter
 
-        AndFilter([LanguageFilter(["en"]), CountryFilter(["US"])]) 
+        AndFilter([LanguageFilter(["en"]), CountryFilter(["US"])])
         ```
 
         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")
-        
+
         self.filters = filters
 
     def _to_model(self):
-        return AndUserFilterModel(_t="AndFilter", filters=[AndUserFilterModelFiltersInner(filter._to_model()) for filter in self.filters])
+        return AndUserFilterModel(
+            _t="AndFilter",
+            filters=[
+                AndUserFilterModelFiltersInner(filter._to_model())
+                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

@@ -11,7 +11,7 @@ class CampaignFilter(RapidataFilter):
     Can be used to filter who to target based on campaign IDs.
 
     This filter can only be used when directly in contact with Rapidata.
-    
+
     Args:
         campaign_ids (list[str]): List of campaign IDs to filter by.
     """
@@ -24,3 +24,9 @@ class CampaignFilter(RapidataFilter):
             _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

@@ -7,7 +7,7 @@ class CountryFilter(RapidataFilter):
     """CountryFilter Class
 
     Can be used to filter who to target based on country codes.
-    
+
     Args:
         country_codes (list[str]): List of country codes (capitalized) to filter by.
     """
@@ -16,7 +16,7 @@ class CountryFilter(RapidataFilter):
         # 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")
 
@@ -24,3 +24,9 @@ class CountryFilter(RapidataFilter):
 
     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

@@ -8,10 +8,10 @@ class CustomFilter(RapidataFilter):
 
     Can be used to filter who to target based on custom filters.
 
-    Ought to be used with contact to Rapidata. 
-    
+    Ought to be used with contact to Rapidata.
+
     Warning: If identifier does not exist, order will not get any responses.
-    
+
     Args:
         identifier (str): Identifier of the custom filter.
         values (list[str]): List of values to filter by.
@@ -27,3 +27,9 @@ 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

@@ -6,10 +6,10 @@ from rapidata.rapidata_client.filter.models.gender import Gender
 
 class GenderFilter(RapidataFilter):
     """GenderFilter Class
-    
+
     Can be used to filter who to target based on their gender.
-    
-    
+
+
     Args:
         genders (list[Gender]): List of genders to filter by."""
 
@@ -21,3 +21,9 @@ class GenderFilter(RapidataFilter):
             _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

@@ -7,26 +7,27 @@ from rapidata.api_client.models.language_user_filter_model import (
 
 class LanguageFilter(RapidataFilter):
     """LanguageFilter Class
-    
+
     Can be used to filter who to target based on language codes.
 
     Args:
         language_codes (list[str]): List of language codes to filter by.
-            
-    Example: 
+
+    Example:
         ```python
         LanguageFilter(["en", "de"])
         ```
         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")
@@ -35,3 +36,9 @@ class LanguageFilter(RapidataFilter):
 
     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})"

rapidata/rapidata_client/filter/new_user_filter.py

@@ -1,13 +1,12 @@
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 from rapidata.api_client.models.new_user_filter_model import NewUserFilterModel
 
+
 class NewUserFilter(RapidataFilter):
     """NewUserFilter Class
-    
+
     Can be used to filter new users.
     """
 
     def _to_model(self):
-        return NewUserFilterModel(
-            _t="NewUserFilter"
-        )
+        return NewUserFilterModel(_t="NewUserFilter")

rapidata/rapidata_client/filter/not_filter.py

@@ -1,7 +1,9 @@
 from typing import Any
 from rapidata.rapidata_client.filter._base_filter import RapidataFilter
 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 rapidata.api_client.models.and_user_filter_model_filters_inner import (
+    AndUserFilterModelFiltersInner,
+)
 
 
 class NotFilter(RapidataFilter):
@@ -10,21 +12,31 @@ class NotFilter(RapidataFilter):
 
     Args:
         filter (RapidataFilter): The filter whose condition should be negated.
-        
+
     Example:
         ```python
         from rapidata import NotFilter, LanguageFilter
 
-        NotFilter(LanguageFilter(["en"])) 
+        NotFilter(LanguageFilter(["en"]))
         ```
 
         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")
-        
+
         self.filter = filter
 
     def _to_model(self):
-        return NotUserFilterModel(_t="NotFilter", filter=AndUserFilterModelFiltersInner(self.filter._to_model()))
+        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,7 +1,9 @@
 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 rapidata.api_client.models.and_user_filter_model_filters_inner import (
+    AndUserFilterModelFiltersInner,
+)
 
 
 class OrFilter(RapidataFilter):
@@ -10,21 +12,34 @@ class OrFilter(RapidataFilter):
 
     Args:
         filters (list[RapidataFilter]): A list of filters to be combined with OR.
-        
+
     Example:
         ```python
         from rapidata import OrFilter, LanguageFilter, CountryFilter
 
-        OrFilter([LanguageFilter(["en"]), CountryFilter(["US"])]) 
+        OrFilter([LanguageFilter(["en"]), CountryFilter(["US"])])
         ```
 
         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")
-        
+
         self.filters = filters
 
     def _to_model(self):
-        return OrUserFilterModel(_t="OrFilter", filters=[AndUserFilterModelFiltersInner(filter._to_model()) for filter in self.filters])
+        return OrUserFilterModel(
+            _t="OrFilter",
+            filters=[
+                AndUserFilterModelFiltersInner(filter._to_model())
+                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

@@ -49,3 +49,9 @@ 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

@@ -7,28 +7,34 @@ from rapidata.api_client.models.user_score_user_filter_model import (
 
 class UserScoreFilter(RapidataFilter):
     """UserScoreFilter Class
-    
+
     Can be used to filter who to target based on their user score.
-    
+
     Args:
         lower_bound (float): The lower bound of the user score.
         upper_bound (float): The upper bound of the user score.
         dimension (str): The dimension of the userScore to be considerd for the filter.
 
-    Example: 
+    Example:
         ```python
         UserScoreFilter(0.5, 0.9)
         ```
         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):
+
+    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
@@ -40,3 +46,9 @@ 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_dataset.py

@@ -6,18 +6,17 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 from tqdm import tqdm
 
 from typing import Generator
-from rapidata.rapidata_client.logging import (
-    logger,
-    managed_print,
-    RapidataOutputManager,
-)
+from rapidata.rapidata_client.config import logger, managed_print
 import time
 import threading
-from rapidata.rapidata_client.api.rapidata_exception import (
+from rapidata.rapidata_client.api.rapidata_api_client import (
     suppress_rapidata_error_logging,
 )
 from rapidata.rapidata_client.config.rapidata_config import rapidata_config
 
+# Add OpenTelemetry context imports for thread propagation
+from opentelemetry import context as otel_context
+
 
 def chunk_list(lst: list, chunk_size: int) -> Generator:
     for i in range(0, len(lst), chunk_size):
@@ -62,22 +61,37 @@ class RapidataDataset:
             )
             return datapoint
 
+        def upload_with_context(
+            context: otel_context.Context, datapoint: Datapoint, index: int
+        ) -> Datapoint:
+            """Wrapper function that runs upload_text_datapoint with the provided context."""
+            token = otel_context.attach(context)
+            try:
+                return upload_text_datapoint(datapoint, index)
+            finally:
+                otel_context.detach(token)
+
         successful_uploads: list[Datapoint] = []
         failed_uploads: list[Datapoint] = []
 
+        # Capture the current OpenTelemetry context before creating threads
+        current_context = otel_context.get_current()
+
         total_uploads = len(datapoints)
         with ThreadPoolExecutor(
-            max_workers=rapidata_config.maxUploadWorkers
+            max_workers=rapidata_config.upload.maxWorkers
         ) as executor:
             future_to_datapoint = {
-                executor.submit(upload_text_datapoint, datapoint, index=i): datapoint
+                executor.submit(
+                    upload_with_context, current_context, datapoint, i
+                ): datapoint
                 for i, datapoint in enumerate(datapoints)
             }
 
             with tqdm(
                 total=total_uploads,
                 desc="Uploading text datapoints",
-                disable=RapidataOutputManager.silent_mode,
+                disable=rapidata_config.logging.silent_mode,
             ) as pbar:
                 for future in as_completed(future_to_datapoint.keys()):
                     datapoint = future_to_datapoint[future]
@@ -119,7 +133,7 @@ class RapidataDataset:
         urls = datapoint.get_urls()
 
         last_exception = None
-        for attempt in range(rapidata_config.uploadMaxRetries):
+        for attempt in range(rapidata_config.upload.maxRetries):
             try:
                 with suppress_rapidata_error_logging():
                     self.openapi_service.dataset_api.dataset_dataset_id_datapoints_post(
@@ -136,7 +150,7 @@ class RapidataDataset:
 
             except Exception as e:
                 last_exception = e
-                if attempt < rapidata_config.uploadMaxRetries - 1:
+                if attempt < rapidata_config.upload.maxRetries - 1:
                     # Exponential backoff: wait 1s, then 2s, then 4s
                     retry_delay = 2**attempt
                     time.sleep(retry_delay)
@@ -144,13 +158,13 @@ class RapidataDataset:
                     logger.debug(
                         "Retrying %s of %s...",
                         attempt + 1,
-                        rapidata_config.uploadMaxRetries,
+                        rapidata_config.upload.maxRetries,
                     )
 
         # If we get here, all retries failed
         local_failed.append(datapoint)
         tqdm.write(
-            f"Upload failed for {datapoint} after {rapidata_config.uploadMaxRetries} attempts. \nFinal error: \n{str(last_exception)}"
+            f"Upload failed for {datapoint} after {rapidata_config.upload.maxRetries} attempts. \nFinal error: \n{str(last_exception)}"
         )
 
         return local_successful, local_failed
@@ -183,7 +197,7 @@ class RapidataDataset:
                 with tqdm(
                     total=total_uploads,
                     desc="Uploading datapoints",
-                    disable=RapidataOutputManager.silent_mode,
+                    disable=rapidata_config.logging.silent_mode,
                 ) as pbar:
                     prev_ready = 0
                     prev_failed = 0
@@ -291,17 +305,31 @@ class RapidataDataset:
         successful_uploads: list[Datapoint] = []
         failed_uploads: list[Datapoint] = []
 
+        def process_upload_with_context(
+            context: otel_context.Context, datapoint: Datapoint, index: int
+        ) -> tuple[list[Datapoint], list[Datapoint]]:
+            """Wrapper function that runs _process_single_upload with the provided context."""
+            token = otel_context.attach(context)
+            try:
+                return self._process_single_upload(datapoint, index)
+            finally:
+                otel_context.detach(token)
+
+        # Capture the current OpenTelemetry context before creating threads
+        current_context = otel_context.get_current()
+
         try:
             with ThreadPoolExecutor(
-                max_workers=rapidata_config.maxUploadWorkers
+                max_workers=rapidata_config.upload.maxWorkers
             ) as executor:
                 # Process uploads in chunks to avoid overwhelming the system
                 for chunk_idx, chunk in enumerate(chunk_list(datapoints, chunk_size)):
                     futures = [
                         executor.submit(
-                            self._process_single_upload,
+                            process_upload_with_context,
+                            current_context,
                             datapoint,
-                            index=(chunk_idx * chunk_size + i),
+                            chunk_idx * chunk_size + i,
                         )
                         for i, datapoint in enumerate(chunk)
                     ]