rapidata 1.1.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

rapidata/rapidata_client/order/rapidata_order_builder.py

@@ -28,6 +28,10 @@ from rapidata.service.openapi_service import OpenAPIService
 
 from rapidata.rapidata_client.workflow.compare_workflow import CompareWorkflow
 
+from rapidata.rapidata_client.assets import MediaAsset, TextAsset, MultiAsset
+
+from typing import cast, Sequence
+
 
 class RapidataOrderBuilder:
     """Builder object for creating Rapidata orders.
@@ -55,7 +59,6 @@ class RapidataOrderBuilder:
         self._openapi_service = openapi_service
         self._workflow: Workflow | None = None
         self._referee: Referee | None = None
-        self._media_paths: list[str | list[str]] = []
         self._metadata: list[Metadata] | None = None
         self._aggregator: AggregatorType | None = None
         self._validation_set_id: str | None = None
@@ -65,8 +68,7 @@ class RapidataOrderBuilder:
         self._selections: list[Selection] = []
         self._rapids_per_bag: int = 2
         self._priority: int = 50
-        self._texts: list[str] | None = None
-        self._media_paths: list[str | list[str]] = []
+        self._assets: list[MediaAsset] | list[TextAsset] | list[MultiAsset] = []
 
     def _to_model(self) -> CreateOrderModel:
         """
@@ -139,13 +141,17 @@ class RapidataOrderBuilder:
         Returns:
             RapidataOrder: The created RapidataOrder instance.
         """
+        if not self._workflow or not self._assets:
+            raise ValueError(
+                "You must provide a workflow and assets to create an order. Use the .workflow() and .media() methods respecitvely."
+            )
         order_model = self._to_model()
         if isinstance(
             self._workflow, CompareWorkflow
         ):  # Temporary fix; will be handled by backend in the future
-            assert all(
-                [len(path) == 2 for path in self._media_paths]
-            ), "The media paths must come in pairs for comparison tasks."
+            assert all(isinstance(item, MultiAsset) for item in self._assets), (
+                "The media paths must be of type MultiAsset for comparison tasks."
+            )
 
         result = self._openapi_service.order_api.order_create_post(
             create_order_model=order_model
@@ -159,23 +165,38 @@ class RapidataOrderBuilder:
             openapi_service=self._openapi_service,
         )
 
-        if self._media_paths and self._texts:
-            raise ValueError(
-                "You cannot provide both media paths and texts to the same order."
-            )
-
-        if not self._media_paths and not self._texts:
-            raise ValueError(
-                "You must provide either media paths or texts to the order."
+        if all(isinstance(item, MediaAsset) for item in self._assets):
+            assets = cast(list[MediaAsset], self._assets)
+            order.dataset.add_media_from_paths(
+                assets, self._metadata, max_workers
             )
+        
+        elif all(isinstance(item, TextAsset) for item in self._assets):
+            assets = cast(list[TextAsset], self._assets)
+            order.dataset.add_texts(assets)
+
+        elif all(isinstance(item, MultiAsset) for item in self._assets):
+            multi_assets = cast(list[MultiAsset], self._assets)
+            
+            # Check if all MultiAssets contain the same type of assets
+            first_asset_type = type(multi_assets[0].assets[0])
+            if not all(isinstance(asset, first_asset_type) for multi_asset in multi_assets for asset in multi_asset.assets):
+                raise ValueError("All MultiAssets must contain the same type of assets (either all MediaAssets or all TextAssets).")
+            
+            # Process based on the asset type
+            if issubclass(first_asset_type, MediaAsset):
+                order.dataset.add_media_from_paths(
+                    multi_assets, self._metadata, max_workers
+                )
 
-        if self._texts:
-            order.dataset.add_texts(self._texts)
+            elif issubclass(first_asset_type, TextAsset):
+                order.dataset.add_texts(multi_assets)
 
-        if self._media_paths:
-            order.dataset.add_media_from_paths(
-                self._media_paths, self._metadata, max_workers
-            )
+            else:
+                raise ValueError("MultiAsset must contain MediaAssets or TextAssets objects.")
+        
+        else:
+            raise ValueError("Media paths must be of type MediaAsset, TextAsset, or MultiAsset.")
 
         if submit:
             order.submit()
@@ -192,6 +213,9 @@ class RapidataOrderBuilder:
         Returns:
             RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
         """
+        if not isinstance(workflow, Workflow):
+            raise TypeError("Workflow must be of type Workflow.")
+        
         self._workflow = workflow
         return self
 
