Intermediate changes

commit_hash:a0c75506f0d1cf5a6805d32237dc5b93c517de28

19 files changed, 133 insertions, 56 deletions

diff --git a/contrib/python/lz4/py3/.dist-info/METADATA b/contrib/python/lz4/py3/.dist-info/METADATA
index a57e6022a3f..ffde6ce8e50 100644
--- a/contrib/python/lz4/py3/.dist-info/METADATA
+++ b/contrib/python/lz4/py3/.dist-info/METADATA
@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lz4
-Version: 4.4.4
+Version: 4.4.5
 Summary: LZ4 Bindings for Python
 Home-page: https://github.com/python-lz4/python-lz4
 Author: Jonathan Underwood
diff --git a/contrib/python/lz4/py3/lz4/_version.c b/contrib/python/lz4/py3/lz4/_version.c
index c611f0b361d..af606abee19 100644
--- a/contrib/python/lz4/py3/lz4/_version.c
+++ b/contrib/python/lz4/py3/lz4/_version.c
@@ -113,5 +113,9 @@ PyInit__version(void)
   if (module == NULL)
     return NULL;
 
+  #ifdef Py_GIL_DISABLED
+    PyUnstable_Module_SetGIL(module, Py_MOD_GIL_NOT_USED);
+  #endif
+
   return module;
 }
diff --git a/contrib/python/lz4/py3/lz4/block/_block.c b/contrib/python/lz4/py3/lz4/block/_block.c
index 3e904a03441..993cc44c010 100644
--- a/contrib/python/lz4/py3/lz4/block/_block.c
+++ b/contrib/python/lz4/py3/lz4/block/_block.c
@@ -518,5 +518,9 @@ PyInit__block(void)
   Py_INCREF(LZ4BlockError);
   PyModule_AddObject(module, "LZ4BlockError", LZ4BlockError);
 
+  #ifdef Py_GIL_DISABLED
+    PyUnstable_Module_SetGIL(module, Py_MOD_GIL_NOT_USED);
+  #endif
+
   return module;
 }
diff --git a/contrib/python/lz4/py3/lz4/frame/__init__.py b/contrib/python/lz4/py3/lz4/frame/__init__.py
index 00f3e64adf3..2a82cd08226 100644
--- a/contrib/python/lz4/py3/lz4/frame/__init__.py
+++ b/contrib/python/lz4/py3/lz4/frame/__init__.py
@@ -25,9 +25,9 @@ from ._frame import (  # noqa: F401
 __doc__ = _doc
 
 try:
-    import _compression   # Python 3.6 and later
+    import compression._common._streams as _compression  # Python 3.14
 except ImportError:
-    from . import _compression
+    import _compression   # Python 3.9 - 3.13
 
 
 BLOCKSIZE_DEFAULT = _BLOCKSIZE_DEFAULT
@@ -268,7 +268,7 @@ class LZ4FrameCompressor(object):
         This returns a ``bytes`` or ``bytearray`` object containing any data
         stored in the compressor's internal buffers and a frame footer.
 
-        The LZ4FrameCompressor instance may be re-used after this method has
+        The LZ4FrameCompressor instance may be reused after this method has
         been called to create a new frame of compressed data.
 
         Returns:
@@ -287,7 +287,7 @@ class LZ4FrameCompressor(object):
     def reset(self):
         """Reset the `LZ4FrameCompressor` instance.
 
-        This allows the `LZ4FrameCompression` instance to be re-used after an
+        This allows the `LZ4FrameCompression` instance to be reused after an
         error.
 
         """
@@ -360,7 +360,7 @@ class LZ4FrameDecompressor(object):
     def reset(self):
         """Reset the decompressor state.
 
-        This is useful after an error occurs, allowing re-use of the instance.
+        This is useful after an error occurs, allowing reuse of the instance.
 
         """
         reset_decompression_context(self._context)
diff --git a/contrib/python/lz4/py3/lz4/frame/_frame.c b/contrib/python/lz4/py3/lz4/frame/_frame.c
index 34606653b0e..440b0b50593 100644
--- a/contrib/python/lz4/py3/lz4/frame/_frame.c
+++ b/contrib/python/lz4/py3/lz4/frame/_frame.c
@@ -1330,7 +1330,7 @@ PyDoc_STRVAR(
  );
 
 #define COMPRESS_KWARGS_DOCSTRING                                       \
-  "    block_size (int): Sepcifies the maximum blocksize to use.\n"     \
+  "    block_size (int): Specifies the maximum blocksize to use.\n"     \
   "        Options:\n\n"                                                \
   "        - `lz4.frame.BLOCKSIZE_DEFAULT`: the lz4 library default\n" \
   "        - `lz4.frame.BLOCKSIZE_MAX64KB`: 64 kB\n"             \
@@ -1466,7 +1466,7 @@ PyDoc_STRVAR
  "data will also be included in the returned data.\n"                   \
  "\n"                                                                   \
  "If the ``end_frame`` argument is ``True``, the compression context will be\n" \
- "reset and can be re-used.\n"                                          \
+ "reset and can be reused.\n"                                          \
  "\n"                                                                   \
  "Args:\n"                                                              \
  "    context (cCtx): Compression context\n"                            \
@@ -1677,5 +1677,9 @@ PyInit__frame(void)
   PyModule_AddIntConstant (module, "BLOCKSIZE_MAX1MB", LZ4F_max1MB);
   PyModule_AddIntConstant (module, "BLOCKSIZE_MAX4MB", LZ4F_max4MB);
 
+  #ifdef Py_GIL_DISABLED
+    PyUnstable_Module_SetGIL(module, Py_MOD_GIL_NOT_USED);
+  #endif
+
   return module;
 }
