rapidata 0.1.0__py3-none-any.whl

rapidata/rapidata_client/__init__.py

@@ -0,0 +1 @@
+from .rapidata_client import RapidataClient as RapidataClient

rapidata/rapidata_client/order/dataset/rapidata_dataset.py

@@ -0,0 +1,26 @@
+import os
+from rapidata.service import LocalFileService
+from rapidata.service import RapidataService
+
+
+class RapidataDataset:
+
+    def __init__(self, dataset_id: str, rapidata_service: RapidataService):
+        self.dataset_id = dataset_id
+        self.rapidata_service = rapidata_service
+        self.local_file_service = LocalFileService()
+
+    def add_texts(self, texts: list[str]):
+        self.rapidata_service.dataset.upload_text_sources(self.dataset_id, texts)
+
+    def add_images_from_paths(self, image_paths: list[str]):
+        image_names = [os.path.basename(image_path) for image_path in image_paths]
+        images = self.local_file_service.load_images(image_paths)
+
+        self.rapidata_service.dataset.upload_images(self.dataset_id, images, image_names)
+
+    def add_videos_from_paths(self, video_paths: list[str]):
+        video_names = [os.path.basename(video_path) for video_path in video_paths]
+        videos = self.local_file_service.load_videos(video_paths)
+
+        self.rapidata_service.dataset.upload_videos(self.dataset_id, videos, video_names)

rapidata/rapidata_client/order/rapidata_order.py

@@ -0,0 +1,71 @@
+from rapidata.rapidata_client.order.dataset.rapidata_dataset import RapidataDataset
+from rapidata.rapidata_client.workflow import Workflow
+from rapidata.service import RapidataService
+
+
+class RapidataOrder:
+    """
+    Represents a Rapidata order.
+
+    :param name: The name of the order.
+    :type name: str
+    :param workflow: The workflow associated with the order.
+    :type workflow: Workflow
+    :param rapidata_service: The Rapidata service used to create and manage the order.
+    :type rapidata_service: RapidataService
+    """
+
+    def __init__(
+        self, name: str, workflow: Workflow, rapidata_service: RapidataService
+    ):
+        self.name = name
+        self.workflow = workflow
+        self.rapidata_service = rapidata_service
+        self.order_id = None
+        self._dataset = None
+
+    def create(self):
+        """
+        Creates the order using the provided name and workflow.
+
+        :return: The created RapidataOrder instance.
+        :rtype: RapidataOrder
+        """
+        self.order_id, dataset_id = self.rapidata_service.order.create_order(self.name, self.workflow.to_dict())
+        self._dataset = RapidataDataset(dataset_id, self.rapidata_service)
+        return self
+
+    def submit(self):
+        """
+        Submits the order for processing.
+
+        :raises ValueError: If the order has not been created.
+        """
+        if self.order_id is None:
+            raise ValueError("You must create the order before submitting it.")
+
+        self.rapidata_service.order.submit(self.order_id)
+
+    def approve(self):
+        """
+        Approves the order for execution.
+
+        :raises ValueError: If the order has not been created.
+        """
+        if self.order_id is None:
+            raise ValueError("You must create the order before approving it.")
+
+        self.rapidata_service.order.approve(self.order_id)
+
+    @property
+    def dataset(self):
+        """
+        The dataset associated with the order.
+
+        :raises ValueError: If the order has not been submitted.
+        :return: The RapidataDataset instance.
+        :rtype: RapidataDataset
+        """
+        if self._dataset is None:
+            raise ValueError("You must submit the order before accessing the dataset.")
+        return self._dataset

rapidata/rapidata_client/order/rapidata_order_builder.py