@@ -205,39 +229,41 @@ class RapidataOrderBuilder:
         Returns:
             RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
         """
+        if not isinstance(referee, Referee):
+            raise TypeError("Referee must be of type Referee.")
+        
         self._referee = referee
         return self
 
     def media(
         self,
-        media_paths: list[str | list[str]],
-        metadata: list[Metadata] | None = None,
+        asset: list[MediaAsset] | list[TextAsset] | list[MultiAsset],
+        metadata: Sequence[Metadata] | None = None,
     ) -> "RapidataOrderBuilder":
         """
         Set the media assets for the order.
 
         Args:
-            media_paths (list[str | list[str]]): The paths of the media assets to be set.
+            media_paths (list[MediaAsset] | list[TextAsset] | list[MultiAsset]): The paths of the media assets to be set.
             metadata (list[Metadata] | None, optional): Metadata for the media assets. Defaults to None.
 
         Returns:
             RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
         """
-        self._media_paths = media_paths
-        self._metadata = metadata
-        return self
-
-    def texts(self, texts: list[str]) -> "RapidataOrderBuilder":
-        """
-        Set the TextAssets for the order.
-
-        Args:
-            texts (list[str]): The texts to be set.
-
-        Returns:
-            RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
-        """
-        self._texts = texts
+        if not isinstance(asset, list):
+            raise TypeError("Media paths must be provided as a list of paths.")
+
+        for a in asset:
+            if not isinstance(a, (MediaAsset, TextAsset, MultiAsset)):
+                raise TypeError("Media paths must be of type MediaAsset, TextAsset, or MultiAsset.")
+
+        if metadata:
+            for data in metadata:
+                if not isinstance(data, Metadata):
+                    raise TypeError("Metadata must be of type Metadata.")
+        
+        self._assets = asset
+        self._metadata = metadata # type: ignore
         return self
 
     def feature_flags(self, feature_flags: FeatureFlags) -> "RapidataOrderBuilder":
@@ -250,6 +276,9 @@ class RapidataOrderBuilder:
         Returns:
             RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
         """
+        if not isinstance(feature_flags, FeatureFlags):
+            raise TypeError("Feature flags must be of type FeatureFlags.")
+        
         self._feature_flags = feature_flags
         return self
 
@@ -263,6 +292,13 @@ class RapidataOrderBuilder:
         Returns:
             RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
         """
+        if not isinstance(country_codes, list):
+            raise TypeError("Country codes must be provided as a list of strings.")
+        
+        for code in country_codes:
+            if not isinstance(code, str):
+                raise TypeError("Country codes must be of type str.")
+            
         self._country_codes = country_codes
         return self
 
@@ -276,6 +312,12 @@ class RapidataOrderBuilder:
         Returns:
             RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
         """
+        if not isinstance(language_codes, list):
+            raise TypeError("Language codes must be provided as a list of strings.")
+        
+        if not all(isinstance(code, str) for code in language_codes):
+            raise TypeError("Language codes must be of type str.")
+        
         self._language_codes = language_codes
         return self
 
@@ -289,6 +331,9 @@ class RapidataOrderBuilder:
         Returns:
             RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
         """
+        if not isinstance(aggregator, AggregatorType):
+            raise TypeError("Aggregator must be of type AggregatorType.")
+        
         self._aggregator = aggregator
         return self
 
@@ -302,6 +347,9 @@ class RapidataOrderBuilder:
         Returns:
             RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
         """
+        if not isinstance(validation_set_id, str):
+            raise TypeError("Validation set ID must be of type str.")
+        
         self._validation_set_id = validation_set_id
         return self
 
@@ -320,17 +368,24 @@ class RapidataOrderBuilder:
         """
         raise NotImplementedError("Not implemented yet.")
 
-    def selections(self, selections: list[Selection]) -> "RapidataOrderBuilder":
+    def selections(self, selections: Sequence[Selection]) -> "RapidataOrderBuilder":
         """
         Set the selections for the order.
 
         Args:
-            selections (list[Selection]): The selections to be set.
+            selections (Sequence[Selection]): The selections to be set.
 
         Returns:
             RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
         """
-        self._selections = selections
+        if not isinstance(selections, list):
+            raise TypeError("Selections must be provided as a list of Selection objects.")
+        
+        for selection in selections:
+            if not isinstance(selection, Selection):
+                raise TypeError("Selections must be of type Selection.")
+        
+        self._selections = selections # type: ignore
         return self
 
     def priority(self, priority: int) -> "RapidataOrderBuilder":
@@ -343,5 +398,8 @@ class RapidataOrderBuilder:
         Returns:
             RapidataOrderBuilder: The updated RapidataOrderBuilder instance.
         """
