codeocean 0.1.6__tar.gz → 0.2.0__tar.gz

{codeocean-0.1.6 → codeocean-0.2.0}/CHANGELOG.md

@@ -1,6 +1,14 @@
 CHANGELOG
 =========
 
+## 0.2.0 (2024-10-21)
+
+- [#15](https://github.com/codeocean/codeocean-sdk-python/pull/15) feat: Add option for custom retries
+
+## 0.1.7 (2024-10-17)
+
+- [#14](https://github.com/codeocean/codeocean-sdk-python/pull/14) feat: Add an optional timeout parameter to polling while loops
+
 ## 0.1.6 (2024-10-15)
 
 - [#13](https://github.com/codeocean/codeocean-sdk-python/pull/13) feat: makes polling interval configurable

{codeocean-0.1.6 → codeocean-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: codeocean
-Version: 0.1.6
+Version: 0.2.0
 Summary: Code Ocean Python SDK
 Project-URL: Homepage, https://github.com/codeocean/codeocean-sdk-python
 Project-URL: Issues, https://github.com/codeocean/codeocean-sdk-python/issues

{codeocean-0.1.6 → codeocean-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "codeocean"
-version = "0.1.6"
+version = "0.2.0"
 authors = [
   { name="Code Ocean", email="dev@codeocean.com" },
 ]

{codeocean-0.1.6 → codeocean-0.2.0}/src/codeocean/client.py

@@ -1,6 +1,8 @@
-from requests_toolbelt.sessions import BaseUrlSession
-from requests_toolbelt.adapters.socket_options import TCPKeepAliveAdapter
 from dataclasses import dataclass
+from requests_toolbelt.adapters.socket_options import TCPKeepAliveAdapter
+from requests_toolbelt.sessions import BaseUrlSession
+from typing import Optional
+from urllib3.util import Retry
 
 from codeocean.capsule import Capsules
 from codeocean.computation import Computations
@@ -12,15 +14,16 @@ class CodeOcean:
 
     domain: str
     token: str
+    retries: Optional[Retry] = None
 
     def __post_init__(self):
         self.session = BaseUrlSession(base_url=f"{self.domain}/api/v1/")
         self.session.auth = (self.token, "")
-        self.session.mount(self.domain, TCPKeepAliveAdapter())
         self.session.headers.update({"Content-Type": "application/json"})
         self.session.hooks["response"] = [
             lambda response, *args, **kwargs: response.raise_for_status()
         ]
+        self.session.mount(self.domain, TCPKeepAliveAdapter(max_retries=self.retries))
 
         self.capsules = Capsules(client=self.session)
         self.computations = Computations(client=self.session)

{codeocean-0.1.6 → codeocean-0.2.0}/src/codeocean/computation.py

@@ -4,7 +4,7 @@ from dataclasses import dataclass
 from dataclasses_json import dataclass_json
 from requests_toolbelt.sessions import BaseUrlSession
 from typing import Optional
-from time import sleep
+from time import sleep, time
 
 from codeocean.enum import StrEnum
 
@@ -141,20 +141,39 @@ class Computations:
 
         return Computation.from_dict(res.json())
 
-    def wait_until_completed(self, computation: Computation, polling_interval: int = 5) -> Computation:
+    def wait_until_completed(
+        self,
+        computation: Computation,
+        polling_interval: float = 5,
+        timeout: Optional[float] = None,
+    ) -> Computation:
         """
         Polls the given computation until it reaches the 'Completed' or 'Failed' state.
+
+        - `polling_interval` and `timeout` are in seconds
         """
         if polling_interval < 5:
             raise ValueError(
                 f"Polling interval {polling_interval} should be greater than or equal to 5"
             )
+        if timeout is not None and timeout < polling_interval:
+            raise ValueError(
+                f"Timeout {timeout} should be greater than or equal to polling interval {polling_interval}"
+            )
+        if timeout is not None and timeout < 0:
+            raise ValueError(
+                f"Timeout {timeout} should be greater than or equal to 0 (seconds), or None"
+            )
+        t0 = time()
         while True:
             comp = self.get_computation(computation.id)
 
             if comp.state in [ComputationState.Completed, ComputationState.Failed]:
                 return comp
 
+            if timeout is not None and (time() - t0) > timeout:
+                raise TimeoutError(f"Computation {computation.id} did not complete within {timeout} seconds")
+
             sleep(polling_interval)
 
     def list_computation_results(self, computation_id: str, path: str = "") -> Folder:

{codeocean-0.1.6 → codeocean-0.2.0}/src/codeocean/data_asset.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from dataclasses_json import dataclass_json
 from dataclasses import dataclass
 from requests_toolbelt.sessions import BaseUrlSession
-from time import sleep
+from time import sleep, time
 from typing import Optional
 
 from codeocean.components import SortOrder, SearchFilter, Permissions
@@ -237,20 +237,39 @@ class DataAssets:
 
         return DataAsset.from_dict(res.json())
 
-    def wait_until_ready(self, data_asset: DataAsset, polling_interval: int = 5) -> DataAsset:
+    def wait_until_ready(
+        self,
+        data_asset: DataAsset,
+        polling_interval: float = 5,
+        timeout: float | None = None,
+    ) -> DataAsset:
         """
         Polls the given data asset until it reaches the 'Ready' or 'Failed' state.
+
+        - `polling_interval` and `timeout` are in seconds
         """
         if polling_interval < 5:
             raise ValueError(
                 f"Polling interval {polling_interval} should be greater than or equal to 5"
             )
+        if timeout is not None and timeout < polling_interval:
+            raise ValueError(
+                f"Timeout {timeout} should be greater than or equal to polling interval {polling_interval}"
+            )
+        if timeout is not None and timeout < 0:
+            raise ValueError(
+                f"Timeout {timeout} should be greater than or equal to 0 (seconds), or None"
+            )
+        t0 = time()
         while True:
             da = self.get_data_asset(data_asset.id)
 
             if da.state in [DataAssetState.Ready, DataAssetState.Failed]:
                 return da
 
+            if timeout is not None and (time() - t0) > timeout:
+                raise TimeoutError(f"Data asset {data_asset.id} was not ready within {timeout} seconds")
+
             sleep(polling_interval)
 
     def delete_data_asset(self, data_asset_id: str):