@@ -0,0 +1,52 @@
+from rapidata.rapidata_client.workflow import Workflow
+from rapidata.rapidata_client.order.rapidata_order import RapidataOrder
+from rapidata.service import RapidataService
+
+
+class RapidataOrderBuilder:
+    """
+    Builder object for creating Rapidata orders.
+
+    Use the fluent interface to set the desired configuration. Add a workflow to the order using `.workflow()` and finally call `.create()` to create the order.
+
+    :param rapidata_service: The RapidataService instance.
+    :type rapidata_service: RapidataService
+    :param name: The name of the order.
+    :type name: str
+    """
+
+    def __init__(
+        self,
+        rapidata_service: RapidataService,
+        name: str,
+    ):
+        self._name = name
+        self._rapidata_service = rapidata_service
+        self._workflow: Workflow | None = None
+
+    def create(self) -> RapidataOrder:
+        """
+        Create a RapidataOrder instance based on the configured settings.
+
+        :return: The created RapidataOrder instance.
+        :rtype: RapidataOrder
+        :raises ValueError: If no workflow is provided.
+        """
+        if self._workflow is None:
+            raise ValueError("You must provide a blueprint to create an order.")
+
+        return RapidataOrder(
+            name=self._name, workflow=self._workflow, rapidata_service=self._rapidata_service
+        ).create()
+
+    def workflow(self, workflow: Workflow):
+        """
+        Set the workflow for the order.
+
+        :param workflow: The workflow to be set.
+        :type workflow: Workflow
+        :return: The updated RapidataOrderBuilder instance.
+        :rtype: RapidataOrderBuilder
+        """
+        self._workflow = workflow
+        return self

rapidata/rapidata_client/rapidata_client.py

@@ -0,0 +1,34 @@
+from rapidata.rapidata_client.order.rapidata_order_builder import RapidataOrderBuilder
+from rapidata.service import RapidataService
+
+
+class RapidataClient:
+    """
+    A client for interacting with the Rapidata API.
+    """
+
+    def __init__(
+        self,
+        client_id: str,
+        client_secret: str,
+        endpoint: str = "https://api.rapidata.ai",
+    ):
+        """
+        Initialize the RapidataClient.
+
+        :param client_id: The client ID for authentication.
+        :param client_secret: The client secret for authentication.
+        :param endpoint: The API endpoint URL. Defaults to "https://api.rapidata.ai".
+        """
+        self._rapidata_service = RapidataService(
+            client_id=client_id, client_secret=client_secret, endpoint=endpoint
+        )
+
+    def new_order(self, name: str) -> RapidataOrderBuilder:
+        """
+        Create a new order using a RapidataOrderBuilder instance.
+
+        :param name: The name of the order.
+        :return: A RapidataOrderBuilder instance.
+        """
+        return RapidataOrderBuilder(rapidata_service=self._rapidata_service, name=name)

rapidata/rapidata_client/workflow/__init__.py

@@ -0,0 +1,6 @@
+from .base_workflow import Workflow as Workflow
+from .classify_workflow import ClassifyWorkflow as ClassifyWorkflow
+from .compare_workflow import CompareWorkflow as CompareWorkflow
+from .free_text_workflow import FreeTextWorkflow as FreeTextWorkflow
+from .feature_flags import FeatureFlags as FeatureFlags
+from .country_codes import CountryCodes as CountryCodes

rapidata/rapidata_client/workflow/base_workflow.py

@@ -0,0 +1,35 @@
+from abc import ABC
+from typing import Any
+
+from rapidata.rapidata_client.workflow.feature_flags import FeatureFlags
+from rapidata.rapidata_client.workflow.referee.base_referee import Referee
+from rapidata.rapidata_client.workflow.referee.naive_referee import NaiveReferee
+
+
+class Workflow(ABC):
+    
+    def __init__(self, type: str):
+        self._type = type
+        self._referee = NaiveReferee()
+        self._target_country_codes: list[str] = []
+        self._feature_flags: FeatureFlags = FeatureFlags()
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "_t": self._type,
+            "referee": self._referee.to_dict(),
+            "targetCountryCodes": self._target_country_codes,
+            "featureFlags": self._feature_flags.to_list(),
+        }
+
+    def referee(self, referee: Referee):
+        self._referee = referee
+        return self
+    
+    def target_country_codes(self, target_country_codes: list[str]):
+        self._target_country_codes = target_country_codes
+        return self
+    
+    def feature_flags(self, feature_flags: FeatureFlags):
+        self._feature_flags = feature_flags
+        return self

