make test pass

Author: bisgaard-itis

clients/python/src/osparc/_api_files_api.py

@@ -4,9 +4,6 @@
 import json
 import logging
 import math
-import random
-import shutil
-import string
 from pathlib import Path
 from typing import Any, Iterator, List, Optional, Tuple, Union
 
@@ -28,6 +25,8 @@
     FileUploadData,
     UploadedPart,
 )
+from tempfile import NamedTemporaryFile
+from urllib.parse import urljoin
 from ._utils import (
     DEFAULT_TIMEOUT_SECONDS,
     PaginationGenerator,
@@ -65,24 +64,48 @@ def __getattr__(self, name: str) -> Any:
         return super().__getattribute__(name)
 
     def download_file(
-        self, file_id: str, *, destination_folder: Optional[Path] = None, **kwargs
+        self,
+        file_id: str,
+        *,
+        destination_folder: Optional[Path] = None,
+        timeout_seconds: int = DEFAULT_TIMEOUT_SECONDS,
+        **kwargs,
+    ) -> str:
+        return asyncio.run(
+            self.download_file_async(
+                file_id=file_id,
+                destination_folder=destination_folder,
+                timeout_seconds=timeout_seconds,
+                **kwargs,
+            )
+        )
+
+    async def download_file_async(
+        self,
+        file_id: str,
+        *,
+        destination_folder: Optional[Path] = None,
+        timeout_seconds: int = DEFAULT_TIMEOUT_SECONDS,
+        **kwargs,
     ) -> str:
         if destination_folder is not None and not destination_folder.is_dir():
             raise RuntimeError(
                 f"destination_folder: {destination_folder} must be a directory"
             )
-        downloaded_file: Path = Path(super().download_file(file_id, **kwargs))
-        if destination_folder is not None:
-            dest_file: Path = destination_folder / downloaded_file.name
-            while dest_file.is_file():
-                new_name = (
-                    downloaded_file.stem
-                    + "".join(random.choices(string.ascii_letters, k=8))
-                    + downloaded_file.suffix
-                )
-                dest_file = destination_folder / new_name
-            shutil.move(downloaded_file, dest_file)
-            downloaded_file = dest_file
+        downloaded_file = Path(
+            NamedTemporaryFile(dir=destination_folder, delete=False).name
+        )
+        async with AsyncHttpClient(
+            configuration=self.api_client.configuration, timeout=timeout_seconds
+        ) as session:
+            url = urljoin(
+                self.api_client.configuration.host, f"/v0/files/{file_id}/content"
+            )
+            with open(downloaded_file, mode="wb") as f:
+                async for chunk in session.stream(
+                    "GET", url=url, auth=self._auth, follow_redirects=True
+                ):
+                    f.write(chunk)
         return str(downloaded_file.resolve())
 
     def upload_file(
@@ -159,7 +182,7 @@ async def upload_file_async(
             )
             async with AsyncHttpClient(
                 configuration=self.api_client.configuration,
-                request_type="post",
+                method="post",
                 url=links.abort_upload,
                 body=abort_body.to_dict(),
                 base_url=self.api_client.configuration.host,

clients/python/src/osparc/_http_client.py

@@ -1,7 +1,16 @@
 from contextlib import suppress
 from datetime import datetime
 from email.utils import parsedate_to_datetime
-from typing import Any, Awaitable, Callable, Dict, Optional, Set
+from typing import (
+    Any,
+    Awaitable,
+    Callable,
+    Dict,
+    Optional,
+    Set,
+    Literal,
+    AsyncGenerator,
+)
 
 import httpx
 import tenacity
@@ -17,14 +26,14 @@ def __init__(
         self,
         *,
         configuration: Configuration,
-        request_type: Optional[str] = None,
+        method: Optional[str] = None,
         url: Optional[str] = None,
         body: Optional[Dict] = None,
         **httpx_async_client_kwargs,
     ):
         self.configuration = configuration
         self._client = httpx.AsyncClient(**httpx_async_client_kwargs)
-        self._callback = getattr(self._client, request_type) if request_type else None
+        self._callback = getattr(self._client, method) if method else None
         self._url = url
         self._body = body
         if self._callback is not None:
@@ -77,6 +86,30 @@ async def _():
 
         return await _()
 
+    async def _stream(
+        self, method: Literal["GET"], url: str, *args, **kwargs
+    ) -> AsyncGenerator[bytes, None]:
+        n_attempts = self.configuration.retries.total
+        assert isinstance(n_attempts, int)
+
+        @tenacity.retry(
+            reraise=True,
+            wait=self._wait_callback,
+            stop=tenacity.stop_after_attempt(n_attempts),
+            retry=tenacity.retry_if_exception_type(httpx.HTTPStatusError),
+        )
+        async def _() -> AsyncGenerator[bytes, None]:
+            async with self._client.stream(
+                method=method, url=url, *args, **kwargs
+            ) as response:
+                if response.status_code in self.configuration.retries.status_forcelist:
+                    response.raise_for_status()
+                async for chunk in response.aiter_bytes():
+                    yield chunk
+
+        async for chunk in _():
+            yield chunk
+
     async def put(self, *args, **kwargs) -> httpx.Response:
         return await self._request(self._client.put, *args, **kwargs)
 
@@ -92,6 +125,12 @@ async def patch(self, *args, **kwargs) -> httpx.Response:
     async def get(self, *args, **kwargs) -> httpx.Response:
         return await self._request(self._client.get, *args, **kwargs)
 
+    async def stream(
+        self, method: Literal["GET"], url: str, *args, **kwargs
+    ) -> AsyncGenerator[bytes, None]:
+        async for chunk in self._stream(method=method, url=url, *args, **kwargs):
+            yield chunk
+
     def _wait_callback(self, retry_state: tenacity.RetryCallState) -> int:
         assert retry_state.outcome is not None
         if retry_state.outcome and retry_state.outcome.exception():