benchling-sdk 1.10.0a9__tar.gz → 1.10.0a11__tar.gz

{benchling_sdk-1.10.0a9 → benchling_sdk-1.10.0a11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: benchling-sdk
-Version: 1.10.0a9
+Version: 1.10.0a11
 Summary: SDK for interacting with the Benchling Platform.
 License: Apache-2.0
 Author: Benchling Support
@@ -17,7 +17,7 @@ Provides-Extra: python-jose
 Requires-Dist: PyYAML (>=6.0,<7.0)
 Requires-Dist: attrs (>=20.1.0,<23)
 Requires-Dist: backoff (>=1.10.0,<2.0.0)
-Requires-Dist: benchling-api-client (==2.0.243)
+Requires-Dist: benchling-api-client (==2.0.244)
 Requires-Dist: certifi (>=2022.12.7)
 Requires-Dist: cryptography (>=41.0.3,<42.0.0) ; extra == "cryptography"
 Requires-Dist: dataclasses-json (>=0.5.2,<0.6.0)

{benchling_sdk-1.10.0a9 → benchling_sdk-1.10.0a11}/benchling_sdk/apps/canvas/framework.py

@@ -399,7 +399,7 @@ class CanvasBuilder:
             enabled=canvas.enabled,
             session_id=canvas.session_id,
             blocks=canvas.blocks,
-            data=json.loads(canvas.data) if canvas.data is not None else None,
+            data=json.loads(canvas.data) if isinstance(canvas.data, str) else None,
         )
 
     def _with_enabled(self, value: bool) -> CanvasBuilder:
@@ -631,6 +631,9 @@ class CanvasBuilder:
         """
         return json.loads(self._source_canvas.data) if self._source_canvas.data is not None else None
 
+    def __eq__(self, other) -> bool:
+        return isinstance(other, CanvasBuilder) and self._source_canvas == other._source_canvas
+
 
 def _is_included_class(included_classes: Set[Type[UiBlock]], target_class: UiBlock) -> bool:
     return isinstance(target_class, tuple(c for c in included_classes))

{benchling_sdk-1.10.0a9 → benchling_sdk-1.10.0a11}/benchling_sdk/apps/framework.py

@@ -11,9 +11,6 @@ from benchling_sdk.apps.status.framework import (
     SessionContextManager,
 )
 from benchling_sdk.benchling import Benchling
-from benchling_sdk.helpers.logging_helpers import log_stability_warning, StabilityLevel
-
-log_stability_warning(StabilityLevel.ALPHA)
 
 
 class App:

{benchling_sdk-1.10.0a9 → benchling_sdk-1.10.0a11}/benchling_sdk/apps/helpers/webhook_helpers.py

@@ -11,7 +11,7 @@ from benchling_sdk.helpers.logging_helpers import log_stability_warning, Stabili
 from benchling_sdk.helpers.package_helpers import _required_packages_context, ExtrasPackage
 from benchling_sdk.services.v2.stable.api_service import build_json_response
 
-log_stability_warning(StabilityLevel.ALPHA)
+log_stability_warning(StabilityLevel.BETA)
 
 
 class WebhookVerificationError(Exception):
@@ -104,7 +104,7 @@ def verify_app_installation(
     Resolves JWKs from Benchling with default settings. Pass jwk_function for customization.
 
     This method will eventually be replaced with verify(app_definition_id) once Benchling Apps
-    are migrated to global.
+    have global JWKs available for their app definition id.
     """
     _verify_headers_present(headers)
     _verify_timestamp(headers["webhook-timestamp"])

{benchling_sdk-1.10.0a9 → benchling_sdk-1.10.0a11}/benchling_sdk/apps/status/errors.py

@@ -80,3 +80,6 @@ class AppUserFacingError(Exception):
             AppSessionMessageCreate(content=message, style=AppSessionMessageStyle.ERROR)
             for message in self._messages
         ]
+
+    def __str__(self) -> str:
+        return "\n".join(self._messages) if self._messages else ""

{benchling_sdk-1.10.0a9 → benchling_sdk-1.10.0a11}/benchling_sdk/errors.py

@@ -183,8 +183,8 @@ class AppSessionClosedError(ExtendedBenchlingErrorBase):
 
 
 @dataclass
-class InvalidDatasetError(Exception):
-    """A general error related to Benchling Datasets."""
+class InvalidDataFrameError(Exception):
+    """A general error related to Benchling DataFrames."""
 
     message: str
 