rapidata/rapidata_client/workflow/classify_workflow.py

@@ -0,0 +1,19 @@
+from typing import Any
+from rapidata.rapidata_client.workflow import Workflow
+
+
+class ClassifyWorkflow(Workflow):
+    def __init__(self, question: str, categories: list[str]):
+        super().__init__(type="SimpleWorkflowConfig")
+        self._question = question
+        self._categories = categories
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            **super().to_dict(),
+            "blueprint": {
+                "_t": "ClassifyBlueprint",
+                "title": self._question,
+                "possibleCategories": self._categories,
+            }
+        }

rapidata/rapidata_client/workflow/compare_workflow.py

@@ -0,0 +1,30 @@
+from typing import Any
+from rapidata.rapidata_client.workflow import Workflow
+
+
+class CompareWorkflow(Workflow):
+    def __init__(self, criteria: str):
+        super().__init__(type="CompareWorkflowConfig")
+        self._criteria = criteria
+        self._k_factor = 40
+        self._match_size = 2
+        self._matches_until_completed = 10
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            **super().to_dict(),
+            "criteria": self._criteria,
+        }
+    
+    def k_factor(self, k_factor: int):
+        self._k_factor = k_factor
+        return self
+    
+    def match_size(self, match_size: int):
+        self._match_size = match_size
+        return self
+    
+    def matches_until_completed(self, matches_until_completed: int):
+        self._matches_until_completed = matches_until_completed
+        return self
+    

rapidata/rapidata_client/workflow/country_codes/__init__.py

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

rapidata/rapidata_client/workflow/country_codes/country_codes.py

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

rapidata/rapidata_client/workflow/feature_flags/__init__.py

@@ -0,0 +1 @@
+from .feature_flags import FeatureFlags as FeatureFlags

rapidata/rapidata_client/workflow/feature_flags/feature_flags.py

@@ -0,0 +1,20 @@
+class FeatureFlags:
+    def __init__(self):
+        self._flags: dict[str, str] = {}
+
+    def to_list(self) -> list[dict[str, str]]:
+        # transform dict of flags to list of flags
+        return [{"key": name, "value": value} for name, value in self._flags.items()]
+    
+    def alert_on_fast_response(self, value: int):
+        self._flags["alertOnFastResponse"] = str(value)
+        return self
+    
+    def disable_translation(self, value: bool):
+        self._flags["disableTranslation"] = str(value)
+        return self
+    
+    def free_text_minimum_characters(self, value: int):
+        self._flags["freeTextMinimumCharacters"] = str(value)
+        return self
+    

rapidata/rapidata_client/workflow/free_text_workflow.py

@@ -0,0 +1,17 @@
+from typing import Any
+from rapidata.rapidata_client.workflow import Workflow
+
+
+class FreeTextWorkflow(Workflow):
+    def __init__(self, question: str):
+        super().__init__(type="SimpleWorkflowConfig")
+        self._question = question
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            **super().to_dict(),
+            "blueprint": {
+                "_t": "FreeTextBlueprint",
+                "question": self._question,
+            },
+        }

rapidata/rapidata_client/workflow/referee/__init__.py

@@ -0,0 +1,3 @@
+from .base_referee import Referee as Referee
+from .naive_referee import NaiveReferee as NaiveReferee
+from .classify_early_stopping_referee import ClassifyEarlyStoppingReferee as ClassifyEarlyStoppingReferee

rapidata/rapidata_client/workflow/referee/base_referee.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+from typing import Mapping
+
+
+class Referee(ABC):
+    """
+    The referee defines when a rapid is considered complete. 
+    """
+    @abstractmethod
+    def to_dict(self) -> Mapping[str, str | int | float]:
+        """
+        Convert the referee to a referee configuration dict.
+        """
+        pass

rapidata/rapidata_client/workflow/referee/classify_early_stopping_referee.py

