diff --git a/c-ext/compressionreader.c b/c-ext/compressionreader.c index b14a63b1..1aba444f 100644 --- a/c-ext/compressionreader.c +++ b/c-ext/compressionreader.c @@ -112,15 +112,22 @@ static PyObject *compressionreader_flush(PyObject *self) { } static PyObject *compressionreader_close(ZstdCompressionReader *self) { + int hasClose; + if (self->closed) { Py_RETURN_NONE; } self->closed = 1; - if (self->closefd && self->reader != NULL && - PyObject_HasAttrString(self->reader, "close")) { - return PyObject_CallMethod(self->reader, "close", NULL); + if (self->closefd && self->reader != NULL) { + hasClose = PyObject_HasAttrStringWithError(self->reader, "close"); + if (hasClose < 0) { + return NULL; + } + if (hasClose) { + return PyObject_CallMethod(self->reader, "close", NULL); + } } Py_RETURN_NONE; diff --git a/c-ext/compressionwriter.c b/c-ext/compressionwriter.c index c7490713..fef98a9e 100644 --- a/c-ext/compressionwriter.c +++ b/c-ext/compressionwriter.c @@ -132,6 +132,8 @@ static PyObject *ZstdCompressionWriter_flush(ZstdCompressionWriter *self, PyObject *args, PyObject *kwargs) { static char *kwlist[] = {"flush_mode", NULL}; + int hasFlush; + size_t zresult; ZSTD_inBuffer input; PyObject *res; @@ -197,18 +199,25 @@ static PyObject *ZstdCompressionWriter_flush(ZstdCompressionWriter *self, } } - if (!self->closing && PyObject_HasAttrString(self->writer, "flush")) { - res = PyObject_CallMethod(self->writer, "flush", NULL); - if (NULL == res) { + if (!self->closing) { + hasFlush = PyObject_HasAttrStringWithError(self->writer, "flush"); + if (hasFlush < 0) { return NULL; } - Py_XDECREF(res); + if (hasFlush) { + res = PyObject_CallMethod(self->writer, "flush", NULL); + if (NULL == res) { + return NULL; + } + Py_XDECREF(res); + } } return PyLong_FromSsize_t(totalWrite); } static PyObject *ZstdCompressionWriter_close(ZstdCompressionWriter *self) { + int hasClose; PyObject *result; if (self->closed) { @@ -225,8 +234,14 @@ static PyObject *ZstdCompressionWriter_close(ZstdCompressionWriter *self) { } /* Call close on underlying stream as well. */ - if (self->closefd && PyObject_HasAttrString(self->writer, "close")) { - return PyObject_CallMethod(self->writer, "close", NULL); + if (self->closefd) { + hasClose = PyObject_HasAttrStringWithError(self->writer, "close"); + if (hasClose < 0) { + return NULL; + } + if (hasClose) { + return PyObject_CallMethod(self->writer, "close", NULL); + } } Py_RETURN_NONE; diff --git a/c-ext/decompressionreader.c b/c-ext/decompressionreader.c index de01047d..d7519636 100644 --- a/c-ext/decompressionreader.c +++ b/c-ext/decompressionreader.c @@ -83,15 +83,22 @@ static PyObject *decompressionreader_seekable(PyObject *self) { } static PyObject *decompressionreader_close(ZstdDecompressionReader *self) { + int hasClose; + if (self->closed) { Py_RETURN_NONE; } self->closed = 1; - if (self->closefd && self->reader != NULL && - PyObject_HasAttrString(self->reader, "close")) { - return PyObject_CallMethod(self->reader, "close", NULL); + if (self->closefd && self->reader != NULL) { + hasClose = PyObject_HasAttrStringWithError(self->reader, "close"); + if (hasClose < 0) { + return NULL; + } + if (hasClose) { + return PyObject_CallMethod(self->reader, "close", NULL); + } } Py_RETURN_NONE; diff --git a/c-ext/decompressionwriter.c b/c-ext/decompressionwriter.c index 71a148be..8c28c026 100644 --- a/c-ext/decompressionwriter.c +++ b/c-ext/decompressionwriter.c @@ -124,6 +124,7 @@ static PyObject *ZstdDecompressionWriter_write(ZstdDecompressionWriter *self, } static PyObject *ZstdDecompressionWriter_close(ZstdDecompressionWriter *self) { + int hasClose; PyObject *result; if (self->closed) { @@ -140,8 +141,14 @@ static PyObject *ZstdDecompressionWriter_close(ZstdDecompressionWriter *self) { } /* Call close on underlying stream as well. */ - if (self->closefd && PyObject_HasAttrString(self->writer, "close")) { - return PyObject_CallMethod(self->writer, "close", NULL); + if (self->closefd) { + hasClose = PyObject_HasAttrStringWithError(self->writer, "close"); + if (hasClose < 0) { + return NULL; + } + if (hasClose) { + return PyObject_CallMethod(self->writer, "close", NULL); + } } Py_RETURN_NONE; @@ -159,17 +166,24 @@ static PyObject *ZstdDecompressionWriter_fileno(ZstdDecompressionWriter *self) { } static PyObject *ZstdDecompressionWriter_flush(ZstdDecompressionWriter *self) { + int hasFlush; + if (self->closed) { PyErr_SetString(PyExc_ValueError, "stream is closed"); return NULL; } - if (!self->closing && PyObject_HasAttrString(self->writer, "flush")) { - return PyObject_CallMethod(self->writer, "flush", NULL); - } - else { - Py_RETURN_NONE; + if (!self->closing) { + hasFlush = PyObject_HasAttrStringWithError(self->writer, "flush"); + if (hasFlush < 0) { + return NULL; + } + if (hasFlush) { + return PyObject_CallMethod(self->writer, "flush", NULL); + } } + + Py_RETURN_NONE; } static PyObject *ZstdDecompressionWriter_iter(PyObject *self) { diff --git a/tests/test_compressor_stream_reader.py b/tests/test_compressor_stream_reader.py index 6c1fca21..a04a8bc5 100644 --- a/tests/test_compressor_stream_reader.py +++ b/tests/test_compressor_stream_reader.py @@ -10,6 +10,39 @@ class TestCompressor_stream_reader(unittest.TestCase): + def test_close_attribute_lookup_error(self): + class Stream: + def read(self, size): + return b"" + + def write(self, data): + return len(data) + + def __getattr__(self, name): + if name == "close": + raise exception("close lookup failed") + raise AttributeError(name) + + for exception in (MemoryError, KeyboardInterrupt): + with self.subTest(exception=exception): + stream = zstd.ZstdCompressor().stream_reader(Stream()) + with self.assertRaisesRegex(exception, "close lookup failed"): + stream.close() + self.assertTrue(stream.closed) + stream.close() + + def test_close_attribute_absent(self): + class Stream: + def read(self, size): + return b"" + + def write(self, data): + return len(data) + + stream = zstd.ZstdCompressor().stream_reader(Stream()) + stream.close() + self.assertTrue(stream.closed) + def test_context_manager(self): cctx = zstd.ZstdCompressor() diff --git a/tests/test_compressor_stream_writer.py b/tests/test_compressor_stream_writer.py index 1f1855fc..070dbc2f 100644 --- a/tests/test_compressor_stream_writer.py +++ b/tests/test_compressor_stream_writer.py @@ -14,6 +14,65 @@ class TestCompressor_stream_writer(unittest.TestCase): + def test_close_attribute_lookup_error(self): + class Stream: + def read(self, size): + return b"" + + def write(self, data): + return len(data) + + def __getattr__(self, name): + if name == "close": + raise exception("close lookup failed") + raise AttributeError(name) + + for exception in (MemoryError, KeyboardInterrupt): + with self.subTest(exception=exception): + stream = zstd.ZstdCompressor().stream_writer(Stream()) + with self.assertRaisesRegex(exception, "close lookup failed"): + stream.close() + self.assertTrue(stream.closed) + stream.close() + + def test_close_attribute_absent(self): + class Stream: + def read(self, size): + return b"" + + def write(self, data): + return len(data) + + stream = zstd.ZstdCompressor().stream_writer(Stream()) + stream.close() + self.assertTrue(stream.closed) + + def test_flush_attribute_lookup_error(self): + class Stream: + def write(self, data): + return len(data) + + def __getattr__(self, name): + if name == "flush": + raise exception("flush lookup failed") + raise AttributeError(name) + + for exception in (MemoryError, KeyboardInterrupt): + with self.subTest(exception=exception): + stream = zstd.ZstdCompressor().stream_writer(Stream()) + with self.assertRaisesRegex(exception, "flush lookup failed"): + stream.flush() + self.assertFalse(stream.closed) + + def test_flush_attribute_absent(self): + class Stream: + def write(self, data): + return len(data) + + stream = zstd.ZstdCompressor().stream_writer(Stream()) + stream.flush() + self.assertFalse(stream.closed) + def test_io_api(self): buffer = io.BytesIO() cctx = zstd.ZstdCompressor() diff --git a/tests/test_decompressor_stream_reader.py b/tests/test_decompressor_stream_reader.py index c879b941..a2aa18e3 100644 --- a/tests/test_decompressor_stream_reader.py +++ b/tests/test_decompressor_stream_reader.py @@ -10,6 +10,39 @@ class TestDecompressor_stream_reader(unittest.TestCase): + def test_close_attribute_lookup_error(self): + class Stream: + def read(self, size): + return b"" + + def write(self, data): + return len(data) + + def __getattr__(self, name): + if name == "close": + raise exception("close lookup failed") + raise AttributeError(name) + + for exception in (MemoryError, KeyboardInterrupt): + with self.subTest(exception=exception): + stream = zstd.ZstdDecompressor().stream_reader(Stream()) + with self.assertRaisesRegex(exception, "close lookup failed"): + stream.close() + self.assertTrue(stream.closed) + stream.close() + + def test_close_attribute_absent(self): + class Stream: + def read(self, size): + return b"" + + def write(self, data): + return len(data) + + stream = zstd.ZstdDecompressor().stream_reader(Stream()) + stream.close() + self.assertTrue(stream.closed) + def test_context_manager(self): dctx = zstd.ZstdDecompressor() diff --git a/tests/test_decompressor_stream_writer.py b/tests/test_decompressor_stream_writer.py index e624a16e..5b19f0bc 100644 --- a/tests/test_decompressor_stream_writer.py +++ b/tests/test_decompressor_stream_writer.py @@ -22,6 +22,65 @@ def decompress_via_writer(data): class TestDecompressor_stream_writer(unittest.TestCase): + def test_close_attribute_lookup_error(self): + class Stream: + def read(self, size): + return b"" + + def write(self, data): + return len(data) + + def __getattr__(self, name): + if name == "close": + raise exception("close lookup failed") + raise AttributeError(name) + + for exception in (MemoryError, KeyboardInterrupt): + with self.subTest(exception=exception): + stream = zstd.ZstdDecompressor().stream_writer(Stream()) + with self.assertRaisesRegex(exception, "close lookup failed"): + stream.close() + self.assertTrue(stream.closed) + stream.close() + + def test_close_attribute_absent(self): + class Stream: + def read(self, size): + return b"" + + def write(self, data): + return len(data) + + stream = zstd.ZstdDecompressor().stream_writer(Stream()) + stream.close() + self.assertTrue(stream.closed) + + def test_flush_attribute_lookup_error(self): + class Stream: + def write(self, data): + return len(data) + + def __getattr__(self, name): + if name == "flush": + raise exception("flush lookup failed") + raise AttributeError(name) + + for exception in (MemoryError, KeyboardInterrupt): + with self.subTest(exception=exception): + stream = zstd.ZstdDecompressor().stream_writer(Stream()) + with self.assertRaisesRegex(exception, "flush lookup failed"): + stream.flush() + self.assertFalse(stream.closed) + + def test_flush_attribute_absent(self): + class Stream: + def write(self, data): + return len(data) + + stream = zstd.ZstdDecompressor().stream_writer(Stream()) + stream.flush() + self.assertFalse(stream.closed) + def test_io_api(self): buffer = io.BytesIO() dctx = zstd.ZstdDecompressor()