rapidata 2.17.1__tar.gz → 2.18.0__tar.gz

{rapidata-2.17.1 → rapidata-2.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: rapidata
-Version: 2.17.1
+Version: 2.18.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
@@ -12,6 +12,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: authlib (>=1.5.1,<2.0.0)
 Requires-Dist: colorama (==0.4.6)
 Requires-Dist: deprecated (>=1.2.14,<2.0.0)
 Requires-Dist: pandas (>=2.2.3,<3.0.0)

{rapidata-2.17.1 → rapidata-2.18.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "rapidata"
-version = "2.17.1"
+version = "2.18.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"
@@ -19,6 +19,7 @@ deprecated = "^1.2.14"
 colorama = "0.4.6"
 tinytag = "^2.0.0"
 pandas = "^2.2.3"
+authlib = "^1.5.1"
 
 [tool.poetry.group.dev.dependencies]
 python-dotenv = "^1.0.1"

rapidata-2.18.0/src/rapidata/api_client/rest.py

@@ -0,0 +1,231 @@
+# coding: utf-8
+
+"""
+    Rapidata.Dataset
+
+    No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+
+    The version of the OpenAPI document: v1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+import io
+import json
+import re
+from typing import Dict, Optional
+
+import requests
+from authlib.integrations.requests_client import OAuth2Session
+from requests.adapters import HTTPAdapter
+from urllib3 import Retry
+
+from rapidata.api_client.exceptions import ApiException, ApiValueError
+
+
+class RESTResponse(io.IOBase):
+
+    def __init__(self, resp: requests.Response) -> None:
+        self.response = resp
+        self.status = resp.status_code
+        self.reason = resp.reason
+        self.data = None
+
+    def read(self):
+        if self.data is None:
+            self.data = self.response.content
+        return self.data
+
+    def getheaders(self) -> Dict[str, str]:
+        """Returns a dictionary of the response headers."""
+        return dict(self.response.headers)
+
+    def getheader(self, name, default=None) -> Optional[str]:
+        """Returns a given response header."""
+        return self.response.headers.get(name, default)
+
+
+RESTResponseType = RESTResponse
+
+
+class RESTClientObject:
+
+    def __init__(self, configuration) -> None:
+        self.configuration = configuration
+
+        self.session: Optional[OAuth2Session] = None
+
+    def setup_oauth_client_credentials(
+            self, client_id: str, client_secret: str, token_endpoint: str, scope: str
+    ):
+        self.session = OAuth2Session(
+            client_id=client_id,
+            client_secret=client_secret,
+            token_endpoint=token_endpoint,
+            scope=scope,
+        )
+        self._configure_session_defaults()
+        self.session.fetch_token()
+
+    def setup_oauth_with_token(self,
+                               client_id: str | None,
+                               client_secret: str | None,
+                               token: dict,
+                               token_endpoint: str,
+                               leeway: int = 60):
+        self.session = OAuth2Session(
+            token=token,
+            token_endpoint=token_endpoint,
+            client_id=client_id,
+            client_secret=client_secret,
+            leeway=leeway,
+        )
+        self._configure_session_defaults()
+
+    def request(
+            self,
+            method,
+            url,
+            headers=None,
+            body=None,
+            post_params=None,
+            _request_timeout=None,
+    ):
+        """Perform requests.
+
+        :param method: http request method
+        :param url: http request url
+        :param headers: http request headers
+        :param body: request json body, for `application/json`
+        :param post_params: request post parameters,
+                            `application/x-www-form-urlencoded`
+                            and `multipart/form-data`
+        :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.
+        """
+        method = method.upper()
+        assert method in ["GET", "HEAD", "DELETE", "POST", "PUT", "PATCH", "OPTIONS"]
+
+        if post_params and body:
+            raise ApiValueError(
+                "body parameter cannot be used with post_params parameter."
+            )
+
+        post_params = post_params or {}
+        headers = headers or {}
+
+        if not self.session:
+            raise ApiValueError(
+                "OAuth2 session is not initialized. Please initialize it before making requests."
+            )
+
+        session = self.session
+
+        timeout = None
+        if _request_timeout:
+            if isinstance(_request_timeout, (int, float)):
+                timeout = _request_timeout
+            elif isinstance(_request_timeout, tuple) and len(_request_timeout) == 2:
+                timeout = _request_timeout
+
+        try:
+            if method in ["POST", "PUT", "PATCH", "OPTIONS", "DELETE"]:
+                content_type = headers.get("Content-Type")
+
+                if not content_type or re.search("json", content_type, re.IGNORECASE):
+                    request_body = None
+                    if body is not None:
+                        request_body = json.dumps(body)
+                    r = session.request(method, url, data=request_body, timeout=timeout, headers=headers)
+
+                elif content_type == 'application/x-www-form-urlencoded':
+                    r = session.request(method, url, data=post_params, timeout=timeout, headers=headers)
+
+                elif content_type == 'multipart/form-data':
+                    del headers['Content-Type']
+                    files = []
+                    data = {}
+
+                    for key, value in post_params:
+                        if isinstance(value, tuple) and len(value) >= 2:
+                            # This is a file tuple (filename, file_data, [content_type])
+                            filename, file_data = value[0], value[1]
+                            content_type = value[2] if len(value) > 2 else None
+                            files.append((key, (filename, file_data, content_type)))
+                        elif isinstance(value, dict):
+                            # JSON-serialize dictionary values
+                            if key in data:
+                                # If we already have this key, handle as needed
+                                # (convert to list or append to existing list)
+                                if not isinstance(data[key], list):
+                                    data[key] = [data[key]]
+                                data[key].append(json.dumps(value))
+                            else:
+                                data[key] = json.dumps(value)
+                        else:
+                            # Regular form data
+                            if key in data:
+                                if not isinstance(data[key], list):
+                                    data[key] = [data[key]]
+                                data[key].append(value)
+                            else:
+                                data[key] = value
+                    r = session.request(method, url, files=files, data=data, timeout=timeout, headers=headers)
+
+                elif isinstance(body, str) or isinstance(body, bytes):
+                    r = session.request(method, url, data=body, timeout=timeout, headers=headers)
+
+                elif headers['Content-Type'].startswith('text/') and isinstance(body, bool):
+                    request_body = 'true' if body else 'false'
+                    r = session.request(method, url, data=request_body, timeout=timeout, headers=headers)
+
+                else:
+                    msg = '''Cannot prepare a request message for provided arguments.
+                             Please check that your arguments match declared content type.'''
+                    raise ApiException(status=0, reason=msg)
+
+            else:
+                r = session.request(method, url, params={}, timeout=timeout, headers=headers)
+
+        except requests.exceptions.SSLError as e:
+            msg = '\n'.join([type(e).__name__, str(e)])
+            raise ApiException(status=0, reason=msg)
+
+        return RESTResponse(r)
+
+    def _configure_session_defaults(self):
+        self.session.verify = (
+            self.configuration.ssl_ca_cert
+            if self.configuration.ssl_ca_cert
+            else self.configuration.verify_ssl
+        )
+
+        if self.configuration.cert_file and self.configuration.key_file:
+            self.session.cert = (
+                self.configuration.cert_file,
+                self.configuration.key_file,
+            )
+
+        if self.configuration.retries is not None:
+            retry = Retry(
+                total=self.configuration.retries,
+                backoff_factor=0.3,
+                status_forcelist=[429, 500, 502, 503, 504],
+            )
+            adapter = HTTPAdapter(max_retries=retry)
+            self.session.mount("https://", adapter)
+            # noinspection HttpUrlsUsage
+            self.session.mount("http://", adapter)
+
+        if self.configuration.proxy:
+            self.session.proxies = {
+                "http": self.configuration.proxy,
+                "https": self.configuration.proxy,
+            }
+
+            if self.configuration.proxy_headers:
+                for key, value in self.configuration.proxy_headers.items():
+                    self.session.headers[key] = value

{rapidata-2.17.1 → rapidata-2.18.0}/src/rapidata/rapidata_client/order/rapidata_order.py

@@ -51,7 +51,7 @@ class RapidataOrder:
         """Runs the order to start collecting responses."""
         self.__openapi_service.order_api.order_submit_post(self.order_id)
         if print_link:
-            print(f"Order '{self.name}' is now viewable under: https://app.{self.__openapi_service.enviroment}/order/detail/{self.order_id}")
+            print(f"Order '{self.name}' is now viewable under: https://app.{self.__openapi_service.environment}/order/detail/{self.order_id}")
         return self
 
     def pause(self) -> None:
@@ -167,7 +167,7 @@ class RapidataOrder:
             Exception: If the order is not in processing state.
         """        
         campaign_id = self.__get_campaign_id()
-        auth_url = f"https://app.{self.__openapi_service.enviroment}/order/detail/{self.order_id}/preview?campaignId={campaign_id}"
+        auth_url = f"https://app.{self.__openapi_service.environment}/order/detail/{self.order_id}/preview?campaignId={campaign_id}"
         could_open_browser = webbrowser.open(auth_url)
         if not could_open_browser:
             encoded_url = urllib.parse.quote(auth_url, safe="%/:=&?~#+!$,;'@()*[]")

{rapidata-2.17.1 → rapidata-2.18.0}/src/rapidata/rapidata_client/rapidata_client.py

@@ -2,28 +2,37 @@ from rapidata.service.openapi_service import OpenAPIService
 
 from rapidata.rapidata_client.order.rapidata_order_manager import RapidataOrderManager
 
-from rapidata.rapidata_client.validation.validation_set_manager import ValidationSetManager
+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."""
-    
+
     def __init__(
-        self,
-        client_id: str | None = None,
-        client_secret: str | None = None,
-        enviroment: str = "rapidata.ai",
-        oauth_scope: str = "openid",
-        cert_path: str | None = None,
+            self,
+            client_id: str | None = None,
+            client_secret: str | None = None,
+            environment: str = "rapidata.ai",
+            oauth_scope: str = "openid",
+            cert_path: str | None = None,
+            token: dict | None = None,
+            leeway: int = 60
     ):
-        """Initialize the RapidataClient. If both the client_id and client_secret are None, it will try using your credentials under "~/.config/rapidata/credentials.json". 
-        If this is not successful, it will open a browser windown and ask you to log in, then save your new credentials in said json file.
+        """Initialize the RapidataClient. If both the client_id and client_secret are None, it will try using your credentials under "~/.config/rapidata/credentials.json".
+        If this is not successful, it will open a browser window and ask you to log in, then save your new credentials in said json file.
 
         Args:
             client_id (str): The client ID for authentication.
             client_secret (str): The client secret for authentication.
-            enviroment (str, optional): The API endpoint.
+            environment (str, optional): The API endpoint.
+            oauth_scope (str, optional): The scopes to use for authentication. In general this does not need to be changed.
+            cert_path (str, optional): An optional path to a certificate file useful for development.
+            token (dict, optional): If you already have a token that the client should use for authentication. Important, if set, this needs to be the complete token object containing the access token, token type and expiration time.
+            leeway (int, optional): An optional leeway to use to determine if a token is expired. Defaults to 60 seconds.
 
         Attributes:
             order (RapidataOrderManager): The RapidataOrderManager instance.
@@ -32,17 +41,19 @@ class RapidataClient:
         self._openapi_service = OpenAPIService(
             client_id=client_id,
             client_secret=client_secret,
-            enviroment=enviroment,
+            environment=environment,
             oauth_scope=oauth_scope,
-            cert_path=cert_path
+            cert_path=cert_path,
+            token=token,
+            leeway=leeway,
         )
-        
+
         self.order = RapidataOrderManager(openapi_service=self._openapi_service)
-        
+
         self.validation = ValidationSetManager(openapi_service=self._openapi_service)
 
         self._demographic = DemographicManager(openapi_service=self._openapi_service)
 
     def reset_credentials(self):
-        """Reset the credentials saved in the configuration file for the current enviroment."""
+        """Reset the credentials saved in the configuration file for the current environment."""
         self._openapi_service.reset_credentials()

{rapidata-2.17.1 → rapidata-2.18.0}/src/rapidata/rapidata_client/selection/__init__.py

@@ -5,3 +5,5 @@ from .validation_selection import ValidationSelection
 from .conditional_validation_selection import ConditionalValidationSelection
 from .capped_selection import CappedSelection
 from .shuffling_selection import ShufflingSelection
+from .ab_test_selection import AbTestSelection
+from .static_selection import StaticSelection

rapidata-2.18.0/src/rapidata/rapidata_client/selection/static_selection.py

@@ -0,0 +1,22 @@
+
+from rapidata.api_client.models.static_selection import StaticSelection as StaticSelectionModel
+from rapidata.rapidata_client.selection._base_selection import RapidataSelection
+
+class StaticSelection(RapidataSelection):
+    """StaticSelection Class
+
+    Given a list of RapidIds, theses specific rapids will be shown in order for every session.
+    
+    Args:
+        selections (list[str]): List of rapid ids to show.
+    """
+
+    def __init__(self, rapid_ids: list[str]):
+        self.rapid_ids = rapid_ids
+
+    def _to_model(self) -> StaticSelectionModel:
+        return StaticSelectionModel(
+            _t="StaticSelection",
+            rapidIds=self.rapid_ids
+        )
+    

{rapidata-2.17.1 → rapidata-2.18.0}/src/rapidata/rapidata_client/validation/validation_set_manager.py

@@ -468,7 +468,7 @@ class ValidationSetManager:
         if print_confirmation:
             print()
             print(f"Validation set '{name}' created with ID {validation_set_id}\n",
-                  f"Now viewable under: https://app.{self.__openapi_service.enviroment}/validation-set/detail/{validation_set_id}",
+                  f"Now viewable under: https://app.{self.__openapi_service.environment}/validation-set/detail/{validation_set_id}",
                   sep="")
         
         if dimensions:

{rapidata-2.17.1 → rapidata-2.18.0}/src/rapidata/service/credential_manager.py

@@ -133,9 +133,9 @@ class CredentialManager:
                 return credential
 
         return self._create_new_credentials()
-    
+
     def reset_credentials(self) -> None:
-        """Reset the stored credentials for current enviroment."""
+        """Reset the stored credentials for current environment."""
         credentials = self._read_credentials()
         if self.endpoint in credentials:
             del credentials[self.endpoint]

{rapidata-2.17.1 → rapidata-2.18.0}/src/rapidata/service/openapi_service.py

@@ -1,3 +1,6 @@
+import subprocess
+from importlib.metadata import version, PackageNotFoundError
+
 from rapidata.api_client.api.campaign_api import CampaignApi
 from rapidata.api_client.api.dataset_api import DatasetApi
 from rapidata.api_client.api.order_api import OrderApi
@@ -7,31 +10,31 @@ from rapidata.api_client.api.validation_api import ValidationApi
 from rapidata.api_client.api.workflow_api import WorkflowApi
 from rapidata.api_client.api_client import ApiClient
 from rapidata.api_client.configuration import Configuration
-from rapidata.service.token_manager import TokenManager, TokenInfo
 from rapidata.service.credential_manager import CredentialManager
 
-from importlib.metadata import version, PackageNotFoundError
-
 
 class OpenAPIService:
     def __init__(
-        self,
-        client_id: str | None,
-        client_secret: str | None,
-        enviroment: str,
-        oauth_scope: str,
-        cert_path: str | None = None,
+            self,
+            client_id: str | None,
+            client_secret: str | None,
+            environment: str,
+            oauth_scope: str,
+            cert_path: str | None = None,
+            token: dict | None = None,
+            leeway: int = 60,
     ):
-        self.enviroment = enviroment
-        endpoint = f"https://api.{enviroment}"
-        self._token_url = f"https://auth.{enviroment}"
-        token_manager = TokenManager(
-            client_id=client_id,
-            client_secret=client_secret,
-            endpoint=self._token_url,
-            oauth_scope=oauth_scope,
-            cert_path=cert_path,
+        self.environment = environment
+        endpoint = f"https://api.{environment}"
+        auth_endpoint = f"https://auth.{environment}"
+
+        if environment == "rapidata.dev" and not cert_path:
+            cert_path = _get_local_certificate()
+
+        self.credential_manager = CredentialManager(
+            endpoint=auth_endpoint, cert_path=cert_path
         )
+
         client_configuration = Configuration(host=endpoint, ssl_ca_cert=cert_path)
         self.api_client = ApiClient(
             configuration=client_configuration,
@@ -39,16 +42,32 @@ class OpenAPIService:
             header_value=f"RapidataPythonSDK/{self._get_rapidata_package_version()}",
         )
 
-        self.api_client.configuration.api_key["bearer"] = (
-            f"Bearer {token_manager.fetch_token().access_token}"
+        if token:
+            self.api_client.rest_client.setup_oauth_with_token(
+                token=token,
+                token_endpoint=f"{auth_endpoint}/connect/token",
+                client_id=client_id,
+                client_secret=client_secret,
+                leeway=leeway,
+            )
+            return
+
+        if not client_id or not client_secret:
+            credentials = self.credential_manager.get_client_credentials()
+            if not credentials:
+                raise ValueError("Failed to fetch client credentials")
+            client_id = credentials.client_id
+            client_secret = credentials.client_secret
+
+        self.api_client.rest_client.setup_oauth_client_credentials(
+            client_id=client_id,
+            client_secret=client_secret,
+            token_endpoint=f"{auth_endpoint}/connect/token",
+            scope=oauth_scope,
         )
 
-        self._cert_path = cert_path
-
-        token_manager.start_token_refresh(token_callback=self._set_token)
-
     def reset_credentials(self):
-        CredentialManager(endpoint=self._token_url, cert_path=self._cert_path).reset_credentials()
+        self.credential_manager.reset_credentials()
 
     @property
     def order_api(self) -> OrderApi:
@@ -78,9 +97,6 @@ class OpenAPIService:
     def workflow_api(self) -> WorkflowApi:
         return WorkflowApi(self.api_client)
 
-    def _set_token(self, token: TokenInfo):
-        self.api_client.configuration.api_key["bearer"] = f"Bearer {token.access_token}"
-
     def _get_rapidata_package_version(self):
         """
         Returns the version of the currently installed rapidata package.
@@ -93,3 +109,15 @@ class OpenAPIService:
             return version("rapidata")
         except PackageNotFoundError:
             return None
+
+
+def _get_local_certificate() -> str | None:
+    result = subprocess.run(["mkcert", "-CAROOT"], capture_output=True)
+    if result.returncode != 0:
+        return None
+
+    output = result.stdout.decode("utf-8").strip()
+    if not output:
+        return None
+
+    return f"{output}/rootCA.pem"