diff --git a/contrib/python/lz4/py3/lz4/stream/__init__.py b/contrib/python/lz4/py3/lz4/stream/__init__.py
index 4b0074648dc..58ce298ade5 100644
--- a/contrib/python/lz4/py3/lz4/stream/__init__.py
+++ b/contrib/python/lz4/py3/lz4/stream/__init__.py
@@ -32,7 +32,7 @@ class LZ4StreamDecompressor:
                     perform decompression using this initial dictionary.
 
             Raises:
-                Exceptions occuring during the context initialization.
+                Exceptions occurring during the context initialization.
 
                 OverflowError: raised if the ``dictionary`` parameter is too large
                     for the LZ4 context.
@@ -73,7 +73,7 @@ class LZ4StreamDecompressor:
                 bytes or bytearray: Decompressed data.
 
             Raises:
-                Exceptions occuring during decompression.
+                Exceptions occurring during decompression.
 
                 ValueError: raised if the source is inconsistent with a finite LZ4
                     stream block chain.
@@ -96,7 +96,7 @@ class LZ4StreamDecompressor:
                 bytes or bytearray: LZ4 compressed data block.
 
             Raises:
-                Exceptions occuring while getting the first block from ``stream``.
+                Exceptions occurring while getting the first block from ``stream``.
 
                 BufferError: raised if the function cannot return a complete LZ4
                     compressed block from the stream (i.e. the stream does not hold
@@ -150,7 +150,7 @@ class LZ4StreamCompressor:
                     perform compression using this initial dictionary.
 
             Raises:
-                Exceptions occuring during the context initialization.
+                Exceptions occurring during the context initialization.
 
                 OverflowError: raised if the ``dictionary`` parameter is too large
                     for the LZ4 context.
@@ -194,7 +194,7 @@ class LZ4StreamCompressor:
                 bytes or bytearray: Compressed data.
 
             Raises:
-                Exceptions occuring during compression.
+                Exceptions occurring during compression.
 
                 OverflowError: raised if the source is too large for being compressed in
                     the given context.
diff --git a/contrib/python/lz4/py3/lz4/stream/_stream.c b/contrib/python/lz4/py3/lz4/stream/_stream.c
index 522fdedacde..4c51d89dae5 100644
--- a/contrib/python/lz4/py3/lz4/stream/_stream.c
+++ b/contrib/python/lz4/py3/lz4/stream/_stream.c
@@ -931,7 +931,7 @@ _create_context (PyObject * Py_UNUSED (self), PyObject * args, PyObject * kwds)
       context->output.len = buffer_size;
       total_size = context->output.len;
 
-      /* Here we cannot assert the maximal theorical decompressed chunk length
+      /* Here we cannot assert the maximal theoretical decompressed chunk length
        * will fit in one page of the double_buffer, i.e.:
        *    assert( !(double_buffer.page_size < _LZ4_inputBound(store_max_size)) )
        *
@@ -1649,5 +1649,9 @@ PyInit__stream(void)
   Py_INCREF (LZ4StreamError);
   PyModule_AddObject (module, "LZ4StreamError", LZ4StreamError);
 
+  #ifdef Py_GIL_DISABLED
+    PyUnstable_Module_SetGIL(module, Py_MOD_GIL_NOT_USED);
+  #endif
+
   return module;
 }
diff --git a/contrib/python/lz4/py3/lz4/version.py b/contrib/python/lz4/py3/lz4/version.py
index 2808f61053d..ee639d55b29 100644
--- a/contrib/python/lz4/py3/lz4/version.py
+++ b/contrib/python/lz4/py3/lz4/version.py
@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '4.4.4'
-__version_tuple__ = version_tuple = (4, 4, 4)
+__version__ = version = '4.4.5'
+__version_tuple__ = version_tuple = (4, 4, 5)
+
+__commit_id__ = commit_id = 'g59b2d8176'
diff --git a/contrib/python/lz4/py3/tests/block/test_block_0.py b/contrib/python/lz4/py3/tests/block/test_block_0.py
index 8fc0f488877..a7731c3a0bc 100644
--- a/contrib/python/lz4/py3/tests/block/test_block_0.py
+++ b/contrib/python/lz4/py3/tests/block/test_block_0.py
@@ -1,6 +1,8 @@
 import lz4.block
 from multiprocessing.pool import ThreadPool
 import sys
+import copy
+import pytest
 from functools import partial
 if sys.version_info <= (3, 2):
     import struct
@@ -68,6 +70,13 @@ def setup_kwargs(mode, store_size, c_return_bytearray=None, d_return_bytearray=N
 
 # Test single threaded usage with all valid variations of input
 def test_1(data, mode, store_size, c_return_bytearray, d_return_bytearray, dictionary):
+    if isinstance(data, memoryview):
+        data = memoryview(copy.deepcopy(data.obj))
+    elif isinstance(data, bytearray):
+        data_x = bytearray()
+        data_x[:] = data
+        data = data_x
+
     (c_kwargs, d_kwargs) = setup_kwargs(
         mode, store_size, c_return_bytearray, d_return_bytearray)
 
@@ -79,10 +88,21 @@ def test_1(data, mode, store_size, c_return_bytearray, d_return_bytearray, dicti
 
 
 # Test multi threaded usage with all valid variations of input
[email protected]_unsafe
 def test_2(data, mode, store_size, dictionary):
     (c_kwargs, d_kwargs) = setup_kwargs(mode, store_size)
 
-    data_in = [data for i in range(32)]
+    def copy_buf(data):
+        if isinstance(data, memoryview):
+            data_x = memoryview(copy.deepcopy(data.obj))
+        elif isinstance(data, bytearray):
+            data_x = bytearray()
+            data_x[:] = data
+        else:
+            data_x = data
+        return data_x
+
+    data_in = [copy_buf(data) for i in range(32)]
 
     pool = ThreadPool(2)
     rt = partial(roundtrip, c_kwargs=c_kwargs,
diff --git a/contrib/python/lz4/py3/tests/block/test_block_3.py b/contrib/python/lz4/py3/tests/block/test_block_3.py
index 3fcb175b3b5..88461b7a231 100644
--- a/contrib/python/lz4/py3/tests/block/test_block_3.py
+++ b/contrib/python/lz4/py3/tests/block/test_block_3.py
@@ -18,6 +18,7 @@ def data(request):
     return request.param
 
 
[email protected]_unsafe
 def test_block_decompress_mem_usage(data):
     tracemalloc = pytest.importorskip('tracemalloc')
 
diff --git a/contrib/python/lz4/py3/tests/frame/test_frame_2.py b/contrib/python/lz4/py3/tests/frame/test_frame_2.py
index 80b44b87ff5..230867e6545 100644
--- a/contrib/python/lz4/py3/tests/frame/test_frame_2.py
+++ b/contrib/python/lz4/py3/tests/frame/test_frame_2.py
@@ -1,6 +1,7 @@
 import lz4.frame as lz4frame
 import pytest
 import os
+import copy
 import sys
 from . helpers import (
     get_chunked,
@@ -41,6 +42,13 @@ def test_roundtrip_chunked(data, block_size, block_linked,
 
     data, c_chunks, d_chunks = data
 
+    if isinstance(data, memoryview):
+        data = memoryview(copy.deepcopy(data.obj))
+    elif isinstance(data, bytearray):
+        data_2 = bytearray()
+        data_2[:] = data
+        data = data_2
+
     c_context = lz4frame.create_compression_context()
 
     kwargs = {}
diff --git a/contrib/python/lz4/py3/tests/frame/test_frame_5.py b/contrib/python/lz4/py3/tests/frame/test_frame_5.py
index 05daf283f93..dcbe4aead10 100644
--- a/contrib/python/lz4/py3/tests/frame/test_frame_5.py
+++ b/contrib/python/lz4/py3/tests/frame/test_frame_5.py
@@ -8,6 +8,8 @@ test_data = [
     (b'a' * 1024 * 1024),
 ]
 
+pytestmark = pytest.mark.thread_unsafe
+
 
 @pytest.fixture(
     params=test_data,
diff --git a/contrib/python/lz4/py3/tests/frame/test_frame_6.py b/contrib/python/lz4/py3/tests/frame/test_frame_6.py
index c20a4f31316..4f4185ee082 100644
--- a/contrib/python/lz4/py3/tests/frame/test_frame_6.py
+++ b/contrib/python/lz4/py3/tests/frame/test_frame_6.py
@@ -1,5 +1,6 @@
 import os
 import pytest
+import threading
 import lz4.frame as lz4frame
 
 test_data = [
@@ -33,40 +34,45 @@ def compression_level(request):
     return request.param
 
 
-def test_lz4frame_open_write(data):
-    with lz4frame.open('testfile', mode='wb') as fp:
+def test_lz4frame_open_write(tmp_path, data):
+    thread_id = threading.get_native_id()
+    with lz4frame.open(tmp_path / f'testfile_{thread_id}', mode='wb') as fp:
         fp.write(data)
 
 
-def test_lz4frame_open_write_read_defaults(data):
-    with lz4frame.open('testfile', mode='wb') as fp:
+def test_lz4frame_open_write_read_defaults(tmp_path, data):
+    thread_id = threading.get_native_id()
+    with lz4frame.open(tmp_path / f'testfile_{thread_id}', mode='wb') as fp:
         fp.write(data)
-    with lz4frame.open('testfile', mode='r') as fp:
+    with lz4frame.open(tmp_path / f'testfile_{thread_id}', mode='r') as fp:
         data_out = fp.read()
     assert data_out == data
 
 
-def test_lz4frame_open_write_read_text():
+def test_lz4frame_open_write_read_text(tmp_path):
     data = u'This is a test string'
-    with lz4frame.open('testfile', mode='wt') as fp:
+    thread_id = threading.get_native_id()
+    with lz4frame.open(tmp_path / f'testfile_{thread_id}', mode='wt') as fp:
         fp.write(data)
-    with lz4frame.open('testfile', mode='rt') as fp:
+    with lz4frame.open(tmp_path / f'testfile_{thread_id}', mode='rt') as fp:
         data_out = fp.read()
     assert data_out == data
 
 
-def test_lz4frame_open_write_read_text_iter():
+def test_lz4frame_open_write_read_text_iter(tmp_path):
     data = u'This is a test string'
-    with lz4frame.open('testfile', mode='wt') as fp:
+    thread_id = threading.get_native_id()
+    with lz4frame.open(tmp_path / f'testfile_{thread_id}', mode='wt') as fp:
         fp.write(data)
     data_out = ''
-    with lz4frame.open('testfile', mode='rt') as fp:
+    with lz4frame.open(tmp_path / f'testfile_{thread_id}', mode='rt') as fp:
         for line in fp:
             data_out += line
     assert data_out == data
 
 
 def test_lz4frame_open_write_read(
+        tmp_path,
         data,
         compression_level,
         block_linked,
@@ -91,29 +97,31 @@ def test_lz4frame_open_write_read(
     kwargs['return_bytearray'] = return_bytearray
     kwargs['mode'] = 'wb'
 
-    with lz4frame.open('testfile', **kwargs) as fp:
+    thread_id = threading.get_native_id()
+    with lz4frame.open(tmp_path / f'testfile_{thread_id}', **kwargs) as fp:
         fp.write(data)
 
-    with lz4frame.open('testfile', mode='r') as fp:
+    with lz4frame.open(tmp_path / f'testfile_{thread_id}', mode='r') as fp:
         data_out = fp.read()
 
     assert data_out == data
 
 
-def test_lz4frame_flush():
+def test_lz4frame_flush(tmp_path):
     data_1 = b"This is a..."
     data_2 = b" test string!"
+    thread_id = threading.get_native_id()
 
-    with lz4frame.open("testfile", mode="w") as fp_write:
+    with lz4frame.open(tmp_path / f"testfile_{thread_id}", mode="w") as fp_write:
         fp_write.write(data_1)
         fp_write.flush()
 
         fp_write.write(data_2)
 
-        with lz4frame.open("testfile", mode="r") as fp_read:
+        with lz4frame.open(tmp_path / f"testfile_{thread_id}", mode="r") as fp_read:
             assert fp_read.read() == data_1
 
         fp_write.flush()
 
-        with lz4frame.open("testfile", mode="r") as fp_read:
+        with lz4frame.open(tmp_path / f"testfile_{thread_id}", mode="r") as fp_read:
             assert fp_read.read() == data_1 + data_2
diff --git a/contrib/python/lz4/py3/tests/frame/test_frame_8.py b/contrib/python/lz4/py3/tests/frame/test_frame_8.py
index 159534aefec..cfaeaace600 100644
--- a/contrib/python/lz4/py3/tests/frame/test_frame_8.py
+++ b/contrib/python/lz4/py3/tests/frame/test_frame_8.py
@@ -1,12 +1,14 @@
+import threading
 import lz4.frame as lz4frame
 
 
-def test_lz4frame_open_write_read_text_iter():
+def test_lz4frame_open_write_read_text_iter(tmp_path):
     data = u'This is a test string'
-    with lz4frame.open('testfile', mode='wt') as fp:
+    thread_id = threading.get_native_id()
+    with lz4frame.open(tmp_path / f'testfile_{thread_id}', mode='wt') as fp:
         fp.write(data)
     data_out = ''
-    with lz4frame.open('testfile', mode='rt') as fp:
+    with lz4frame.open(tmp_path / f'testfile_{thread_id}', mode='rt') as fp:
         for line in fp:
             data_out += line
     assert data_out == data
diff --git a/contrib/python/lz4/py3/tests/frame/test_frame_9.py b/contrib/python/lz4/py3/tests/frame/test_frame_9.py
index 51433934176..6f7fc0dba85 100644
--- a/contrib/python/lz4/py3/tests/frame/test_frame_9.py
+++ b/contrib/python/lz4/py3/tests/frame/test_frame_9.py
@@ -3,11 +3,12 @@ import os
 import io
 import pickle
 import sys
+import threading
 import lz4.frame
 import pytest
 
 
-def test_issue_172_1():
+def test_issue_172_1(tmp_path):
     """Test reproducer for issue 172
 
     Issue 172 is a reported failure occurring on Windows 10 only. This bug was
@@ -16,34 +17,38 @@ def test_issue_172_1():
 
     """
     input_data = 8 * os.urandom(1024)
-    with lz4.frame.open('testfile_small', 'wb') as fp:
+    thread_id = threading.get_native_id()
+
+    with lz4.frame.open(tmp_path / f'testfile_small_{thread_id}', 'wb') as fp:
         bytes_written = fp.write(input_data)  # noqa: F841
 
-    with lz4.frame.open('testfile_small', 'rb') as fp:
+    with lz4.frame.open(tmp_path / f'testfile_small_{thread_id}', 'rb') as fp:
         data = fp.read(10)
         assert len(data) == 10
 
 
-def test_issue_172_2():
+def test_issue_172_2(tmp_path):
     input_data = 9 * os.urandom(1024)
-    with lz4.frame.open('testfile_small', 'w') as fp:
+    thread_id = threading.get_native_id()
+    with lz4.frame.open(tmp_path / f'testfile_small_{thread_id}', 'w') as fp:
         bytes_written = fp.write(input_data)  # noqa: F841
 
-    with lz4.frame.open('testfile_small', 'r') as fp:
+    with lz4.frame.open(tmp_path / f'testfile_small_{thread_id}', 'r') as fp:
         data = fp.read(10)
         assert len(data) == 10
 
 
-def test_issue_172_3():
+def test_issue_172_3(tmp_path):
     input_data = 9 * os.urandom(1024)
-    with lz4.frame.open('testfile_small', 'wb') as fp:
+    thread_id = threading.get_native_id()
+    with lz4.frame.open(tmp_path / f'testfile_small_{thread_id}', 'wb') as fp:
         bytes_written = fp.write(input_data)  # noqa: F841
 
-    with lz4.frame.open('testfile_small', 'rb') as fp:
+    with lz4.frame.open(tmp_path / f'testfile_small_{thread_id}', 'rb') as fp:
         data = fp.read(10)
         assert len(data) == 10
 
-    with lz4.frame.open('testfile_small', 'rb') as fp:
+    with lz4.frame.open(tmp_path / f'testfile_small_{thread_id}', 'rb') as fp:
         data = fp.read(16 * 1024 - 1)
         assert len(data) == 9 * 1024
         assert data == input_data
@@ -60,7 +65,7 @@ def test_issue_227_1():
 
 @pytest.mark.skipif(
     sys.version_info < (3, 8),
-    reason="PickleBuffer only availiable in Python 3.8 or greater"
+    reason="PickleBuffer only available in Python 3.8 or greater"
 )
 def test_issue_227_2():
     q = array.array('Q', [1, 2, 3, 4, 5])
diff --git a/contrib/python/lz4/py3/tests/stream/test_stream_0.py b/contrib/python/lz4/py3/tests/stream/test_stream_0.py
index 03b19f3f424..3cd05d6f511 100644
--- a/contrib/python/lz4/py3/tests/stream/test_stream_0.py
+++ b/contrib/python/lz4/py3/tests/stream/test_stream_0.py
@@ -96,6 +96,7 @@ def setup_kwargs(strategy, mode, buffer_size, store_comp_size,
 
 
 # Test single threaded usage with all valid variations of input
[email protected]_unsafe
 def test_1(data, strategy, mode, buffer_size, store_comp_size,
            c_return_bytearray, d_return_bytearray, dictionary):
     if buffer_size >= (1 << (8 * store_comp_size['store_comp_size'])):
@@ -111,6 +112,6 @@ def test_1(data, strategy, mode, buffer_size, store_comp_size,
 
 # Test multi threaded:
 #   Not relevant in the lz4.stream case (the process is highly sequential,
-#   and re-use/share the same context from one input chunk to the next one).
+#   and reuse/share the same context from one input chunk to the next one).
 def test_2(data, strategy, mode, buffer_size, store_comp_size, dictionary): # noqa
     pass
diff --git a/contrib/python/lz4/py3/tests/stream/test_stream_1.py b/contrib/python/lz4/py3/tests/stream/test_stream_1.py
index 6b49267e262..481de8aa5b5 100644
--- a/contrib/python/lz4/py3/tests/stream/test_stream_1.py
+++ b/contrib/python/lz4/py3/tests/stream/test_stream_1.py
@@ -136,7 +136,7 @@ def test_invalid_config_c_4(store_comp_size):
     c_kwargs.update(store_comp_size)
 
     if store_comp_size['store_comp_size'] >= 4:
-        # No need for skiping this test case, since arguments check is
+        # No need for skipping this test case, since arguments check is
         # expecting to raise an error.
 
         # Make sure the page size is larger than what the input bound will be,
@@ -169,7 +169,7 @@ def test_invalid_config_d_4(store_comp_size):
         # but still fit in 4 bytes
         d_kwargs['buffer_size'] -= 1
 
-    # No failure expected during instanciation/initialization
+    # No failure expected during instantiation/initialization
     lz4.stream.LZ4StreamDecompressor(**d_kwargs)
 
 
@@ -199,7 +199,7 @@ def test_invalid_config_d_5():
     d_kwargs = {}
     d_kwargs['strategy'] = "double_buffer"
 
-    # No failure expected during instanciation/initialization
+    # No failure expected during instantiation/initialization
     d_kwargs['buffer_size'] = lz4.stream.LZ4_MAX_INPUT_SIZE
 
     if sys.maxsize < 0xffffffff:
@@ -207,7 +207,7 @@ def test_invalid_config_d_5():
 
     lz4.stream.LZ4StreamDecompressor(**d_kwargs)
 
-    # No failure expected during instanciation/initialization
+    # No failure expected during instantiation/initialization
     d_kwargs['buffer_size'] = lz4.stream.LZ4_MAX_INPUT_SIZE + 1
 
     if sys.maxsize < 0xffffffff:
@@ -215,7 +215,7 @@ def test_invalid_config_d_5():
 
     lz4.stream.LZ4StreamDecompressor(**d_kwargs)
 
-    # No failure expected during instanciation/initialization
+    # No failure expected during instantiation/initialization
     d_kwargs['buffer_size'] = _4GB - 1  # 4GB - 1 (to fit in 4 bytes)
 
     if sys.maxsize < 0xffffffff:
diff --git a/contrib/python/lz4/py3/tests/stream/test_stream_3.py b/contrib/python/lz4/py3/tests/stream/test_stream_3.py
index 2b52d6b5494..fed93d2c4a7 100644
--- a/contrib/python/lz4/py3/tests/stream/test_stream_3.py
+++ b/contrib/python/lz4/py3/tests/stream/test_stream_3.py
@@ -71,6 +71,7 @@ def data(request):
     return request.param
 
 
[email protected]_unsafe
 def test_block_decompress_mem_usage(data, buffer_size):
     kwargs = {
         'strategy': "double_buffer",
diff --git a/contrib/python/lz4/py3/ya.make b/contrib/python/lz4/py3/ya.make
index 90442055a36..4fd0725b1ee 100644
--- a/contrib/python/lz4/py3/ya.make
+++ b/contrib/python/lz4/py3/ya.make
@@ -2,7 +2,7 @@
 
 PY3_LIBRARY()
 
-VERSION(4.4.4)
+VERSION(4.4.5)
 
 LICENSE(BSD-3-Clause)