+        if not isinstance(priority, int):
+            raise TypeError("Priority must be of type int.")
+        
         self._priority = priority
         return self

rapidata/rapidata_client/selection/__init__.py

@@ -3,3 +3,4 @@ from .demographic_selection import DemographicSelection
 from .labeling_selection import LabelingSelection
 from .validation_selection import ValidationSelection
 from .conditional_validation_selection import ConditionalValidationSelection
+from .capped_selection import CappedSelection

rapidata/rapidata_client/selection/capped_selection.py

@@ -0,0 +1,25 @@
+from rapidata.api_client.models.capped_selection import (
+    CappedSelection as CappedSelectionModel,
+)
+from rapidata.api_client.models.capped_selection_selections_inner import (
+    CappedSelectionSelectionsInner,
+)
+from rapidata.rapidata_client.selection.base_selection import Selection
+from typing import Sequence
+
+
+class CappedSelection(Selection):
+
+    def __init__(self, selections: Sequence[Selection], max_rapids: int):
+        self.selections = selections
+        self.max_rapids = max_rapids
+
+    def to_model(self):
+        return CappedSelectionModel(
+            _t="CappedSelection",
+            selections=[
+                CappedSelectionSelectionsInner(selection.to_model())
+                for selection in self.selections
+            ],
+            max_rapids=self.max_rapids,
+        )

rapidata/rapidata_client/selection/demographic_selection.py

@@ -5,8 +5,9 @@ from rapidata.api_client.models.demographic_selection import DemographicSelectio
 class DemographicSelection(Selection):
     """Demographic selection class."""
 
-    def __init__(self, keys: list[str]):
+    def __init__(self, keys: list[str], maxRapids: int):
         self.keys = keys
+        self.maxRapids = maxRapids
 
     def to_model(self):
-        return DemographicSelectionModel(_t="DemographicSelection", keys=self.keys)
+        return DemographicSelectionModel(_t="DemographicSelection", keys=self.keys, maxRapids=self.maxRapids)

rapidata/rapidata_client/simple_builders/simple_classification_builders.py

@@ -7,6 +7,8 @@ from rapidata.rapidata_client.workflow.classify_workflow import ClassifyWorkflow
 from rapidata.rapidata_client.selection.validation_selection import ValidationSelection
 from rapidata.rapidata_client.selection.labeling_selection import LabelingSelection
 from rapidata.service.openapi_service import OpenAPIService
+from rapidata.rapidata_client.assets import MediaAsset
+from typing import Sequence
 
 class ClassificationOrderBuilder:
     def __init__(self, name: str, question: str, options: list[str], media_paths: list[str], openapi_service: OpenAPIService):
@@ -19,7 +21,7 @@ class ClassificationOrderBuilder:
         self._metadata = None
         self._validation_set_id = None
 
-    def metadata(self, metadata: list[Metadata]):
+    def metadata(self, metadata: Sequence[Metadata]):
         """Set the metadata for the classification order. Has to be the same lenght as the media paths."""
         self._metadata = metadata
         return self
@@ -28,27 +30,29 @@ class ClassificationOrderBuilder:
         """Set the number of responses required for the classification order."""
         self._responses_required = responses_required
         return self
-    
+
     def probability_threshold(self, probability_threshold: float):
         """Set the probability threshold for early stopping."""
         self._probability_threshold = probability_threshold
         return self
-    
+
     def validation_set_id(self, validation_set_id: str):
         """Set the validation set ID for the classification order."""
         self._validation_set_id = validation_set_id
         return self
-    
+
     def create(self, submit: bool = True, max_upload_workers: int = 10):
         if self._probability_threshold and self._responses_required:
             referee = ClassifyEarlyStoppingReferee(
                 max_vote_count=self._responses_required,
                 threshold=self._probability_threshold
             )
-            
+
         else:
             referee = NaiveReferee(required_guesses=self._responses_required)
-        
+
+        assets = [MediaAsset(path=media_path) for media_path in self._media_paths]
+
         selection: list[Selection] = ([ValidationSelection(amount=1, validation_set_id=self._validation_set_id), LabelingSelection(amount=2)] 
                      if self._validation_set_id 
                      else [LabelingSelection(amount=3)])
@@ -61,14 +65,15 @@ class ClassificationOrderBuilder:
                 )
             )
             .referee(referee)
