rapidata 2.2.1__tar.gz → 2.3.0__tar.gz

{rapidata-2.2.1 → rapidata-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rapidata
-Version: 2.2.1
+Version: 2.3.0
 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

{rapidata-2.2.1 → rapidata-2.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rapidata"
-version = "2.2.1"
+version = "2.3.0"
 description = "Rapidata package containing the Rapidata Python Client to interact with the Rapidata Web API in an easy way."
 authors = ["Rapidata AG <info@rapidata.ai>"]
 license = "Apache-2.0"

{rapidata-2.2.1 → rapidata-2.3.0}/src/rapidata/api_client/api/client_api.py

@@ -834,3 +834,257 @@ class ClientApi:
         )
 
 
+
+
+    @validate_call
+    def client_set_referrer_post(
+        self,
+        referrer: Optional[StrictStr] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> None:
+        """Sets the referrer for the current customer.
+
+
+        :param referrer: 
+        :type referrer: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._client_set_referrer_post_serialize(
+            referrer=referrer,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': None,
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def client_set_referrer_post_with_http_info(
+        self,
+        referrer: Optional[StrictStr] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[None]:
+        """Sets the referrer for the current customer.
+
+
+        :param referrer: 
+        :type referrer: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._client_set_referrer_post_serialize(
+            referrer=referrer,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': None,
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def client_set_referrer_post_without_preload_content(
+        self,
+        referrer: Optional[StrictStr] = None,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Sets the referrer for the current customer.
+
+
+        :param referrer: 
+        :type referrer: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._client_set_referrer_post_serialize(
+            referrer=referrer,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': None,
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _client_set_referrer_post_serialize(
+        self,
+        referrer,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        # process the query parameters
+        if referrer is not None:
+            
+            _query_params.append(('referrer', referrer))
+            
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'bearer', 
+            'oauth2'
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/Client/SetReferrer',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+

{rapidata-2.2.1 → rapidata-2.3.0}/src/rapidata/api_client/models/aggregator_type.py

@@ -37,6 +37,7 @@ class AggregatorType(str, Enum):
     TRANSCRIPTION = 'Transcription'
     SINGLEPOINTLOCATE = 'SinglePointLocate'
     FREETEXT = 'FreeText'
+    SCRUB = 'Scrub'
 
     @classmethod
     def from_json(cls, json_str: str) -> Self:

{rapidata-2.2.1 → rapidata-2.3.0}/src/rapidata/api_client/models/create_order_model.py

@@ -57,8 +57,8 @@ class CreateOrderModel(BaseModel):
         if value is None:
             return value
 
-        if value not in set(['NonCommittal', 'MajorityVote', 'SimpleMatchup', 'LocateCluster', 'Classification', 'Locate', 'BoundingBox', 'Line', 'Transcription', 'SinglePointLocate', 'FreeText']):
-            raise ValueError("must be one of enum values ('NonCommittal', 'MajorityVote', 'SimpleMatchup', 'LocateCluster', 'Classification', 'Locate', 'BoundingBox', 'Line', 'Transcription', 'SinglePointLocate', 'FreeText')")
+        if value not in set(['NonCommittal', 'MajorityVote', 'SimpleMatchup', 'LocateCluster', 'Classification', 'Locate', 'BoundingBox', 'Line', 'Transcription', 'SinglePointLocate', 'FreeText', 'Scrub']):
+            raise ValueError("must be one of enum values ('NonCommittal', 'MajorityVote', 'SimpleMatchup', 'LocateCluster', 'Classification', 'Locate', 'BoundingBox', 'Line', 'Transcription', 'SinglePointLocate', 'FreeText', 'Scrub')")
         return value
 
     model_config = ConfigDict(

{rapidata-2.2.1 → rapidata-2.3.0}/src/rapidata/api_client/models/transcription_truth.py

@@ -17,8 +17,8 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr, field_validator
-from typing import Any, ClassVar, Dict, List, Optional
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictFloat, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
 from rapidata.api_client.models.transcription_word import TranscriptionWord
 from typing import Optional, Set
 from typing_extensions import Self
@@ -30,7 +30,9 @@ class TranscriptionTruth(BaseModel):
     t: StrictStr = Field(description="Discriminator value for TranscriptionTruth", alias="_t")
     correct_words: List[TranscriptionWord] = Field(alias="correctWords")
     strict_grading: Optional[StrictBool] = Field(default=None, alias="strictGrading")
-    __properties: ClassVar[List[str]] = ["_t", "correctWords", "strictGrading"]
+    required_precision: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, alias="requiredPrecision")
+    required_completeness: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, alias="requiredCompleteness")
+    __properties: ClassVar[List[str]] = ["_t", "correctWords", "strictGrading", "requiredPrecision", "requiredCompleteness"]
 
     @field_validator('t')
     def t_validate_enum(cls, value):
@@ -85,6 +87,21 @@ class TranscriptionTruth(BaseModel):
                 if _item_correct_words:
                     _items.append(_item_correct_words.to_dict())
             _dict['correctWords'] = _items
+        # set to None if strict_grading (nullable) is None
+        # and model_fields_set contains the field
+        if self.strict_grading is None and "strict_grading" in self.model_fields_set:
+            _dict['strictGrading'] = None
+
+        # set to None if required_precision (nullable) is None
+        # and model_fields_set contains the field
+        if self.required_precision is None and "required_precision" in self.model_fields_set:
+            _dict['requiredPrecision'] = None
+
+        # set to None if required_completeness (nullable) is None
+        # and model_fields_set contains the field
+        if self.required_completeness is None and "required_completeness" in self.model_fields_set:
+            _dict['requiredCompleteness'] = None
+
         return _dict
 
     @classmethod
@@ -99,7 +116,9 @@ class TranscriptionTruth(BaseModel):
         _obj = cls.model_validate({
             "_t": obj.get("_t") if obj.get("_t") is not None else 'TranscriptionTruth',
             "correctWords": [TranscriptionWord.from_dict(_item) for _item in obj["correctWords"]] if obj.get("correctWords") is not None else None,
-            "strictGrading": obj.get("strictGrading")
+            "strictGrading": obj.get("strictGrading"),
+            "requiredPrecision": obj.get("requiredPrecision"),
+            "requiredCompleteness": obj.get("requiredCompleteness")
         })
         return _obj
 

{rapidata-2.2.1 → rapidata-2.3.0}/src/rapidata/api_client/models/workflow_aggregation_step_model.py

@@ -46,8 +46,8 @@ class WorkflowAggregationStepModel(BaseModel):
         if value is None:
             return value
 
-        if value not in set(['NonCommittal', 'MajorityVote', 'SimpleMatchup', 'LocateCluster', 'Classification', 'Locate', 'BoundingBox', 'Line', 'Transcription', 'SinglePointLocate', 'FreeText']):
-            raise ValueError("must be one of enum values ('NonCommittal', 'MajorityVote', 'SimpleMatchup', 'LocateCluster', 'Classification', 'Locate', 'BoundingBox', 'Line', 'Transcription', 'SinglePointLocate', 'FreeText')")
+        if value not in set(['NonCommittal', 'MajorityVote', 'SimpleMatchup', 'LocateCluster', 'Classification', 'Locate', 'BoundingBox', 'Line', 'Transcription', 'SinglePointLocate', 'FreeText', 'Scrub']):
+            raise ValueError("must be one of enum values ('NonCommittal', 'MajorityVote', 'SimpleMatchup', 'LocateCluster', 'Classification', 'Locate', 'BoundingBox', 'Line', 'Transcription', 'SinglePointLocate', 'FreeText', 'Scrub')")
         return value
 
     model_config = ConfigDict(

{rapidata-2.2.1 → rapidata-2.3.0}/src/rapidata/api_client_README.md

@@ -78,6 +78,7 @@ Class | Method | HTTP request | Description
 *ClientApi* | [**client_client_id_delete**](rapidata/api_client/docs/ClientApi.md#client_client_id_delete) | **DELETE** /Client/{clientId} | Deletes a customers client.
 *ClientApi* | [**client_post**](rapidata/api_client/docs/ClientApi.md#client_post) | **POST** /Client | Creates a new client for the current customer.
 *ClientApi* | [**client_query_get**](rapidata/api_client/docs/ClientApi.md#client_query_get) | **GET** /Client/Query | Gets the clients for the current customer.
+*ClientApi* | [**client_set_referrer_post**](rapidata/api_client/docs/ClientApi.md#client_set_referrer_post) | **POST** /Client/SetReferrer | Sets the referrer for the current customer.
 *CocoApi* | [**coco_submit_post**](rapidata/api_client/docs/CocoApi.md#coco_submit_post) | **POST** /Coco/Submit | Creates a new validation set based on a previously uploaded CoCo set.
 *CocoApi* | [**coco_upload_post**](rapidata/api_client/docs/CocoApi.md#coco_upload_post) | **POST** /Coco/Upload | Uploads a CoCo set to the system.
 *CompareWorkflowApi* | [**compare_workflow_get_result_overview_get**](rapidata/api_client/docs/CompareWorkflowApi.md#compare_workflow_get_result_overview_get) | **GET** /CompareWorkflow/GetResultOverview | Get the result overview for a compare workflow.

{rapidata-2.2.1 → rapidata-2.3.0}/src/rapidata/rapidata_client/assets/_media_asset.py

@@ -11,6 +11,8 @@ import re
 from PIL import Image
 from tinytag import TinyTag
 import tempfile
+from pydantic import StrictStr, StrictBytes
+
 
 class MediaAsset(BaseAsset):
     """MediaAsset Class
@@ -161,3 +163,10 @@ class MediaAsset(BaseAsset):
 
         content = BytesIO(response.content)
         return content.getvalue()
+    
+    def to_file(self) -> StrictStr | tuple[StrictStr, StrictBytes] | StrictBytes: # types for autogenerated models
+        files = []
+        if isinstance(self.path, str):
+            return self.path
+        else: # isinstance(self.path, bytes)
+            return (self.name, self.path)

rapidata-2.3.0/src/rapidata/rapidata_client/demographic/demographic_manager.py

@@ -0,0 +1,27 @@
+from rapidata.service.openapi_service import OpenAPIService
+from rapidata.rapidata_client.assets import MediaAsset
+from rapidata.api_client.models.create_demographic_rapid_model import CreateDemographicRapidModel
+from rapidata.api_client.models.classify_payload import ClassifyPayload
+
+
+class DemographicManager:
+    def __init__(self, openapi_service: OpenAPIService):
+        self._openapi_service = openapi_service
+    
+    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
+            )
+        )
+        self._openapi_service.rapid_api.rapid_create_demographic_rapid_post(model=model, file=[media.to_file()])
+        

{rapidata-2.2.1 → rapidata-2.3.0}/src/rapidata/rapidata_client/order/_rapidata_dataset.py

@@ -14,6 +14,7 @@ from rapidata.service.openapi_service import OpenAPIService
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from tqdm import tqdm
 
+from pydantic import StrictBytes, StrictStr
 from typing import cast, Sequence
 
 
@@ -100,17 +101,14 @@ class RapidataDataset:
                 ),
             )
 
-            files: list[tuple[str, bytes] | str] = []
+            files: list[tuple[StrictStr, StrictBytes] | StrictStr | StrictBytes] = []
             for asset in assets:
                 if isinstance(asset, MediaAsset):
-                    if isinstance(asset.path, bytes):
-                        files.append((asset.name, asset.path))
-                    else:
-                        files.append(cast(str, asset.path))
+                    files.append(asset.to_file())
 
             upload_response = self.openapi_service.dataset_api.dataset_create_datapoint_post(
                 model=model,
-                files=files # type: ignore
+                files=files
             )
             if upload_response.errors:
                 raise ValueError(f"Error uploading datapoint: {upload_response.errors}")

{rapidata-2.2.1 → rapidata-2.3.0}/src/rapidata/rapidata_client/rapidata_client.py

@@ -4,6 +4,7 @@ from rapidata.rapidata_client.order.rapidata_order_manager import RapidataOrderM
 
 from rapidata.rapidata_client.validation.validation_set_manager import ValidationSetManager
 
+from rapidata.rapidata_client.demographic.demographic_manager import DemographicManager
 
 class RapidataClient:
     """The Rapidata client is the main entry point for interacting with the Rapidata API. It allows you to create orders and validation sets."""
@@ -39,3 +40,5 @@ class RapidataClient:
         self.order = RapidataOrderManager(openapi_service=self._openapi_service)
         
         self.validation = ValidationSetManager(openapi_service=self._openapi_service)
+
+        self._demographic = DemographicManager(openapi_service=self._openapi_service)

{rapidata-2.2.1 → rapidata-2.3.0}/src/rapidata/rapidata_client/validation/_validation_set_builder.py

@@ -107,7 +107,14 @@ class ValidationSetBuilder:
             self.__add_compare_rapid(rapid.asset, rapid.instruction, rapid.truth, rapid.metadata)
 
         elif isinstance(rapid, SelectWordsRapid):
-            self.__add_select_words_rapid(rapid.asset, rapid.instruction, rapid.sentence, rapid.truths, rapid.strict_grading)
+            self.__add_select_words_rapid(
+                rapid.asset, 
+                rapid.instruction, 
+                rapid.sentence, 
+                rapid.truths, 
+                rapid.required_precision,
+                rapid.required_completeness, 
+                rapid.metadata)
         
         elif isinstance(rapid, LocateRapid):
             self.__add_locate_rapid(rapid.asset, rapid.instruction, rapid.truths, rapid.metadata)
@@ -213,7 +220,8 @@ class ValidationSetBuilder:
         instruction: str,
         select_words: str,
         truths: list[int],
-        strict_grading: bool | None = None,
+        required_precision: float,
+        required_completeness: float,
         metadata: Sequence[Metadata] = [],
     ):
         """Add a select words rapid to the validation set.
@@ -223,7 +231,8 @@ class ValidationSetBuilder:
             instruction (str): The instruction for the rapid.
             select words (list[str]): The select words for the rapid.
             truths (list[int]): The list of indices of the true word selections.
-            strict_grading (bool | None, optional): The strict grading for the rapid. Defaults to None.
+            required_precision (float): The required precision for the rapid (minimum ratio of selected words that are correct).
+            required_completeness (float): The required completeness for the rapid (miminum ratio of total correct words selected).
             metadata (Sequence[Metadata], optional): The metadata for the rapid.
 
         Returns:
@@ -251,7 +260,8 @@ class ValidationSetBuilder:
         model_truth = TranscriptionTruth(
             _t="TranscriptionTruth",
             correctWords=true_words,
-            strictGrading=strict_grading,
+            requiredPrecision=required_precision,
+            requiredCompleteness=required_completeness,
         )
 
         self._rapid_parts.append(

{rapidata-2.2.1 → rapidata-2.3.0}/src/rapidata/rapidata_client/validation/rapidata_validation_set.py

@@ -70,12 +70,8 @@ class RapidataValidationSet:
         """
         files = []
         for asset in assets:
-            if isinstance(asset.path, str):
-                files.append(asset.path)
-            elif isinstance(asset.path, bytes):
-                files.append((asset.name, asset.path))
-            else:
-                raise ValueError("upload file failed")
+            files.append(asset.to_file())
+            
         self.__openapi_service.validation_api.validation_add_validation_rapid_post(
             model=model, files=files
         )        

{rapidata-2.2.1 → rapidata-2.3.0}/src/rapidata/rapidata_client/validation/rapids/rapids.py

@@ -55,12 +55,23 @@ class SelectWordsRapid(Rapid):
             True means that all correct words and no wrong words have to be selected for the rapid to be marked as correct.
             False means that at least one correct word and no wrong words have to be selected for the rapid to be marked as correct.
     """
-    def __init__(self, instruction: str, truths: list[int], asset: MediaAsset, sentence: str, strict_grading: bool):
+    def __init__(self, instruction: str, truths: list[int], asset: MediaAsset, sentence: str, required_precision: float, required_completeness: float, metadata: Sequence[Metadata]):
+        if not isinstance(truths, list):
+            raise ValueError("The truths must be a list of integers.")
+        if not all(isinstance(x, int) for x in truths):
+            raise ValueError("The truths must be a list of integers.")
+        if required_completeness <= 0 or required_completeness > 1:
+            raise ValueError("The required completeness must be > 0 and <= 1.")
+        if required_precision <= 0 or required_precision > 1:
+            raise ValueError("The required precision must be > 0 and <= 1.")
+        
         self.instruction = instruction
         self.truths = truths
         self.asset = asset
         self.sentence = sentence
-        self.strict_grading = strict_grading
+        self.required_precision = required_precision
+        self.required_completeness = required_completeness
+        self.metadata = metadata
 
 class LocateRapid(Rapid):
     """

{rapidata-2.2.1 → rapidata-2.3.0}/src/rapidata/rapidata_client/validation/rapids/rapids_manager.py

@@ -91,7 +91,9 @@ class RapidsManager:
             truths: list[int],
             datapoint: str,
             sentence: str,
-            strict_grading: bool = True,
+            required_precision: float = 1,
+            required_completeness: float = 1,
+            metadata: Sequence[Metadata] = [],
     ) -> SelectWordsRapid:
         """Build a select words rapid
 
@@ -100,9 +102,9 @@ class RapidsManager:
             truths (list[int]): The indices of the words that are the correct answers.
             datapoint (str): The asset that the labeler will be selecting words from.
             sentence (str): The sentence that the labeler will be selecting words from. (split up by spaces)
-            strict_grading (bool, optional): Whether the grading should be strict or not. 
-                True means that all correct words and no wrong words have to be selected for the rapid to be marked as correct.
-                False means that at least one correct word and no wrong words have to be selected for the rapid to be marked as correct. Defaults to True.
+            required_precision (float): The required precision for the labeler to get the rapid correct (minimum ratio of the words selected that need to be correct). defaults to 1. (no wrong words can be selected)
+            required_completeness (float): The required completeness for the labeler to get the rapid correct (miminum ratio of total correct words selected). defaults to 1. (all correct words need to be selected)
+            metadata (Sequence[Metadata], optional): The metadata that is attached to the rapid. Defaults to [].
         """
         
         asset = MediaAsset(datapoint)
@@ -112,7 +114,9 @@ class RapidsManager:
                 truths=truths,
                 asset=asset,
                 sentence=sentence,
-                strict_grading=strict_grading,
+                required_precision=required_precision,
+                required_completeness=required_completeness,
+                metadata=metadata,
                 )
     
     def locate_rapid(self,

{rapidata-2.2.1 → rapidata-2.3.0}/src/rapidata/rapidata_client/validation/validation_set_manager.py

@@ -149,7 +149,8 @@ class ValidationSetManager:
         truths: list[list[int]],
         datapoints: list[str],
         sentences: list[str],
-        strict_grading: bool = True,
+        required_precision: float = 1.0,
+        required_completeness: float = 1.0,
         print_confirmation: bool = True
     ) -> RapidataValidationSet:
         """Create a select words validation set.
@@ -165,9 +166,8 @@ class ValidationSetManager:
             datapoints (list[str]): The datapoints that will be used for validation.
             sentences (list[str]): The sentences that will be used for validation. The sentece will be split up by spaces to be selected by the labeler.
                 Must be the same length as datapoints.
-            strict_grading (bool, optional): Whether to grade strictly. Defaults to True.\n
-                If True, the labeler must select all correct words to be graded as correct. (and no wrong words)
-                If False, the labeler must select at least one correct word to be graded as correct. (and no wrong words)
+            required_precision (float, optional): The required precision for the labeler to get the rapid correct (minimum ratio of the words selected that need to be correct). Defaults to 1.0 (no wrong word can be selected).
+            required_completeness (float, optional): The required completeness for the labeler to get the rapid correct (miminum ratio of total correct words selected). Defaults to 1.0 (all correct words need to be selected).
             print_confirmation (bool, optional): Whether to print a confirmation message that validation set has been created. Defaults to True.
             """
         
@@ -185,7 +185,8 @@ class ValidationSetManager:
                     truths=truths[i],
                     datapoint=datapoints[i],
                     sentence=sentences[i],
-                    strict_grading=strict_grading
+                    required_precision=required_precision,
+                    required_completeness=required_completeness
                 )
             )