Merge branch 'main' into aravind-segu/NotebookOAuth

Author: renaudhartert-db

.codegen/_openapi_sha

@@ -1 +1 @@
-b54bbd860200d735fa2c306ec1559090625370e6
+27cebd58ae24e19c95c675db3a93b6046abaca2a

.gitattributes

@@ -33,5 +33,6 @@ databricks/sdk/service/tags.py linguist-generated=true
 databricks/sdk/service/vectorsearch.py linguist-generated=true
 databricks/sdk/service/workspace.py linguist-generated=true
 test_http_call.py linguist-generated=true
+test_idempotency.py linguist-generated=true
 test_json_marshall.py linguist-generated=true
 test_lro_call.py linguist-generated=true

.release_metadata.json

@@ -1,3 +1,3 @@
 {
-    "timestamp": "2025-10-23 13:43:03+0000"
+    "timestamp": "2025-11-05 06:52:11+0000"
 }

CHANGELOG.md

@@ -1,9 +1,11 @@
 # NEXT CHANGELOG
 
-## Release v0.71.0
+## Release v0.74.0
 
 ### New Features and Improvements
 
+### Security
+
 ### Bug Fixes
 
 ### Documentation

NEXT_CHANGELOG.md

@@ -12,6 +12,6 @@ def __init__(self, *, timeout: Optional[timedelta] = None):
         """
         Args:
             timeout: The timeout for the Long Running Operations.
-                    If not set, the default timeout is 20 minutes.
+                if not set, then operation will wait forever.
         """
-        self.timeout = timeout or timedelta(minutes=20)
+        self.timeout = timeout

databricks/sdk/__init__.py

@@ -33,7 +33,7 @@
 from .._base_client import _BaseClient, _RawResponse, _StreamingResponse
 from .._property import _cached_property
 from ..config import Config
-from ..errors import AlreadyExists, NotFound, PermissionDenied
+from ..errors import AlreadyExists, InternalError, NotFound, PermissionDenied
 from ..errors.mapper import _error_mapper
 from ..retries import retried
 from ..service import files