-            .media(self._media_paths, metadata=self._metadata) # type: ignore
+            .media(assets, metadata=self._metadata) # type: ignore
             .selections(selection)
             .create(submit=submit, max_workers=max_upload_workers))
 
         return order 
-    
+
 
 class ClassificationMediaBuilder:
+    "test"
     def __init__(self, name: str, question: str, options: list[str], openapi_service: OpenAPIService):
         self._openapi_service = openapi_service
         self._name = name
@@ -85,7 +90,7 @@ class ClassificationMediaBuilder:
         if self._media_paths is None:
             raise ValueError("Media paths are required")
         return ClassificationOrderBuilder(self._name, self._question, self._options, self._media_paths, openapi_service=self._openapi_service)
-    
+
 
 class ClassificationOptionsBuilder:
     def __init__(self, name: str, question: str, openapi_service: OpenAPIService):

rapidata/rapidata_client/simple_builders/simple_compare_builders.py

@@ -1,11 +1,13 @@
 from rapidata.service.openapi_service import OpenAPIService
-from rapidata.rapidata_client.metadata.base_metadata import Metadata
+from rapidata.rapidata_client.metadata import Metadata
 from rapidata.rapidata_client.order.rapidata_order_builder import RapidataOrderBuilder
 from rapidata.rapidata_client.workflow.compare_workflow import CompareWorkflow
 from rapidata.rapidata_client.referee.naive_referee import NaiveReferee
 from rapidata.rapidata_client.selection.validation_selection import ValidationSelection
 from rapidata.rapidata_client.selection.labeling_selection import LabelingSelection
 from rapidata.rapidata_client.selection.base_selection import Selection
+from rapidata.rapidata_client.assets import MultiAsset, MediaAsset
+from typing import Sequence
 
 class CompareOrderBuilder:
     def __init__(self, name:str, criteria: str, media_paths: list[list[str]], openapi_service: OpenAPIService):
@@ -22,7 +24,7 @@ class CompareOrderBuilder:
         self._responses_required = responses_required
         return self
     
-    def metadata(self, metadata: list[Metadata]) -> 'CompareOrderBuilder':
+    def metadata(self, metadata: Sequence[Metadata]) -> 'CompareOrderBuilder':
         """Set the metadata for the comparison order. Has to be the same shape as the media paths."""
         self._metadata = metadata
         return self
@@ -37,6 +39,7 @@ class CompareOrderBuilder:
                      if self._validation_set_id 
                      else [LabelingSelection(amount=3)])
         
+        media_paths = [MultiAsset([MediaAsset(path=path) for path in paths]) for paths in self._media_paths]
         order = (self._order_builder
             .workflow(
                 CompareWorkflow(
@@ -44,7 +47,7 @@ class CompareOrderBuilder:
                 )
             )
             .referee(NaiveReferee(required_guesses=self._responses_required))
-            .media(self._media_paths, metadata=self._metadata) # type: ignore
+            .media(media_paths, metadata=self._metadata) # type: ignore
             .selections(selection)
             .create(submit=submit, max_workers=max_upload_workers))
         

rapidata/service/openapi_service.py

@@ -5,6 +5,9 @@ from rapidata.api_client.api.rapid_api import RapidApi
 from rapidata.api_client.api.validation_api import ValidationApi
 from rapidata.api_client.api_client import ApiClient
 from rapidata.api_client.configuration import Configuration
+from rapidata.api_client.api.campaign_api import CampaignApi
+from rapidata.api_client.api.pipeline_api import PipelineApi
+from rapidata.api_client.api.workflow_api import WorkflowApi
 
 
 class OpenAPIService:
@@ -45,3 +48,15 @@ class OpenAPIService:
     @property
     def rapid_api(self) -> RapidApi:
         return RapidApi(self.api_client)
+    
+    @property
+    def campaign_api(self) -> CampaignApi:
+        return CampaignApi(self.api_client)
+    
+    @property
+    def pipeline_api(self) -> PipelineApi:
+        return PipelineApi(self.api_client)
+    
+    @property
+    def workflow_api(self) -> WorkflowApi:
+        return WorkflowApi(self.api_client)

{rapidata-1.1.0.dist-info → rapidata-1.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rapidata
-Version: 1.1.0
+Version: 1.2.1
 Summary: Rapidata package containing the Rapidata Python Client to interact with the Rapidata Web API in an easy way.
 License: Apache-2.0
 Author: Rapidata AG