@@ -0,0 +1,20 @@
+from rapidata.rapidata_client.workflow.referee.base_referee import Referee
+
+
+class ClassifyEarlyStoppingReferee(Referee):
+    """
+    The referee defines when a task is considered complete.
+    The EarlyStoppingReferee stops the task when the confidence in the winning category is above a threshold.
+    The threshold behaves logarithmically, i.e. if 0.99 stops too early, try 0.999 or 0.9999.
+    """
+
+    def __init__(self, threshold: float = 0.999, max_vote_count: int = 100):
+        self.threshold = threshold
+        self.max_vote_count = max_vote_count
+
+    def to_dict(self):
+        return {
+            "_t": "ProbabilisticAttachCategoryRefereeConfig",
+            "threshold": self.threshold,
+            "maxVotes": self.max_vote_count,
+        }

rapidata/rapidata_client/workflow/referee/naive_referee.py

@@ -0,0 +1,18 @@
+from rapidata.rapidata_client.workflow.referee.base_referee import Referee
+
+
+class NaiveReferee(Referee):
+    """
+    The referee defines when a task is considered complete.
+    The SimpleReferee is the simplest referee, requiring a fixed number of guesses.
+    """
+
+    def __init__(self, required_guesses: int = 10):
+        super().__init__()
+        self.required_guesses = required_guesses
+
+    def to_dict(self):
+        return {
+            "_t": "NaiveRefereeConfig",
+            "guessesRequired": self.required_guesses,
+        }

rapidata/service/__init__.py

@@ -0,0 +1,2 @@
+from .rapidata_api_services.rapidata_service import RapidataService as RapidataService
+from .local_file_service import LocalFileService as LocalFileService

rapidata/service/local_file_service.py

@@ -0,0 +1,25 @@
+import os
+from PIL import Image
+
+class LocalFileService:
+    
+    def load_image(self, image_path: str) -> Image.Image:
+        self.check_file_exists(image_path)
+        return Image.open(image_path)
+    
+    def load_images(self, image_paths: list[str]) -> list[Image.Image]:
+        return [self.load_image(image_path) for image_path in image_paths]
+    
+    def load_video(self, video_path: str):
+        self.check_file_exists(video_path)
+        return open(video_path, 'rb')
+    
+    def load_videos(self, video_paths: list[str]):
+        return [self.load_video(video_path) for video_path in video_paths]
+    
+    def _file_exists(self, file_path: str) -> bool:
+        return os.path.exists(file_path)
+    
+    def check_file_exists(self, file_path: str):
+        if not self._file_exists(file_path):
+            raise FileNotFoundError(f"File {file_path} not found.")

rapidata/service/rapidata_api_services/base_service.py

@@ -0,0 +1,76 @@
+from datetime import datetime, timedelta
+from typing import Any
+import jwt
+import requests
+
+
+class BaseRapidataAPIService:
+
+    def __init__(self, client_id: str, client_secret: str, endpoint: str):
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.endpoint = endpoint
+        self.auth_header = None
+        self.token = self._get_auth_token()
+
+    def _check_response(self, response: requests.Response):
+        if response.status_code != 200:
+            raise Exception(f"Error: {response.status_code} - {response.text}")
+
+    def _get_new_auth_token_if_outdated(self):
+        if not self.token or not self._is_token_valid():
+            self._get_auth_token()
+
+    def _is_token_valid(self, expiration_threshold: timedelta = timedelta(minutes=5)):
+        try:
+            payload = jwt.decode(self.token, options={"verify_signature": False})  # type: ignore
+            exp_timestamp = payload.get("exp")
+            if exp_timestamp:
+                expiration_time = datetime.fromtimestamp(exp_timestamp)
+                return datetime.now() + expiration_threshold <= expiration_time
+        except jwt.DecodeError:
+            return False
+        return False
+
+    def _get_auth_token(self):
+        url = f"{self.endpoint}/Identity/GetClientAuthToken"
+        params = {
+            "clientId": self.client_id,
+        }
+        headers = {"Authorization": f"Basic {self.client_secret}"}
+        response = requests.post(url, params=params, headers=headers)
+        self._check_response(response)
+        self.token = response.json().get("authToken")
+        if not self.token:
+            raise Exception("No token received")
+        self.auth_header = {"Authorization": f"Bearer {self.token}"}
+
+    def _post(
+        self,
+        url: str,
+        params: dict[str, Any] | None = None,
+        data: dict[str, Any] | None = None,
+        json: dict[str, Any] | None = None,
+        files: Any | None = None,
+    ):
+        self._get_new_auth_token_if_outdated()
+        response = requests.post(
+            url,
+            params=params,
+            data=data,
+            json=json,
+            files=files,
+            headers=self.auth_header,
+        )
+        self._check_response(response)
+        return response
+
+    def _get(
+        self,
+        url: str,
+        params: dict[str, Any] | None = None,
+    ):
+        self._get_new_auth_token_if_outdated()
+        response = requests.get(url, params=params, headers=self.auth_header)
+        self._check_response(response)
+        return response