@@ -1064,7 +1064,7 @@ def _get_optimized_performance_parameters_for_upload(
     def upload(
         self,
         file_path: str,
-        content: BinaryIO,
+        contents: BinaryIO,
         *,
         overwrite: Optional[bool] = None,
         part_size: Optional[int] = None,
@@ -1076,7 +1076,7 @@ def upload(
 
         :param file_path: str
             The absolute remote path of the target file, e.g. /Volumes/path/to/your/file
-        :param content: BinaryIO
+        :param contents: BinaryIO
             The contents of the file to upload. This must be a BinaryIO stream.
         :param overwrite: bool (optional)
             If true, an existing file will be overwritten. When not specified, assumed True.
@@ -1096,7 +1096,7 @@ def upload(
 
         if self._config.disable_experimental_files_api_client:
             _LOG.info("Disable experimental files API client, will use the original upload method.")
-            super().upload(file_path=file_path, contents=content, overwrite=overwrite)
+            super().upload(file_path=file_path, contents=contents, overwrite=overwrite)
             return UploadStreamResult()
 
         _LOG.debug(f"Uploading file from BinaryIO stream")
@@ -1107,12 +1107,12 @@ def upload(
 
         # Determine content length if the stream is seekable
         content_length = None
-        if content.seekable():
+        if contents.seekable():
             _LOG.debug(f"Uploading using seekable mode")
             # If the stream is seekable, we can read its size.
-            content.seek(0, os.SEEK_END)
-            content_length = content.tell()
-            content.seek(0)
+            contents.seek(0, os.SEEK_END)
+            content_length = contents.tell()
+            contents.seek(0)
 
         # Get optimized part size and batch size based on content length and provided part size
         optimized_part_size, optimized_batch_size = self._get_optimized_performance_parameters_for_upload(
@@ -1134,18 +1134,20 @@ def upload(
             f"Upload context: part_size={ctx.part_size}, batch_size={ctx.batch_size}, content_length={ctx.content_length}"
         )
 
-        if ctx.use_parallel:
-            self._parallel_upload_from_stream(ctx, content)
+        if ctx.use_parallel and (
+            ctx.content_length is None or ctx.content_length >= self._config.files_ext_multipart_upload_min_stream_size
+        ):
+            self._parallel_upload_from_stream(ctx, contents)
             return UploadStreamResult()
         elif ctx.content_length is not None:
-            self._upload_single_thread_with_known_size(ctx, content)
+            self._upload_single_thread_with_known_size(ctx, contents)
             return UploadStreamResult()
         else:
             _LOG.debug(f"Uploading using non-seekable mode")
             # If the stream is not seekable, we cannot determine its size.
             # We will use a multipart upload.
             _LOG.debug(f"Using multipart upload for non-seekable input stream of unknown size for file {file_path}")
-            self._single_thread_multipart_upload(ctx, content)
+            self._single_thread_multipart_upload(ctx, contents)
             return UploadStreamResult()
 
     def upload_from(
@@ -1206,7 +1208,7 @@ def upload_from(
             use_parallel=use_parallel,
             parallelism=parallelism,
         )
-        if ctx.use_parallel:
+        if ctx.use_parallel and ctx.content_length >= self._config.files_ext_multipart_upload_min_stream_size:
             self._parallel_upload_from_file(ctx)
             return UploadFileResult()
         else:
@@ -1459,8 +1461,9 @@ def _parallel_multipart_upload_from_stream(
         # Do the first part read ahead
         pre_read_buffer = content.read(ctx.part_size)
         if not pre_read_buffer:
-            self._complete_multipart_upload(ctx, {}, session_token)
-            return
+            raise FallbackToUploadUsingFilesApi(
+                b"", "Falling back to single-shot upload with Files API due to empty input stream"
+            )
         try:
             etag = self._do_upload_one_part(
                 ctx, cloud_provider_session, 1, 0, len(pre_read_buffer), session_token, BytesIO(pre_read_buffer)
@@ -1650,6 +1653,13 @@ def _do_upload_one_part(
                     raise FallbackToUploadUsingFilesApi(None, "Presigned URLs are disabled")
                 else:
                     raise e from None
+            except InternalError as e:
+                if self._is_presigned_urls_network_zone_error(e):
+                    raise FallbackToUploadUsingFilesApi(
+                        None, "Presigned URLs are not supported in the current network zone"
+                    )
+                else:
+                    raise e from None
 
             upload_part_urls = upload_part_urls_response.get("upload_part_urls", [])
             if len(upload_part_urls) == 0:
@@ -1760,6 +1770,13 @@ def _perform_multipart_upload(
                     raise FallbackToUploadUsingFilesApi(buffer, "Presigned URLs are disabled")
                 else:
                     raise e from None
+            except InternalError as e:
+                if chunk_offset == 0 and self._is_presigned_urls_network_zone_error(e):
+                    raise FallbackToUploadUsingFilesApi(
+                        buffer, "Presigned URLs are not supported in the current network zone"
+                    )
+                else:
+                    raise e from None
 
             upload_part_urls = upload_part_urls_response.get("upload_part_urls", [])
             if len(upload_part_urls) == 0:
@@ -1917,6 +1934,13 @@ def _is_presigned_urls_disabled_error(self, e: PermissionDenied) -> bool:
                 return True
         return False
 
+    def _is_presigned_urls_network_zone_error(self, e: InternalError) -> bool:
+        error_infos = e.get_error_info()
+        for error_info in error_infos:
+            if error_info.reason == "FILES_API_REQUESTER_NETWORK_ZONE_UNKNOWN":
+                return True
+        return False
+
     def _perform_resumable_upload(
         self,
         ctx: _UploadContext,
@@ -1966,6 +1990,13 @@ def _perform_resumable_upload(
                 raise FallbackToUploadUsingFilesApi(pre_read_buffer, "Presigned URLs are disabled")
             else:
                 raise e from None
+        except InternalError as e:
+            if self._is_presigned_urls_network_zone_error(e):
+                raise FallbackToUploadUsingFilesApi(
+                    pre_read_buffer, "Presigned URLs are not supported in the current network zone"
+                )
+            else:
+                raise e from None
 
         resumable_upload_url_node = resumable_upload_url_response.get("resumable_upload_url")
         if not resumable_upload_url_node:
@@ -2350,6 +2381,11 @@ def _create_download_url(self, file_path: str) -> CreateDownloadUrlResponse:
                 raise FallbackToDownloadUsingFilesApi(f"Presigned URLs are disabled")
             else:
                 raise e from None
+        except InternalError as e:
+            if self._is_presigned_urls_network_zone_error(e):
+                raise FallbackToDownloadUsingFilesApi("Presigned URLs are not supported in the current network zone")
+            else:
+                raise e from None
 
     def _init_download_response_presigned_api(self, file_path: str, added_headers: dict[str, str]) -> DownloadResponse:
         """

databricks/sdk/common/lro.py

@@ -103,7 +103,7 @@ def _backoff(attempt: int) -> float:
 
 def poll(
     fn: Callable[[], Tuple[Optional[T], Optional[RetryError]]],
-    timeout: timedelta = timedelta(minutes=20),
+    timeout: Optional[timedelta] = None,
     clock: Optional[Clock] = None,
 ) -> T:
     """Poll a function until it succeeds or times out.
@@ -118,7 +118,7 @@ def poll(
                Return (None, RetryError.continues("msg")) to continue polling.
                Return (None, RetryError.halt(err)) to stop with error.
                Return (result, None) on success.
-    :param timeout: Maximum time to poll (default: 20 minutes)
+    :param timeout: Maximum time to poll. If None, polls indefinitely.
     :param clock: Clock implementation for testing (default: RealClock)
     :returns: The result of the successful function call
     :raises TimeoutError: If the timeout is reached
@@ -138,7 +138,7 @@ def check_operation():
     if clock is None:
         clock = RealClock()
 
-    deadline = clock.time() + timeout.total_seconds()
+    deadline = float("inf") if timeout is None else clock.time() + timeout.total_seconds()
     attempt = 0
     last_err = None