python-lz4 fails to build with Python 3.10.0b1:
=================================== FAILURES ===================================
_________________ test_frame_open_decompress_mem_usage[data0] __________________
data = b'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa...aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
    def test_frame_open_decompress_mem_usage(data):
        tracemalloc = pytest.importorskip('tracemalloc')
        tracemalloc.start()
    
        with lz4.frame.open('test.lz4', 'w') as f:
            f.write(data)
    
        prev_snapshot = None
    
        for i in range(1000):
            with lz4.frame.open('test.lz4', 'r') as f:
>               decompressed = f.read()  # noqa: F841
data       = b'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa...aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
f          = <lz4.frame.LZ4FrameFile object at 0x7faf48083e80>
i          = 0
prev_snapshot = None
tracemalloc = <module 'tracemalloc' from '/usr/lib64/python3.10/tracemalloc.py'>
tests/frame/test_frame_5.py:80: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
self = <lz4.frame.LZ4FrameFile object at 0x7faf48083e80>, size = -1
    def read(self, size=-1):
        """Read up to ``size`` uncompressed bytes from the file.
    
        If ``size`` is negative or omitted, read until ``EOF`` is reached.
        Returns ``b''`` if the file is already at ``EOF``.
    
        Args:
            size(int): If non-negative, specifies the maximum number of
                uncompressed bytes to return.
    
        Returns:
            bytes: uncompressed data
    
        """
        self._check_can_read()
>       return self._buffer.read(size)
self       = <lz4.frame.LZ4FrameFile object at 0x7faf48083e80>
size       = -1
lz4/frame/__init__.py:635: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
self = <_compression.DecompressReader object at 0x7faf48080a30>
    def readall(self):
        chunks = []
        # sys.maxsize means the max length of output buffer is unlimited,
        # so that the whole input buffer can be decompressed within one
        # .decompress() call.
>       while data := self.read(sys.maxsize):
chunks     = []
self       = <_compression.DecompressReader object at 0x7faf48080a30>
/usr/lib64/python3.10/_compression.py:118: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
self = <_compression.DecompressReader object at 0x7faf48080a30>
size = 9223372036854775807
    def read(self, size=-1):
        if size < 0:
            return self.readall()
    
        if not size or self._eof:
            return b""
        data = None  # Default if EOF is encountered
        # Depending on the input data, our call to the decompressor may not
        # return any data. In this case, try again after reading another block.
        while True:
            if self._decompressor.eof:
                rawblock = (self._decompressor.unused_data or
                            self._fp.read(BUFFER_SIZE))
                if not rawblock:
                    break
                # Continue to next stream.
                self._decompressor = self._decomp_factory(
                    **self._decomp_args)
                try:
                    data = self._decompressor.decompress(rawblock, size)
                except self._trailing_error:
                    # Trailing data isn't a valid compressed stream; ignore it.
                    break
            else:
                if self._decompressor.needs_input:
                    rawblock = self._fp.read(BUFFER_SIZE)
                    if not rawblock:
                        raise EOFError("Compressed file ended before the "
                                       "end-of-stream marker was reached")
                else:
                    rawblock = b""
>               data = self._decompressor.decompress(rawblock, size)
data       = None
rawblock   = b'\x04"M\x18@@\xc0\x0b\x01\x00\x00\x1fa\x01\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf...\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe8Paaaaa\x00\x00\x00\x00'
self       = <_compression.DecompressReader object at 0x7faf48080a30>
size       = 9223372036854775807
/usr/lib64/python3.10/_compression.py:103: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
self = <lz4.frame.LZ4FrameDecompressor object at 0x7faf480801f0>
data = b'\x04"M\x18@@\xc0\x0b\x01\x00\x00\x1fa\x01\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf...\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe8Paaaaa\x00\x00\x00\x00'
max_length = 9223372036854775807
    def decompress(self, data, max_length=-1):  # noqa: F811
        """Decompresses part or all of an LZ4 frame of compressed data.
    
        The returned data should be concatenated with the output of any
        previous calls to `decompress()`.
    
        If ``max_length`` is non-negative, returns at most ``max_length`` bytes
        of decompressed data. If this limit is reached and further output can
        be produced, the `needs_input` attribute will be set to ``False``. In
        this case, the next call to `decompress()` may provide data as
        ``b''`` to obtain more of the output. In all cases, any unconsumed data
        from previous calls will be prepended to the input data.
    
        If all of the input ``data`` was decompressed and returned (either
        because this was less than ``max_length`` bytes, or because
        ``max_length`` was negative), the `needs_input` attribute will be set
        to ``True``.
    
        If an end of frame marker is encountered in the data during
        decompression, decompression will stop at the end of the frame, and any
        data after the end of frame is available from the `unused_data`
        attribute. In this case, the `LZ4FrameDecompressor` instance is reset
        and can be used for further decompression.
    
        Args:
            data (str, bytes or buffer-compatible object): compressed data to
                decompress
    
        Keyword Args:
            max_length (int): If this is non-negative, this method returns at
                most ``max_length`` bytes of decompressed data.
    
        Returns:
            bytes: Uncompressed data
    
        """
    
        if self._unconsumed_data:
            data = self._unconsumed_data + data
    
>       decompressed, bytes_read, eoframe = decompress_chunk(
            self._context,
            data,
            max_length=max_length,
            return_bytearray=self._return_bytearray,
        )
E       MemoryError
data       = b'\x04"M\x18@@\xc0\x0b\x01\x00\x00\x1fa\x01\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf...\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe8Paaaaa\x00\x00\x00\x00'
max_length = 9223372036854775807
self       = <lz4.frame.LZ4FrameDecompressor object at 0x7faf480801f0>
lz4/frame/__init__.py:394: MemoryError
=========================== short test summary info ============================
FAILED tests/frame/test_frame_5.py::test_frame_open_decompress_mem_usage[data0]
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
================= 1 failed, 19015 passed in 160.81s (0:02:40) ==================

For the build logs, see:
https://copr-be.cloud.fedoraproject.org/results/@python/python3.10/fedora-rawhide-x86_64/02174997-python-lz4/

For all our attempts to build python-lz4 with Python 3.10, see:
https://copr.fedorainfracloud.org/coprs/g/python/python3.10/package/python-lz4/

Testing and mass rebuild of packages is happening in copr. You can follow these instructions to test locally in mock if your package builds with Python 3.10:
https://copr.fedorainfracloud.org/coprs/g/python/python3.10/

Let us know here if you have any questions.

Python 3.10 will be included in Fedora 35. To make that update smoother, we're building Fedora packages with early pre-releases of Python 3.10.
A build failure prevents us from testing all dependent packages (transitive [Build]Requires), so if this package is required a lot, it's important for us to get it fixed soon.
We'd appreciate help from the people who know this package best, but if you don't want to work on this now, let us know so we can try to work around it on our side.