rapidata/service/rapidata_api_services/dataset_service.py

@@ -0,0 +1,82 @@
+from io import BufferedReader
+from PIL import Image
+from rapidata.service.rapidata_api_services.base_service import BaseRapidataAPIService
+from rapidata.utils.image_utils import ImageUtils
+
+
+class DatasetService(BaseRapidataAPIService):
+    def __init__(self, client_id: str, client_secret: str, endpoint: str):
+        super().__init__(
+            client_id=client_id, client_secret=client_secret, endpoint=endpoint
+        )
+
+    def upload_text_sources(self, dataset_id: str, text_sources: list[str]):
+        url = f"{self.endpoint}/Dataset/UploadTextSourcesToDataset"
+        payload = {"datasetId": dataset_id, "textSources": text_sources}
+
+        response = self._post(url, json=payload)
+
+        return response
+
+    def upload_images(
+        self, dataset_id: str, images: list[Image.Image], image_names: list[str]
+    ):
+        url = f"{self.endpoint}/Dataset/UploadImagesToDataset"
+
+        params = {"datasetId": dataset_id}
+
+        images_bytes: list[bytes] = [
+            ImageUtils.convert_PIL_image_to_bytes(image) for image in images
+        ]
+
+        files = [
+            ("files", (image_name, image_bytes))
+            for image_name, image_bytes in zip(image_names, images_bytes)
+        ]
+
+        response = self._post(url, params=params, files=files)
+
+        return response
+
+    def upload_videos(
+        self, dataset_id: str, videos: list[BufferedReader], video_names: list[str]
+    ):
+        url = f"{self.endpoint}/Dataset/UploadImagesToDataset"
+
+        params = {"datasetId": dataset_id}
+
+        files = [
+            ("files", (video_name, video_bytes))
+            for video_name, video_bytes in zip(video_names, videos)
+        ]
+
+        response = self._post(url, params=params, files=files)
+
+        return response
+
+    def upload_images_from_s3(
+        self,
+        dataset_id: str,
+        bucket_name: str,
+        region: str,
+        source_prefix: str,
+        access_key: str,
+        secret_key: str,
+        clear_dataset: bool = True,
+    ):
+        url = f"{self.endpoint}/Dataset/UploadFilesFromS3"
+
+        payload = {
+            "datasetId": dataset_id,
+            "bucketName": bucket_name,
+            "region": region,
+            "sourcePrefix": source_prefix,
+            "accessKey": access_key,
+            "secretKey": secret_key,
+            "useCustomAwsCredentials": True,
+            "clearDataset": clear_dataset,
+        }
+
+        response = self._post(url, json=payload)
+
+        return response

rapidata/service/rapidata_api_services/order_service.py

