datalab-api 0.4.0__tar.gz → 0.5.1__tar.gz

{datalab_api-0.4.0/src/datalab_api.egg-info → datalab_api-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datalab-api
-Version: 0.4.0
+Version: 0.5.1
 Summary: A Python API for instances of the datalab data management platform (https://github.com/datalab-org/datalab).
 Author-email: Matthew Evans <matthew@ml-evs.science>
 License-Expression: MIT

{datalab_api-0.4.0 → datalab_api-0.5.1}/src/datalab_api/__init__.py

@@ -127,6 +127,8 @@ class DatalabClient(BaseDatalabClient):
         item_type: str = "samples",
         item_data: dict[str, Any] | None = None,
         collection_id: str | None = None,
+        collection_ids: str | Iterable[str] | None = None,  # alias for collection_id
+        group_ids: str | Iterable[str] | None = None,
     ) -> dict[str, Any]:
         """Create an item with a given ID and item data.
 
@@ -135,7 +137,9 @@ class DatalabClient(BaseDatalabClient):
             item_type: The type of item to create, e.g., 'samples', 'cells'.
             item_data: The data for the item.
             collection_id: The ID of the collection to add the item to (optional).
-                If such a collection does not exist, one will be made.
+                If such a collection does not exist, one will be made. Deprecated in favor of `collection_ids`.
+            collection_ids: The ID or IDs of the collection(s) to add the item to (optional).
+            group_ids: The ID or IDs of the group(s) to share the item with (optional).
 
         """
         new_item = {}
@@ -147,13 +151,34 @@ class DatalabClient(BaseDatalabClient):
             new_item.pop("item_id")
 
         if collection_id is not None:
-            try:
-                collection_immutable_id = self.get_collection(collection_id)[0]["immutable_id"]
-            except (RuntimeError, DatalabAPIError):
-                self.create_collection(collection_id)
-                collection_immutable_id = self.get_collection(collection_id)[0]["immutable_id"]
+            warnings.warn(
+                DeprecationWarning(
+                    "`collection_id` is deprecated, please use `collection_ids` instead."
+                )
+            )
+            if collection_ids is None:
+                collection_ids = [collection_id]
+
+        if collection_ids:
             new_item["collections"] = new_item.get("collections", [])
-            new_item["collections"].append({"immutable_id": collection_immutable_id})
+            for collection_id in collection_ids:
+                try:
+                    collection_immutable_id = self.get_collection(collection_id)[0]["immutable_id"]
+                except (RuntimeError, DatalabAPIError):
+                    self.create_collection(collection_id)
+                    collection_immutable_id = self.get_collection(collection_id)[0]["immutable_id"]
+                new_item["collections"].append({"immutable_id": collection_immutable_id})
+
+        if group_ids:
+            # For now, we have to use the search groups endpoint
+            # until we add a get group by id endpoint that is locked down per user
+            new_item["groups"] = new_item.get("groups", [])
+            for group_id in group_ids:
+                try:
+                    group_immutable_id = self.get_group(group_id)["immutable_id"]
+                    new_item["groups"].append({"immutable_id": group_immutable_id})
+                except (RuntimeError, DatalabAPIError):
+                    pass
 
         create_item_url = f"{self.datalab_api_url}/new-sample/"
         created_item = self._post(
@@ -248,7 +273,13 @@ class DatalabClient(BaseDatalabClient):
                     for chunk in response.iter_bytes(chunk_size=1024):
                         file.write(chunk)
 
-    def get_block(self, item_id: str, block_id: str, block_data: dict[str, Any]) -> dict[str, Any]:
+    def get_block(
+        self,
+        item_id: str,
+        block_id: str,
+        block_data: dict[str, Any] | None = None,
+        event_data: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
         """Get a block with a given ID and block data.
         Should be used in conjunction with `get_item` to load an existing block.
 
@@ -256,27 +287,39 @@ class DatalabClient(BaseDatalabClient):
             item_id: The ID of the item to search for.
             block_id: The ID of the block to search for.
             block_data: Any other block data required by the request.
+            event_data: Any block events to trigger.
 
         Returns:
             A dictionary of block data for the block with the given ID.
 
         """
-        block_url = f"{self.datalab_api_url}/update-block/"
+        block_url = f"{self.datalab_api_url}/blocks/"
+
+        if not block_data:
+            block_data = {}
+
+        block_data["item_id"] = item_id
+        block_data["block_id"] = block_id
+        if "blocktype" not in block_data:
+            raise ValueError("block_data must contain a 'blocktype' key.")
+
         block_request = {
             "block_data": block_data,
-            "item_id": item_id,
-            "block_id": block_id,
-            "save_to_db": False,
+            "event_data": event_data,
         }
         block = self._post(block_url, json=block_request)
         return block["new_block_data"]
 
-    def upload_file(self, item_id: str, file_path: Path | str) -> dict[str, Any]:
+    def upload_file(
+        self, item_id: str, file_path: Path | str, replace_file_id: str | None = None
+    ) -> dict[str, Any]:
         """Upload a file to an item with a given ID.
 
         Parameters:
             item_id: The ID of the item to upload the file to.
             file_path: The path to the file to upload.
+            replace_file_id: The ID of an existing file to replace with the uploaded file, if any.
+                If provided, the new file will take the place of the old file in any blocks it was attached to.
 
         Returns:
             A dictionary of the uploaded file data.
@@ -297,7 +340,7 @@ class DatalabClient(BaseDatalabClient):
             upload = self._post(
                 upload_url,
                 files=files,
-                data={"item_id": item_id, "replace_file": None},
+                data={"item_id": item_id, "replace_file": replace_file_id},
                 expected_status=201,
                 timeout=upload_timeout,
             )
@@ -395,10 +438,10 @@ class DatalabClient(BaseDatalabClient):
 
         if file_ids:
             if len(file_ids) > 1:
-                raise RuntimeError(
-                    "API does not currently support attaching multiple files in a block."
-                )
-            block_data["file_id"] = file_ids[0]
+                block_data["file_ids"] = file_ids
+            else:
+                block_data.pop("file_ids", None)
+                block_data["file_id"] = file_ids[0]
 
         blocks_url = f"{self.datalab_api_url}/update-block/"
         payload = {
@@ -435,6 +478,32 @@ class DatalabClient(BaseDatalabClient):
         collection = self._get(collection_url)
         return collection["data"], collection["child_items"]
 
+    def get_group(self, group_id: str) -> dict[str, Any]:
+        """Get a group with a given ID.
+
+        Uses the search groups endpoint under the hood,
+        so will only find groups that the user has access
+        to and that match the query.
+
+        Parameters:
+            group_id: The human-readable ID of the group to search for.
+
+        Returns:
+            A dictionary of group data for the group with the given ID.
+
+        Raises:
+            DatalabAPIError: If no group with the given ID is found.
+
+        """
+        group_url = f"{self.datalab_api_url}/search/groups?query={group_id}"
+        group_resp = self._get(group_url)
+        matching_groups = group_resp["data"]
+        if matching_groups:
+            matching_groups = [g for g in matching_groups if g.get("group_id") == group_id]
+            return matching_groups[0]
+
+        raise DatalabAPIError(f"No group found with ID {group_id!r}")
+
     def create_collection(
         self, collection_id: str, collection_data: dict | None = None
     ) -> dict[str, Any]:

{datalab_api-0.4.0 → datalab_api-0.5.1}/src/datalab_api/_base.py

@@ -35,7 +35,7 @@ class BaseDatalabClient(metaclass=AutoPrettyPrint):
 
     _api_key: Optional[str] = None
     _session: Optional[httpx.Client] = None
-    _headers: dict[str, str] = {}
+    _headers: dict[str, str]
     _timeout: httpx.Timeout = httpx.Timeout(10.0, read=60.0)
 
     interactive: bool = True
@@ -85,7 +85,7 @@ class BaseDatalabClient(metaclass=AutoPrettyPrint):
         self.log = logging.getLogger(__name__)
 
         self._http_client = httpx.Client
-        self._headers["User-Agent"] = f"Datalab Python API/{__version__}"
+        self._headers = {"User-Agent": f"Datalab Python API/{__version__}"}
 
         self._detect_api_url()
 

{datalab_api-0.4.0 → datalab_api-0.5.1/src/datalab_api.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datalab-api
-Version: 0.4.0
+Version: 0.5.1
 Summary: A Python API for instances of the datalab data management platform (https://github.com/datalab-org/datalab).
 Author-email: Matthew Evans <matthew@ml-evs.science>
 License-Expression: MIT

{datalab_api-0.4.0 → datalab_api-0.5.1}/tests/test_client.py

@@ -58,3 +58,16 @@ def test_collection_get(fake_api_url, mocked_api):
 
         collection, children = client.get_collection("test_collection", display=True)
         assert mocked_api["collection-test_collection"].called
+
+
+@respx.mock
+def test_group_get(fake_api_url, mocked_api):
+    with DatalabClient("https://api.datalab.industries") as client:
+        assert mocked_api["api"].called
+        assert mocked_api["info"].called
+        assert mocked_api["info-blocks"].called
+
+        group = client.get_group("test_group", display=True)
+        assert mocked_api["search-groups"].called
+        assert group["immutable_id"] == "67d0b01e03000cdc75134dbd"
+        assert group["group_id"] == "test_group"