@@ -193,8 +193,8 @@ class InvalidDatasetError(Exception):
 
 
 @dataclass
-class DatasetInProgressError(Exception):
-    """An error for Benchling datasets for unavailable data operations on a Dataset in progress."""
+class DataFrameInProgressError(Exception):
+    """An error for Benchling data frames for unavailable data operations on a DataFrame in progress."""
 
     message: str
 

benchling_sdk-1.10.0a9/benchling_sdk/services/v2/beta/v2_beta_dataset_service.py → benchling_sdk-1.10.0a11/benchling_sdk/services/v2/beta/v2_beta_data_frame_service.py

@@ -4,77 +4,79 @@ from pathlib import Path
 import tempfile
 from typing import Dict, List, Optional, Union
 
-from benchling_api_client.v2.beta.api.datasets import create_dataset, get_dataset, patch_dataset
-from benchling_api_client.v2.beta.models.dataset import Dataset
-from benchling_api_client.v2.beta.models.dataset_create import DatasetCreate
-from benchling_api_client.v2.beta.models.dataset_create_manifest_manifest_item import (
-    DatasetCreateManifestManifestItem,
+from benchling_api_client.v2.beta.api.data_frames import create_data_frame, get_data_frame, patch_data_frame
+from benchling_api_client.v2.beta.models.data_frame import DataFrame
+from benchling_api_client.v2.beta.models.data_frame_create import DataFrameCreate
+from benchling_api_client.v2.beta.models.data_frame_create_manifest_manifest_item import (
+    DataFrameCreateManifestManifestItem,
 )
-from benchling_api_client.v2.beta.models.dataset_update import DatasetUpdate
-from benchling_api_client.v2.beta.models.dataset_update_upload_status import DatasetUpdateUploadStatus
+from benchling_api_client.v2.beta.models.data_frame_update import DataFrameUpdate
+from benchling_api_client.v2.beta.models.data_frame_update_upload_status import DataFrameUpdateUploadStatus
 from benchling_api_client.v2.beta.models.file_status_upload_status import FileStatusUploadStatus
 from benchling_api_client.v2.types import Response
 import httpx
 
-from benchling_sdk.errors import DatasetInProgressError, InvalidDatasetError, raise_for_status
+from benchling_sdk.errors import DataFrameInProgressError, InvalidDataFrameError, raise_for_status
 from benchling_sdk.helpers.decorators import api_method
 from benchling_sdk.helpers.response_helpers import model_from_detailed
 from benchling_sdk.models import AsyncTaskLink
 from benchling_sdk.services.v2.base_service import BaseService
 
-_DEFAULT_HTTP_TIMEOUT_UPLOAD_DATASET: float = 60.0
+_DEFAULT_HTTP_TIMEOUT_UPLOAD_DATA_FRAME: float = 60.0
 
 
-class V2BetaDatasetService(BaseService):
+class V2BetaDataFrameService(BaseService):
     """
-    V2-Beta Datasets.
+    V2-Beta Data Frames.
 
-    Datasets are Benchling objects that represent tabular data with typed columns and rows of data.
+    Data Frames are Benchling objects that represent tabular data with typed columns and rows of data.
 
-    See https://benchling.com/api/v2-beta/reference#/Dataset
+    See https://benchling.com/api/v2-beta/reference#/Data%20Frames
     """
 
     @api_method
-    def get_by_id(self, dataset_id: str) -> Dataset:
+    def get_by_id(self, data_frame_id: str) -> DataFrame:
         """
-        Get a dataset and URLs to download its data.
+        Get a data frame and URLs to download its data.
 
-        See https://benchling.com/api/v2-beta/reference#/Datasets/getDataset
+        See https://benchling.com/api/v2-beta/reference#/Data%20Frames/getDataFrame
         """
-        response = get_dataset.sync_detailed(client=self.client, dataset_id=dataset_id)
+        response = get_data_frame.sync_detailed(client=self.client, data_frame_id=data_frame_id)
         return model_from_detailed(response)
 
     @api_method
-    def create(self, dataset: DatasetCreate) -> Dataset:
+    def create(self, data_frame: DataFrameCreate) -> DataFrame:
         """
-        Create a dataset.
+        Create a data frame.
 
-        See https://benchling.com/api/v2-beta/reference#/Datasets/createDataset
+        See https://benchling.com/api/v2-beta/reference#/Data%20Frames/createDataFrame
         """
-        response = create_dataset.sync_detailed(client=self.client, json_body=dataset)
+        response = create_data_frame.sync_detailed(client=self.client, json_body=data_frame)
         return model_from_detailed(response)
 
     @api_method
-    def update(self, dataset_id: str, dataset: DatasetUpdate) -> AsyncTaskLink:
+    def update(self, data_frame_id: str, data_frame: DataFrameUpdate) -> AsyncTaskLink:
         """
-        Update a dataset.
+        Update a data frame.
 
-        See https://benchling.com/api/v2-beta/reference#/Datasets/patchDataset
+        See https://benchling.com/api/v2-beta/reference#/Data%20Frames/patchDataFrame
         """
-        response = patch_dataset.sync_detailed(client=self.client, dataset_id=dataset_id, json_body=dataset)
+        response = patch_data_frame.sync_detailed(
+            client=self.client, data_frame_id=data_frame_id, json_body=data_frame
+        )
         return model_from_detailed(response)
 
     def upload_bytes(
         self,
         url: str,
         input_bytes: Union[BytesIO, bytes],
-        timeout_seconds: float = _DEFAULT_HTTP_TIMEOUT_UPLOAD_DATASET,
+        timeout_seconds: float = _DEFAULT_HTTP_TIMEOUT_UPLOAD_DATA_FRAME,
     ) -> None:
-        """Upload bytes to an existing dataset.
+        """Upload bytes to an existing data frame.
 
-        :param url: The url provided by Benchling for uploading to the dataset
+        :param url: The url provided by Benchling for uploading to the data frame
         :param input_bytes: Data to upload as bytes or BytesIO
-        :param timeout_seconds: Extends the normal HTTP timeout settings since Dataset uploads can be large
+        :param timeout_seconds: Extends the normal HTTP timeout settings since DataFrame uploads can be large
             Use this to extend even further if streams are very large
         """
         # Use a completely different client instead of our configured self.client.httpx_client
@@ -86,17 +88,19 @@ class V2BetaDatasetService(BaseService):
         raise_for_status(response)
 
     def upload_file(
-        self, url: str, file: Path, timeout_seconds: float = _DEFAULT_HTTP_TIMEOUT_UPLOAD_DATASET
+        self, url: str, file: Path, timeout_seconds: float = _DEFAULT_HTTP_TIMEOUT_UPLOAD_DATA_FRAME
     ) -> None:
-        """Upload a file to an existing dataset.
+        """Upload a file to an existing data frame.
 
-        :param url: The url provided by Benchling for uploading to the dataset
+        :param url: The url provided by Benchling for uploading to the data frame
         :param file: A valid Path to an existing file containing the data to upload
-        :param timeout_seconds: Extends the normal HTTP timeout settings since Dataset uploads can be large
+        :param timeout_seconds: Extends the normal HTTP timeout settings since DataFrame uploads can be large
             Use this to extend even further if streams are very large
         """
         if file.is_dir():
-            raise IsADirectoryError(f"Cannot write dataset from directory '{file}', specify a file instead")
+            raise IsADirectoryError(
+                f"Cannot write data frame from directory '{file}', specify a file instead"
+            )
         # Use a completely different client instead of our configured self.client.httpx_client
         # Amazon will reject clients sending other headers besides the ones it expects
         files = {"file": open(file, "rb")}
@@ -107,113 +111,117 @@ class V2BetaDatasetService(BaseService):
     @api_method
     def create_from_bytes(
         self,
-        dataset: DatasetCreate,
+        data_frame: DataFrameCreate,
         input_bytes: Union[BytesIO, bytes],
-        timeout_seconds: float = _DEFAULT_HTTP_TIMEOUT_UPLOAD_DATASET,
+        timeout_seconds: float = _DEFAULT_HTTP_TIMEOUT_UPLOAD_DATA_FRAME,
     ) -> AsyncTaskLink:
-        """Create a dataset from bytes or BytesIO data.
+        """Create a data frame from bytes or BytesIO data.
 
-        :param dataset: The DatasetCreate specification for the data. This must be provided, as it cannot be inferred from file names.
+        :param data_frame: The DataFrameCreate specification for the data. This must be provided, as it cannot be inferred from file names.
         :param input_bytes: Data to upload as bytes or BytesIO
-        :param timeout_seconds: Extends the normal HTTP timeout settings since Dataset uploads can be large
+        :param timeout_seconds: Extends the normal HTTP timeout settings since DataFrame uploads can be large
             Use this to extend even further if streams are very large
-        :return: An AsyncTaskLink that can be polled to know when the dataset has completed processing
+        :return: An AsyncTaskLink that can be polled to know when the data frame has completed processing
         :rtype: AsyncTaskLink
         """
-        # This is a current limit of the Dataset API. We may need additional methods in the future
+        # This is a current limit of the DataFrame API. We may need additional methods in the future
         # to allow multi upload
-        if not dataset.manifest:
-            raise InvalidDatasetError("The dataset manifest must contain exactly 1 item")
-        elif len(dataset.manifest) != 1:
-            raise InvalidDatasetError(
-                f"The dataset manifest contains {len(dataset.manifest)} items. It must contain exactly 1"
+        if not data_frame.manifest:
+            raise InvalidDataFrameError("The data frame manifest must contain exactly 1 item")
+        elif len(data_frame.manifest) != 1:
+            raise InvalidDataFrameError(
+                f"The data frame manifest contains {len(data_frame.manifest)} items. It must contain exactly 1"
             )
-        created_dataset = self.create(dataset)
-        manifest_item = created_dataset.manifest[0]
+        created_data_frame = self.create(data_frame)
+        manifest_item = created_data_frame.manifest[0]
 
         # This would be unexpected and probably an error from the API return. Likely not a user error. This check appeases MyPy.
         if manifest_item.url is None:
-            raise InvalidDatasetError(
-                f"The dataset manifest URL is None. The dataset {created_dataset.id} is not available for data upload."
+            raise InvalidDataFrameError(
+                f"The data frame manifest URL is None. The data frame {created_data_frame.id} is not available for data upload."
             )
         self.upload_bytes(url=manifest_item.url, input_bytes=input_bytes, timeout_seconds=timeout_seconds)
-        dataset_update = DatasetUpdate(upload_status=DatasetUpdateUploadStatus.IN_PROGRESS)
-        return self.update(dataset_id=created_dataset.id, dataset=dataset_update)
+        data_frame_update = DataFrameUpdate(upload_status=DataFrameUpdateUploadStatus.IN_PROGRESS)
+        return self.update(data_frame_id=created_data_frame.id, data_frame=data_frame_update)
 
     @api_method
     def create_from_file(
         self,
         file: Path,
-        dataset: Optional[DatasetCreate] = None,
-        timeout_seconds: float = _DEFAULT_HTTP_TIMEOUT_UPLOAD_DATASET,
+        data_frame: Optional[DataFrameCreate] = None,
+        timeout_seconds: float = _DEFAULT_HTTP_TIMEOUT_UPLOAD_DATA_FRAME,
     ) -> AsyncTaskLink:
-        """Create a dataset from file data.
+        """Create a data frame from file data.
 
         :param file: A valid Path to an existing file containing the data to upload
-        :param dataset: The DatasetCreate specification for the data. If not provided, it will be inferred from the file name
-        :param timeout_seconds: Extends the normal HTTP timeout settings since Dataset uploads can be large
+        :param data_frame: The DataFrameCreate specification for the data. If not provided, it will be inferred from the file name
+        :param timeout_seconds: Extends the normal HTTP timeout settings since DataFrame uploads can be large
             Use this to extend even further if streams are very large
-        :return: An AsyncTaskLink that can be polled to know when the dataset has completed processing
+        :return: An AsyncTaskLink that can be polled to know when the data frame has completed processing
         :rtype: AsyncTaskLink
         """
         if file.is_dir():
-            raise IsADirectoryError(f"Cannot write dataset from directory '{file}', specify a file instead")
+            raise IsADirectoryError(
+                f"Cannot write data frame from directory '{file}', specify a file instead"
+            )
         with open(file, "rb") as file_handle:
             input_bytes = file_handle.read()
-        if not dataset:
-            dataset = DatasetCreate(
+        if not data_frame:
+            data_frame = DataFrameCreate(
                 name=f"{datetime.now()} {file.name}",
-                manifest=[DatasetCreateManifestManifestItem(file_name=file.name)],
+                manifest=[DataFrameCreateManifestManifestItem(file_name=file.name)],
             )
         return self.create_from_bytes(
-            dataset=dataset, input_bytes=input_bytes, timeout_seconds=timeout_seconds
+            data_frame=data_frame, input_bytes=input_bytes, timeout_seconds=timeout_seconds
         )
 
-    def download_dataset_bytes(
-        self, dataset: Dataset, timeout_seconds: float = _DEFAULT_HTTP_TIMEOUT_UPLOAD_DATASET
+    def download_data_frame_bytes(
+        self, data_frame: DataFrame, timeout_seconds: float = _DEFAULT_HTTP_TIMEOUT_UPLOAD_DATA_FRAME
     ) -> List[BytesIO]:
-        """Download dataset data to bytes.
+        """Download data frame data to bytes.
 
-        :param dataset: The dataset to download
-        :param timeout_seconds: Extends the normal HTTP timeout settings since Dataset uploads can be large
+        :param data_frame: The data frame to download
+        :param timeout_seconds: Extends the normal HTTP timeout settings since DataFrame uploads can be large
             Use this to extend even further if streams are very large
-        :return: An ordered list of BytesIO streams corresponding to a manifest item in the dataset
+        :return: An ordered list of BytesIO streams corresponding to a manifest item in the data frame
         :rtype: List[BytesIO]
         """
-        if dataset.upload_status != FileStatusUploadStatus.SUCCEEDED:
-            raise DatasetInProgressError(
-                f"The dataset data cannot be downloaded until the status is {FileStatusUploadStatus.SUCCEEDED}. "
-                f"The status of dataset {dataset.id} is {dataset.upload_status}"
+        if data_frame.upload_status != FileStatusUploadStatus.SUCCEEDED:
+            raise DataFrameInProgressError(
+                f"The data frame data cannot be downloaded until the status is {FileStatusUploadStatus.SUCCEEDED}. "
+                f"The status of data frame {data_frame.id} is {data_frame.upload_status}"
             )
-        dataset_bytes = []
-        for manifest_item in dataset.manifest:
+        data_frame_bytes = []
+        for manifest_item in data_frame.manifest:
             # This should be present based on the status check above. Assertion satisfies MyPy
-            assert manifest_item.url is not None, f"Unable to download dataset {dataset.id}, URL was empty"
+            assert (
+                manifest_item.url is not None
+            ), f"Unable to download data frame {data_frame.id}, URL was empty"
             with httpx.stream("GET", manifest_item.url, timeout=timeout_seconds) as download_stream:
                 target_bytes = BytesIO()
                 for chunk in download_stream.iter_bytes():
                     target_bytes.write(chunk)
                 target_bytes.seek(0)
-                dataset_bytes.append(target_bytes)
-        return dataset_bytes
+                data_frame_bytes.append(target_bytes)
+        return data_frame_bytes
 
-    def download_dataset_files(
+    def download_data_frame_files(
         self,
-        dataset: Dataset,
+        data_frame: DataFrame,
         destination_path: Optional[Path] = None,
-        timeout_seconds: float = _DEFAULT_HTTP_TIMEOUT_UPLOAD_DATASET,
+        timeout_seconds: float = _DEFAULT_HTTP_TIMEOUT_UPLOAD_DATA_FRAME,
     ) -> List[Path]:
-        """Download dataset data to files.
+        """Download data frame data to files.
 
-        :param dataset: The dataset to download
+        :param data_frame: The data frame to download
         :param destination_path: A target directory to place the files. File names will be created based on the manifest item file names.
             If not specified, a temp directory will be created. The caller is responsible for deleting this directory.
-        :param timeout_seconds: Extends the normal HTTP timeout settings since Dataset uploads can be large
+        :param timeout_seconds: Extends the normal HTTP timeout settings since DataFrame uploads can be large
             Use this to extend even further if streams are very large
-        :return: An ordered list of downloaded file paths corresponding to a manifest item in the dataset
+        :return: An ordered list of downloaded file paths corresponding to a manifest item in the data frame
         :rtype: List[Path]
         """
-        dataset_files = []
+        data_frame_files = []
         if not destination_path:
             destination_path = Path(tempfile.mkdtemp())
         elif destination_path.is_file():
@@ -222,61 +230,63 @@ class V2BetaDatasetService(BaseService):
             )
         elif not destination_path.exists():
             raise NotADirectoryError(f"The destination path '{destination_path}' does not exist")
-        if dataset.upload_status != FileStatusUploadStatus.SUCCEEDED:
-            raise DatasetInProgressError(
-                f"The dataset data cannot be downloaded until the status is {FileStatusUploadStatus.SUCCEEDED}. "
-                f"The status of dataset {dataset.id} is {dataset.upload_status}"
+        if data_frame.upload_status != FileStatusUploadStatus.SUCCEEDED:
+            raise DataFrameInProgressError(
+                f"The data frame data cannot be downloaded until the status is {FileStatusUploadStatus.SUCCEEDED}. "
+                f"The status of data frame {data_frame.id} is {data_frame.upload_status}"
             )
-        for manifest_item in dataset.manifest:
+        for manifest_item in data_frame.manifest:
             target_path = destination_path / manifest_item.file_name
-            dataset_files.append(target_path)
+            data_frame_files.append(target_path)
             # This should be present based on the status check above. Assertion satisfies MyPy
-            assert manifest_item.url is not None, f"Unable to download dataset {dataset.id}, URL was empty"
-            with open(target_path, "wb") as dataset_handle:
+            assert (
+                manifest_item.url is not None
+            ), f"Unable to download data frame {data_frame.id}, URL was empty"
+            with open(target_path, "wb") as data_frame_handle:
                 with httpx.stream("GET", manifest_item.url, timeout=timeout_seconds) as download_stream:
                     for chunk in download_stream.iter_bytes():
-                        dataset_handle.write(chunk)
-        return dataset_files
+                        data_frame_handle.write(chunk)
+        return data_frame_files
 
     @api_method
-    def download_dataset_bytes_by_id(
-        self, dataset_id: str, timeout_seconds: float = _DEFAULT_HTTP_TIMEOUT_UPLOAD_DATASET
+    def download_data_frame_bytes_by_id(
+        self, data_frame_id: str, timeout_seconds: float = _DEFAULT_HTTP_TIMEOUT_UPLOAD_DATA_FRAME
     ) -> List[BytesIO]:
-        """Download dataset data to files by dataset_id.
+        """Download data frame data to files by data_frame_id.
 
-        Fetches the dataset first, then downloads the files.
+        Fetches the data frame first, then downloads the files.
 
-        :param dataset_id: The id of the dataset to download
-        :param timeout_seconds: Extends the normal HTTP timeout settings since Dataset uploads can be large
+        :param data_frame_id: The id of the data frame to download
+        :param timeout_seconds: Extends the normal HTTP timeout settings since DataFrame uploads can be large
             Use this to extend even further if streams are very large
-        :return: An ordered list of BytesIO streams corresponding to a manifest item in the dataset
+        :return: An ordered list of BytesIO streams corresponding to a manifest item in the data frame
         :rtype: List[BytesIO]
         """
-        dataset = self.get_by_id(dataset_id=dataset_id)
-        return self.download_dataset_bytes(dataset=dataset, timeout_seconds=timeout_seconds)
+        data_frame = self.get_by_id(data_frame_id=data_frame_id)
+        return self.download_data_frame_bytes(data_frame=data_frame, timeout_seconds=timeout_seconds)
 
     @api_method
-    def download_dataset_files_by_id(
+    def download_data_frame_files_by_id(
         self,
-        dataset_id: str,
+        data_frame_id: str,
         destination_path: Optional[Path] = None,
-        timeout_seconds: float = _DEFAULT_HTTP_TIMEOUT_UPLOAD_DATASET,
+        timeout_seconds: float = _DEFAULT_HTTP_TIMEOUT_UPLOAD_DATA_FRAME,
     ) -> List[Path]:
-        """Download dataset data to files by dataset_id.
+        """Download data frame data to files by data_frame_id.
 
-        Fetches the dataset first, then downloads the files.
+        Fetches the data frame first, then downloads the files.
 
-        :param dataset_id: The id of the dataset to download
+        :param data_frame_id: The id of the data frame to download
         :param destination_path: A target directory to place the files. File names will be created based on the manifest item file names.
             If not specified, a temp directory will be created. The caller is responsible for deleting this directory.
-        :param timeout_seconds: Extends the normal HTTP timeout settings since Dataset uploads can be large
+        :param timeout_seconds: Extends the normal HTTP timeout settings since DataFrame uploads can be large
             Use this to extend even further if streams are very large
-        :return: An ordered list of downloaded file paths corresponding to a manifest item in the dataset
+        :return: An ordered list of downloaded file paths corresponding to a manifest item in the data frame
         :rtype: List[Path]
         """
-        dataset = self.get_by_id(dataset_id=dataset_id)
-        return self.download_dataset_files(
-            dataset=dataset, destination_path=destination_path, timeout_seconds=timeout_seconds
+        data_frame = self.get_by_id(data_frame_id=data_frame_id)
+        return self.download_data_frame_files(
+            data_frame=data_frame, destination_path=destination_path, timeout_seconds=timeout_seconds
         )
 
 

{benchling_sdk-1.10.0a9 → benchling_sdk-1.10.0a11}/benchling_sdk/services/v2/v2_beta_service.py

@@ -7,7 +7,7 @@ from benchling_api_client.v2.stable.client import Client
 from benchling_sdk.helpers.client_helpers import v2_beta_client
 from benchling_sdk.helpers.retry_helpers import RetryStrategy
 from benchling_sdk.services.v2.base_service import BaseService
-from benchling_sdk.services.v2.beta.v2_beta_dataset_service import V2BetaDatasetService
+from benchling_sdk.services.v2.beta.v2_beta_data_frame_service import V2BetaDataFrameService
 
 if TYPE_CHECKING:
     from benchling_sdk.services.v2.beta.v2_beta_aa_sequence_service import V2BetaAaSequenceService
@@ -37,7 +37,7 @@ class V2BetaService(BaseService):
     _app_service: Optional[V2BetaAppService]
     _collaboration_service: Optional[V2BetaCollaborationService]
     _custom_entity_service: Optional[V2BetaCustomEntityService]
-    _dataset_service: Optional[V2BetaDatasetService]
+    _data_frame_service: Optional[V2BetaDataFrameService]
     _dna_oligo_service: Optional[V2BetaDnaOligoService]
     _dna_sequence_service: Optional[V2BetaDnaSequenceService]
     _entity_service: Optional[V2BetaEntityService]
@@ -61,7 +61,7 @@ class V2BetaService(BaseService):
         self._app_service = None
         self._collaboration_service = None
         self._custom_entity_service = None
-        self._dataset_service = None
+        self._data_frame_service = None
         self._dna_sequence_service = None
         self._dna_oligo_service = None
         self._entity_service = None
@@ -137,19 +137,19 @@ class V2BetaService(BaseService):
         return self._custom_entity_service
 
     @property
-    def datasets(self) -> V2BetaDatasetService:
+    def data_frames(self) -> V2BetaDataFrameService:
         """
-        V2-Beta Datasets.
+        V2-Beta DataFrames.
 
-        Datasets are Benchling objects that represent tabular data with typed columns and rows of data.
+        DataFrames are Benchling objects that represent tabular data with typed columns and rows of data.
 
-        See https://benchling.com/api/v2-beta/reference#/Datasets
+        See https://benchling.com/api/v2-beta/reference#/Data%20Frames
         """
-        if self._dataset_service is None:
-            from benchling_sdk.services.v2.beta.v2_beta_dataset_service import V2BetaDatasetService
+        if self._data_frame_service is None:
+            from benchling_sdk.services.v2.beta.v2_beta_data_frame_service import V2BetaDataFrameService
 
-            self._dataset_service = V2BetaDatasetService(self._beta_client, self.retry_strategy)
-        return self._dataset_service
+            self._data_frame_service = V2BetaDataFrameService(self._beta_client, self.retry_strategy)
+        return self._data_frame_service
 
     @property
     def dna_oligos(self) -> V2BetaDnaOligoService:

{benchling_sdk-1.10.0a9 → benchling_sdk-1.10.0a11}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "benchling-sdk"
-version = "1.10.0a9"   # NOTE: This version number is ignored and does not correspond to releases (see README)
+version = "1.10.0a11"   # NOTE: This version number is ignored and does not correspond to releases (see README)
 description = "SDK for interacting with the Benchling Platform."
 authors = ["Benchling Support <support@benchling.com>"]
 packages = [{include = "benchling_sdk"}]
@@ -28,7 +28,7 @@ PyYAML = "^6.0"
 # See issue: https://github.com/giampaolo/psutil/issues/2165
 psutil = {version = "^5.9.4", python = "^3.11" }
 jwcrypto = "^1.4.2"
-benchling-api-client = "2.0.243"
+benchling-api-client = "2.0.244"
 # Minimum version due to vulnerability in 2022.9.24
 certifi = ">=2022.12.7"
 # Cryptography extras - see ExtrasPackage.CRYPTOGRAPHY