@@ -0,0 +1,49 @@
+
+from typing import Any
+from rapidata.service.rapidata_api_services.base_service import BaseRapidataAPIService
+
+
+class OrderService(BaseRapidataAPIService):
+    def __init__(self, client_id: str, client_secret: str, endpoint: str):
+        super().__init__(
+            client_id=client_id, client_secret=client_secret, endpoint=endpoint
+        )
+
+    def create_order(self, name: str, workflow_config: dict[str, Any]) -> tuple[str, str]:
+        """
+        order_name: name of the order that will be displayed in the Rapidata dashboard.
+        question: The question shown to the labeler in the rapid.
+        categories: The answer options, between which the labeler can choose.
+        target_country_codes: A list of two digit target country codes.
+        disable_translation: Per default, the question and categories get translated with DeepL (or Google Translate, if DeepL doesn't support a language). By setting this to `True`, the translation is disabled.
+        referee: The referee determines when the task is done. See above for the options.
+        """
+        url = f"{self.endpoint}/Order/CreateDefaultOrder"
+
+        payload = {
+            "orderName": name,
+            "datasetName": f"{name} dataset",
+            "isPublic": False,
+            "workflowConfig": workflow_config,
+            "aggregatorType": "Classification",
+        }
+
+        response = self._post(url, json=payload)
+
+        return response.json()["orderId"], response.json()["datasetId"]
+
+    def submit(self, order_id: str):
+        url = f"{self.endpoint}/Order/Submit"
+        params = {"orderId": order_id}
+
+        submit_response = self._post(url, params=params)
+
+        return submit_response
+    
+    def approve(self, order_id: str):
+        url = f"{self.endpoint}/Order/Approve"
+        params = {"orderId": order_id}
+
+        approve_response = self._post(url, params=params)
+
+        return approve_response

rapidata/service/rapidata_api_services/rapidata_service.py

@@ -0,0 +1,18 @@
+from rapidata.service.rapidata_api_services.base_service import BaseRapidataAPIService
+from rapidata.service.rapidata_api_services.dataset_service import DatasetService
+from rapidata.service.rapidata_api_services.order_service import OrderService
+
+
+class RapidataService(BaseRapidataAPIService):
+    def __init__(self, client_id: str, client_secret: str, endpoint: str):
+        super().__init__(client_id, client_secret, endpoint)
+        self._order_service = OrderService(client_id, client_secret, endpoint)
+        self._dataset_service = DatasetService(client_id, client_secret, endpoint)
+
+    @property
+    def order(self):
+        return self._order_service
+
+    @property
+    def dataset(self):
+        return self._dataset_service

rapidata/utils/image_utils.py

@@ -0,0 +1,13 @@
+from io import BytesIO
+import PIL.Image as Image
+
+class ImageUtils:
+
+    @staticmethod
+    def convert_PIL_image_to_bytes(image: Image.Image):
+        """
+        Convert a PIL image to bytes with meta data encoded. We can't just use image.tobytes() because this only returns the pixel data.
+        """
+        buffer = BytesIO()
+        image.save(buffer, image.format)
+        return buffer.getvalue()

rapidata-0.1.0.dist-info/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

rapidata-0.1.0.dist-info/METADATA

