feat: add ignore_flush parameter to BlobWriter

google/cloud/storage/blob.py

@@ -3760,6 +3760,7 @@ def open(
  self,
  mode="r",
  chunk_size=None,
+ ignore_flush=None,
  encoding=None,
  errors=None,
  newline=None,
@@ -3801,6 +3802,19 @@ def open(
  chunk_size for writes must be exactly a multiple of 256KiB as with
  other resumable uploads. The default is 40 MiB.
 
+ :type ignore_flush: bool
+ :param ignore_flush:
+ (Optional) For non text-mode writes, makes flush() do nothing
+ instead of raising an error. flush() without closing is not
+ supported by the remote service and therefore calling it normally
+ results in io.UnsupportedOperation. However, that behavior is
+ incompatible with some consumers and wrappers of file objects in
+ Python, such as zipfile.ZipFile or io.TextIOWrapper. Setting
+ ignore_flush will cause flush() to successfully do nothing, for
+ compatibility with those contexts. The correct way to actually flush
+ data to the remote server is to close() (using a context manager,
+ such as in the example, will cause this to happen automatically).
+
  :type encoding: str
  :param encoding:
  (Optional) For text mode only, the name of the encoding that the stream will
@@ -3873,23 +3887,38 @@ def open(
  raise ValueError(
  "encoding, errors and newline arguments are for text mode only"
  )
+ if ignore_flush:
+ raise ValueError(
+ "ignore_flush argument is for non-text write mode only"
+ )
  return BlobReader(self, chunk_size=chunk_size, **kwargs)
  elif mode == "wb":
  if encoding or errors or newline:
  raise ValueError(
  "encoding, errors and newline arguments are for text mode only"
  )
- return BlobWriter(self, chunk_size=chunk_size, **kwargs)
+ return BlobWriter(
+ self, chunk_size=chunk_size, ignore_flush=ignore_flush, **kwargs
+ )
  elif mode in ("r", "rt"):
+ if ignore_flush:
+ raise ValueError(
+ "ignore_flush argument is for non-text write mode only"
+ )
  return TextIOWrapper(
  BlobReader(self, chunk_size=chunk_size, **kwargs),
  encoding=encoding,
  errors=errors,
  newline=newline,
  )
  elif mode in ("w", "wt"):
+ if ignore_flush is False:
+ raise ValueError(
+ "ignore_flush is required for text mode writing and "
+ "cannot be set to False"
+ )
  return TextIOWrapper(
- BlobWriter(self, chunk_size=chunk_size, text_mode=True, **kwargs),
+ BlobWriter(self, chunk_size=chunk_size, ignore_flush=True, **kwargs),
  encoding=encoding,
  errors=errors,
  newline=newline,

google/cloud/storage/fileio.py

@@ -229,11 +229,23 @@ class BlobWriter(io.BufferedIOBase):
  writes must be exactly a multiple of 256KiB as with other resumable
  uploads. The default is the chunk_size of the blob, or 40 MiB.
 
- :type text_mode: boolean
+ :type text_mode: bool
  :param text_mode:
- Whether this class is wrapped in 'io.TextIOWrapper'. Toggling this
- changes the behavior of flush() to conform to TextIOWrapper's
- expectations.
+ (Deprecated) A synonym for ignore_flush. For backwards-compatibility,
+ if True, sets ignore_flush to True. Use ignore_flush instead. This
+ parameter will be removed in a future release.
+
+ :type ignore_flush: bool
+ :param ignore_flush:
+ Makes flush() do nothing instead of raise an error. flush() without
+ closing is not supported by the remote service and therefore calling it
+ on this class normally results in io.UnsupportedOperation. However, that
+ behavior is incompatible with some consumers and wrappers of file
+ objects in Python, such as zipfile.ZipFile or io.TextIOWrapper. Setting
+ ignore_flush will cause flush() to successfully do nothing, for
+ compatibility with those contexts. The correct way to actually flush
+ data to the remote server is to close() (using this object as a context
+ manager is recommended).
 
  :type retry: google.api_core.retry.Retry or google.cloud.storage.retry.ConditionalRetryPolicy
  :param retry:
@@ -278,6 +290,7 @@ def __init__(
  blob,
  chunk_size=None,
  text_mode=False,
+ ignore_flush=False,
  retry=DEFAULT_RETRY_IF_GENERATION_SPECIFIED,
  **upload_kwargs
  ):
@@ -292,9 +305,8 @@ def __init__(
  # Resumable uploads require a chunk size of a multiple of 256KiB.
  # self._chunk_size must not be changed after the upload is initiated.
  self._chunk_size = chunk_size or blob.chunk_size or DEFAULT_CHUNK_SIZE
- # In text mode this class will be wrapped and TextIOWrapper requires a
- # different behavior of flush().
- self._text_mode = text_mode
+ # text_mode is a deprecated synonym for ignore_flush
+ self._ignore_flush = ignore_flush or text_mode
  self._retry = retry
  self._upload_kwargs = upload_kwargs
 
@@ -394,13 +406,14 @@ def tell(self):
  return self._buffer.tell() + len(self._buffer)
 
  def flush(self):
- if self._text_mode:
- # TextIOWrapper expects this method to succeed before calling close().
- return
-
- raise io.UnsupportedOperation(
- "Cannot flush without finalizing upload. Use close() instead."
- )
+ # flush() is not fully supported by the remote service, so raise an
+ # error here, unless self._ignore_flush is set.
+ if not self._ignore_flush:
+ raise io.UnsupportedOperation(
+ "Cannot flush without finalizing upload. Use close() instead, "
+ "or set ignore_flush=True when constructing this class (see "
+ "docstring)."
+ )
 
  def close(self):
  self._checkClosed() # Raises ValueError if closed.

tests/unit/test_blob.py

@@ -5585,13 +5585,21 @@ def test_open(self):
  self.assertEqual(type(f.buffer), BlobWriter)
  f = blob.open("wb")
  self.assertEqual(type(f), BlobWriter)
+ f = blob.open("wb", ignore_flush=True)
+ self.assertTrue(f._ignore_flush)
 
  with self.assertRaises(NotImplementedError):
  blob.open("a")
  with self.assertRaises(ValueError):
  blob.open("rb", encoding="utf-8")
  with self.assertRaises(ValueError):
  blob.open("wb", encoding="utf-8")
+ with self.assertRaises(ValueError):
+ blob.open("r", ignore_flush=True)
+ with self.assertRaises(ValueError):
+ blob.open("rb", ignore_flush=True)
+ with self.assertRaises(ValueError):
+ blob.open("w", ignore_flush=False)
 
 
 class Test__quote(unittest.TestCase):

tests/unit/test_fileio.py

@@ -272,6 +272,13 @@ def test_attributes_explicit(self):
  self.assertEqual(writer._chunk_size, 512 * 1024)
  self.assertEqual(writer._retry, DEFAULT_RETRY)
 
+ def test_deprecated_text_mode_attribute(self):
+ blob = mock.Mock()
+ blob.chunk_size = 256 * 1024
+ writer = self._make_blob_writer(blob, text_mode=True)
+ self.assertTrue(writer._ignore_flush)
+ writer.flush() # This should do nothing and not raise an error.
+
  def test_reject_wrong_chunk_size(self):
  blob = mock.Mock()
  blob.chunk_size = 123
@@ -857,7 +864,7 @@ def test_write(self, mock_warn):
  unwrapped_writer = self._make_blob_writer(
  blob,
  chunk_size=chunk_size,
-text_mode=True,
+ignore_flush=True,
  num_retries=NUM_RETRIES,
  content_type=PLAIN_CONTENT_TYPE,
  )