@@ -0,0 +1,18 @@
+Metadata-Version: 2.1
+Name: rapidata
+Version: 0.1.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: Marian Kannwischer
+Author-email: marian.kannwischer@t-online.de
+Requires-Python: >=3.12,<4.0
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: PyJWT (>=2.9.0,<3.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Description-Content-Type: text/markdown
+
+# rapidata-python
+Python client to interface with the Rapidata API
+

rapidata-0.1.0.dist-info/RECORD

@@ -0,0 +1,34 @@
+rapidata/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rapidata/rapidata_client/__init__.py,sha256=S34OtjhVlHBYmruPZHpJ5C-pVflCHPwj7FHwhMN-YyY,61
+rapidata/rapidata_client/order/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rapidata/rapidata_client/order/dataset/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rapidata/rapidata_client/order/dataset/rapidata_dataset.py,sha256=Nk5v0VBHM6j8V_7boh-tUgjxBL4i8OiX5VRyYRCqtaI,1071
+rapidata/rapidata_client/order/rapidata_order.py,sha256=1FV1PtDdkWX2J12_d1Z5M-8-yXC2oXaxCn2un_yxaq8,2269
+rapidata/rapidata_client/order/rapidata_order_builder.py,sha256=DTDGmT0RywkSU8r7wfAfOgkVGPnroROIFkNg4L1_2ls,1699
+rapidata/rapidata_client/rapidata_client.py,sha256=I1s9ZCghxUvU5iZl_m9QBR8HJoNi92XhStXMED7smPc,1119
+rapidata/rapidata_client/workflow/__init__.py,sha256=-xbTGFPdJH7SgTvJsGqHHjB3GFZOQyKH3amfcI4NVmA,362
+rapidata/rapidata_client/workflow/base_workflow.py,sha256=wMAL4WTSvdpgqmcbtVAijzHg7p5okPU_6BePRhIQN6U,1151
+rapidata/rapidata_client/workflow/classify_workflow.py,sha256=jzwhShNmvF_fEmKY82krhKK0ega-NFwrc8gcds90m5c,585
+rapidata/rapidata_client/workflow/compare_workflow.py,sha256=4oB8GfFycJ72WMiYcgJaExLIeGSchU_LMoao3Wko00U,850
+rapidata/rapidata_client/workflow/country_codes/__init__.py,sha256=Y8qeG2IMjvMGvhaPydq0nhwRQHb6dQqilctlEXu0_PE,55
+rapidata/rapidata_client/workflow/country_codes/country_codes.py,sha256=Q0HMX7uHJQDeLCFPP5bq4iYi6pgcDWEcl2ONGhjgoeU,286
+rapidata/rapidata_client/workflow/feature_flags/__init__.py,sha256=BNG_NQ4CrrC61fAWliImr8r581pIvegrkepVVbxcBw8,55
+rapidata/rapidata_client/workflow/feature_flags/feature_flags.py,sha256=BqMwL2p8Da3woa4BjGbzB3tYh3xTDyjkwQip0NE87sk,676
+rapidata/rapidata_client/workflow/free_text_workflow.py,sha256=96Jb4jC-iQtl0AGTyC9BkM64qjsKyzMoKXfMGaydExg,472
+rapidata/rapidata_client/workflow/referee/__init__.py,sha256=x0AxGCsR6TlDjfqQ00lB9V7QVS9EZCJzweNEIzx42PI,207
+rapidata/rapidata_client/workflow/referee/base_referee.py,sha256=JE5EIh7fva3CBMGQ6WcstP-llK1LD9TQLsaycvfZ4-k,338
+rapidata/rapidata_client/workflow/referee/classify_early_stopping_referee.py,sha256=7nvf9gdPmjpR9c_RcC_2G1QFI1Q8TwLNJpJF8KOG_BU,759
+rapidata/rapidata_client/workflow/referee/naive_referee.py,sha256=vLevsNBwKtCklUBABYUf54E7jixPYr1SbNGroCuwAu4,540
+rapidata/service/__init__.py,sha256=2y7otliX28HSkZpHRnIaN_fO8ETUbooevdlZH4AF-YQ,155
+rapidata/service/local_file_service.py,sha256=pgorvlWcx52Uh3cEG6VrdMK_t__7dacQ_5AnfY14BW8,877
+rapidata/service/rapidata_api_services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rapidata/service/rapidata_api_services/base_service.py,sha256=VwYHv8ted3NQtCrLUZ5_r4v7Vxt_IetRHTvh4ybWS10,2568
+rapidata/service/rapidata_api_services/dataset_service.py,sha256=fT5IV_lD35gPKmRaXTYcOZ71TDv3Koyb5FKtK2fwLLA,2480
+rapidata/service/rapidata_api_services/order_service.py,sha256=gytLUflH7fcOvH616TFJrHYs-hFpoGYn4HpIu8m-qlw,1919
+rapidata/service/rapidata_api_services/rapidata_service.py,sha256=AvYMxjwgZHyQPMeqq_IKpmQX-NH_7yuWUyQjU_cJmAs,740
+rapidata/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rapidata/utils/image_utils.py,sha256=TldO3eJWG8IhfJjm5MfNGO0mEDm1mQTsRoA0HLU1Uxs,404
+rapidata-0.1.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+rapidata-0.1.0.dist-info/METADATA,sha256=u4iDZRc_io5u2vkRo3KX__FT0F4X8q22iDBpS0SCJ5k,642
+rapidata-0.1.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+rapidata-0.1.0.dist-info/RECORD,,

rapidata-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any