| Server IP : 121.121.20.254 / Your IP : 216.73.216.202 Web Server : Microsoft-IIS/10.0 System : Windows NT WEB-SERVER 10.0 build 20348 (Windows Server 2022) AMD64 User : IUSR ( 0) PHP Version : 8.3.28 Disable Function : NONE MySQL : ON | cURL : ON | WGET : OFF | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : C:/Python312/Lib/site-packages/lz4/frame/__pycache__/ |
Upload File : |
�
�7�h} � �V � d dl Z d dlZd dlZd dlZd dlZddlmZmZmZm Z m
Z
m Z m Z m
Z
mZmZmZmZmZmZmZmZ eZ d dl Z eZ eZ eZ eZ eZ d Z dZ dZ! G d� de"� Z# G d � d
e"� Z$d Z%dZ&dZ' G d � d e jP � Z)d
dddede ddddd f d�Z*y# e $ r ddl m Z Y �gw xY w)� N� )�compress�
decompress�create_compression_context�compress_begin�compress_chunk�compress_flush� create_decompression_context�reset_decompression_context�decompress_chunk�get_frame_info�BLOCKSIZE_DEFAULT�BLOCKSIZE_MAX64KB�BLOCKSIZE_MAX256KB�BLOCKSIZE_MAX1MB�BLOCKSIZE_MAX4MB�__doc__)� _compression� � c �X � e Zd ZdZededdddfd�Zd� Zd� Zdd�Z d� Z
d � Z d
� Z d � Z
d � Zy
)�LZ4FrameCompressora� Create a LZ4 frame compressor object.
This object can be used to compress data incrementally.
Args:
block_size (int): Specifies the maximum blocksize to use.
Options:
- `lz4.frame.BLOCKSIZE_DEFAULT`: the lz4 library default
- `lz4.frame.BLOCKSIZE_MAX64KB`: 64 kB
- `lz4.frame.BLOCKSIZE_MAX256KB`: 256 kB
- `lz4.frame.BLOCKSIZE_MAX1MB`: 1 MB
- `lz4.frame.BLOCKSIZE_MAX4MB`: 4 MB
If unspecified, will default to `lz4.frame.BLOCKSIZE_DEFAULT` which
is equal to `lz4.frame.BLOCKSIZE_MAX64KB`.
block_linked (bool): Specifies whether to use block-linked
compression. If ``True``, the compression ratio is improved,
especially for small block sizes. If ``False`` the blocks are
compressed independently. The default is ``True``.
compression_level (int): Specifies the level of compression used.
Values between 0-16 are valid, with 0 (default) being the
lowest compression (0-2 are the same value), and 16 the highest.
Values above 16 will be treated as 16.
Values between 4-9 are recommended. 0 is the default.
The following module constants are provided as a convenience:
- `lz4.frame.COMPRESSIONLEVEL_MIN`: Minimum compression (0)
- `lz4.frame.COMPRESSIONLEVEL_MINHC`: Minimum high-compression (3)
- `lz4.frame.COMPRESSIONLEVEL_MAX`: Maximum compression (16)
content_checksum (bool): Specifies whether to enable checksumming of
the payload content. If ``True``, a checksum of the uncompressed
data is stored at the end of the compressed frame which is checked
during decompression. The default is ``False``.
block_checksum (bool): Specifies whether to enable checksumming of
the content of each block. If ``True`` a checksum of the
uncompressed data in each block in the frame is stored at the end
of each block. If present, these checksums will be used to
validate the data during decompression. The default is ``False``,
meaning block checksums are not calculated and stored. This
functionality is only supported if the underlying LZ4 library has
version >= 1.8.0. Attempting to set this value to ``True`` with a
version of LZ4 < 1.8.0 will cause a ``RuntimeError`` to be raised.
auto_flush (bool): When ``False``, the LZ4 library may buffer data
until a block is full. When ``True`` no buffering occurs, and
partially full blocks may be returned. The default is ``False``.
return_bytearray (bool): When ``False`` a ``bytes`` object is returned
from the calls to methods of this class. When ``True`` a
``bytearray`` object will be returned. The default is ``False``.
TFc �� � || _ || _ || _ || _ |r"t j
� dk r t
d� �|| _ || _ || _ d | _
d| _ y )Ni0* zEAttempt to set block_checksum to True with LZ4 libraryversion < 10800F) �
block_size� block_linked�compression_level�content_checksum�lz4�library_version_number� RuntimeError�block_checksum�
auto_flush�return_bytearray�_context�_started)�selfr r r r r! r" r# s �4C:\Python312\Lib\site-packages\lz4/frame/__init__.py�__init__zLZ4FrameCompressor.__init__� so � � %��� (���!2�� � 0�� � �c� 8� 8� :�U� B� �"��
� -���$��� 0�� � ��
� ��
� c � � | S �N� �r& s r' � __enter__z LZ4FrameCompressor.__enter__� � � �� r) c � � d | _ d | _ d | _ d | _ d | _ d | _ d | _ d | _ d| _ y )NF) r r r r r! r" r# r$ r% �r& �exception_type� exception� tracebacks r' �__exit__zLZ4FrameCompressor.__exit__� sF � � ��� ���!%�� � $�� � "��� ��� $�� � ��
� ��
r) c �, � | j du r|t � | _ t | j | j | j
| j | j | j | j | j |�� }d| _ |S t d� �)aM Begin a compression frame.
The returned data contains frame header information. The data returned
from subsequent calls to ``compress()`` should be concatenated with
this header.
Keyword Args:
source_size (int): Optionally specify the total size of the
uncompressed data. If specified, will be stored in the
compressed frame header as an 8-byte field for later use
during decompression. Default is 0 (no size stored).
Returns:
bytes or bytearray: frame header data
F)r r r r r! r" r# � source_sizeTz;LZ4FrameCompressor.begin() called after already initialized) r% r r$ r r r r r r! r" r# r )r& r7 �results r' �beginzLZ4FrameCompressor.begin� s� � �$ �=�=�E� !� 6� 8�D�M�#��
�
� �?�?� !� .� .�"&�"8�"8�!%�!6�!6� #� 2� 2� �?�?�!%�!6�!6� '�
�F� !�D�M��M� �M��
r) c � � | j � t d� �| j du r t d� �t | j || j �� }|S )a� Compresses data and returns it.
This compresses ``data`` (a ``bytes`` object), returning a bytes or
bytearray object containing compressed data the input.
If ``auto_flush`` has been set to ``False``, some of ``data`` may be
buffered internally, for use in later calls to
`LZ4FrameCompressor.compress()` and `LZ4FrameCompressor.flush()`.
The returned data should be concatenated with the output of any
previous calls to `compress()` and a single call to
`compress_begin()`.
Args:
data (str, bytes or buffer-compatible object): data to compress
Returns:
bytes or bytearray: compressed data
z compress called after flush()Fz'compress called before compress_begin())r# )r$ r r% r r# )r& �datar8 s r' r zLZ4FrameCompressor.compress� sU � �* �=�=� � � >�?� ?� �=�=�E� !� � H�I� I� � �M�M�4� !� 2� 2�
��
�
r) c �f � t | j d| j �� }d| _ d| _ |S )a� Finish the compression process.
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
been called to create a new frame of compressed data.
Returns:
bytes or bytearray: compressed data and frame footer.
T)� end_framer# NF)r r$ r# r% )r& r8 s r' �flushzLZ4FrameCompressor.flush s6 � � � �M�M�� !� 2� 2�
��
��
� ��
��
r) c � � d| _ d| _ y)z�Reset the `LZ4FrameCompressor` instance.
This allows the `LZ4FrameCompression` instance to be re-used after an
error.
NF)r$ r% r- s r' �resetzLZ4FrameCompressor.reset s � � ��
� ��
r) c � � | j duS )z�Return whether the compression context exists.
Returns:
bool: ``True`` if the compression context exists, ``False``
otherwise.
N)r$ r- s r' � has_contextz LZ4FrameCompressor.has_context) s � � �}�}�D�(�(r) c � � | j S )z�Return whether the compression frame has been started.
Returns:
bool: ``True`` if the compression frame has been started, ``False``
otherwise.
)r% r- s r' �startedzLZ4FrameCompressor.started2 s � � �}�}� r) N)r )�__name__�
__module__� __qualname__r r �COMPRESSIONLEVEL_MINr( r. r5 r9 r r> r@ rB rD r, r) r' r r e sN � �3�l .� "�#7�"'� %� !�"'� �.� �$�L �D�, �)� r) r c �2 � e Zd ZdZdd�Zd� Zd� Zd� Zd d�Zy)
�LZ4FrameDecompressora� Create a LZ4 frame decompressor object.
This can be used to decompress data incrementally.
For a more convenient way of decompressing an entire compressed frame at
once, see `lz4.frame.decompress()`.
Args:
return_bytearray (bool): When ``False`` a bytes object is returned from
the calls to methods of this class. When ``True`` a bytearray
object will be returned. The default is ``False``.
Attributes:
eof (bool): ``True`` if the end-of-stream marker has been reached.
``False`` otherwise.
unused_data (bytes): Data found after the end of the compressed stream.
Before the end of the frame is reached, this will be ``b''``.
needs_input (bool): ``False`` if the ``decompress()`` method can
provide more decompressed data before requiring new uncompressed
input. ``True`` otherwise.
c �h � t � | _ d| _ d| _ d | _ d| _ || _ y )NFTr) )r
r$ �eof� needs_input� unused_data�_unconsumed_data�_return_bytearray)r& r# s r' r( z LZ4FrameDecompressor.__init__T s3 � �4�6��
���� ��� ��� #�� �!1�� r) c � � | S r+ r, r- s r' r. z LZ4FrameDecompressor.__enter__\ r/ r) c �X � d | _ d | _ d | _ d | _ d | _ d | _ y r+ )r$ rL rM rN rO rP r1 s r' r5 z LZ4FrameDecompressor.__exit__` s0 � � ��
���� ��� ��� $�� �!%�� r) c �f � t | j � d| _ d| _ d| _ d| _ y)zwReset the decompressor state.
This is useful after an error occurs, allowing re-use of the instance.
FTNr) )r r$ rL rM rN rO r- s r' r@ zLZ4FrameDecompressor.reseth s/ � � $�D�M�M�2���� ��� ��� #�� r) c �z � t |t t f� st |� j � }| j
r| j
|z }t
| j ||| j �� \ }}}|t |� k r |r ||d | _
n'||d | _ d| _ nd| _ d| _ d| _
|| _ |S )a# 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
)�
max_lengthr# NFr) T)
�
isinstance�bytes� bytearray�
memoryview�tobytesrO r r$ rP �lenrN rM rL )r& r; rU � decompressed�
bytes_read�eoframes r' r z LZ4FrameDecompressor.decompresst s� � �H �$�� � 2�3� �d�#�+�+�-�D� � � ��(�(�4�/�D�,<� �M�M� �!� !� 3� 3� -
�)� �j�'� ��D� � !��#'�
� �#4�� �(,�Z�[�(9��%�#(�� �$'�D� !� #�D� � #�D� �����r) N)F����) rE rF rG r r( r. r5 r@ r r, r) r' rJ rJ < s � ��.2��&�
$�> r) rJ c
� � e Zd ZdZddededddddf
d�Zd� Zed � � Z d
� Z
d � Z d � Z d
� Z
dd�Zd� Zdd�Zdd�Zdd�Zd� Zd� Zej, fd�Zd� Zy)� LZ4FrameFilea� A file object providing transparent LZ4F (de)compression.
An LZ4FFile can act as a wrapper for an existing file object, or refer
directly to a named file on disk.
Note that LZ4FFile provides a *binary* file interface - data read is
returned as bytes, and data to be written must be given as bytes.
When opening a file for writing, the settings used by the compressor can be
specified. The underlying compressor object is
`lz4.frame.LZ4FrameCompressor`. See the docstrings for that class for
details on compression options.
Args:
filename(str, bytes, PathLike, file object): can be either an actual
file name (given as a str, bytes, or
PathLike object), in which case the named file is opened, or it
can be an existing file object to read from or write to.
Keyword Args:
mode(str): mode can be ``'r'`` for reading (default), ``'w'`` for
(over)writing, ``'x'`` for creating exclusively, or ``'a'``
for appending. These can equivalently be given as ``'rb'``,
``'wb'``, ``'xb'`` and ``'ab'`` respectively.
return_bytearray (bool): When ``False`` a bytes object is returned from
the calls to methods of this class. When ``True`` a ``bytearray``
object will be returned. The default is ``False``.
source_size (int): Optionally specify the total size of the
uncompressed data. If specified, will be stored in the compressed
frame header as an 8-byte field for later use during decompression.
Default is ``0`` (no size stored). Only used for writing
compressed files.
block_size (int): Compressor setting. See
`lz4.frame.LZ4FrameCompressor`.
block_linked (bool): Compressor setting. See
`lz4.frame.LZ4FrameCompressor`.
compression_level (int): Compressor setting. See
`lz4.frame.LZ4FrameCompressor`.
content_checksum (bool): Compressor setting. See
`lz4.frame.LZ4FrameCompressor`.
block_checksum (bool): Compressor setting. See
`lz4.frame.LZ4FrameCompressor`.
auto_flush (bool): Compressor setting. See
`lz4.frame.LZ4FrameCompressor`.
N�rTFr c � � d | _ d| _ t | _ |dv rt } nC|dv r%t
} t
||||||| �� | _ d| _ nt dj |� � �t j dkD r&t |t t t j" f� } nt |t t f� } | du r3d |vr|d z
}t% j& ||� | _ d| _ | | _ n2t) |d
� s t) |d � r|| _ | | _ n t+ d � �| j t k( r>t- j. | j t0 � }
t3 j4 |
� | _ | j t
k( r=|
| _ | j j; | j j= |
�
� � y y )NF)rc �rb)�w�wb�a�ab�x�xb)r r r r r! r" r# r zInvalid mode: {!r})r � T�b�read�writez6filename must be a str, bytes, file or PathLike object�r7 ) �_fp�_closefp� _MODE_CLOSED�_mode�
_MODE_READ� _MODE_WRITEr � _compressor�_pos�
ValueError�format�sys� version_inforV �strrW �os�PathLike�builtins�open�hasattr� TypeErrorr �DecompressReaderrJ �io�BufferedReader�_buffer� _source_sizero r9 )r& �filename�moder r r r r! r" r# r7 � mode_code� path_test�raws r' r( zLZ4FrameFile.__init__� s� � � ��� ��
�!��
� �;� �"�I�
�6�
6�#�I� 1�%� )�"3�!1� -�%�!1� �D� � �D�I� � 1� 8� 8�� >�?� ?� � � �f� $�"�8�c�5�"�+�+�-F�G�I�"�8�c�5�\�:�I� �� ��$���� �� �}�}�X�t�4�D�H� �D�M�"�D�J�
�X�v�
&�'�(�G�*D� �D�H�"�D�J��H��
� �:�:�� #� �/�/����:N�O�C� �,�,�S�1�D�L� �:�:�� $� +�D� � �H�H�N�N�4�+�+�1�1�k�1�J� K� %r) c �n � | j t k( ry | j t k( r"| j j � d| _ n*| j t
k( r| j
� d| _ | j r| j j � d| _ d| _ t | _ y# d| _ d| _ t | _ w xY w# | j r| j j � d| _ d| _ t | _ w # d| _ d| _ t | _ w xY wxY w)z�Flush and close the file.
May be called more than once without error. Once the file is
closed, any other operation on it will raise a ValueError.
NF)
rt rs ru r� �closerv r> rw rr rq r- s r' r� zLZ4FrameFile.close% s� � � �:�:� � %� � *��z�z�Z�'�� � �"�"�$� #�� ����{�*��
�
� �#'�� �
*��=�=��H�H�N�N�$� ��� %��
� )��
�� ��� %��
� )��
��
*��=�=��H�H�N�N�$� ��� %��
� )��
�� ��� %��
� )��
�s0 �A C �6&B6 �6C�D4�&D�<D4�D1�1D4c �( � | j t k( S )z�Returns ``True`` if this file is closed.
Returns:
bool: ``True`` if the file is closed, ``False`` otherwise.
)rt rs r- s r' �closedzLZ4FrameFile.closed= s � � �z�z�\�)�)r) c �V � | j � | j j � S )z�Return the file descriptor for the underlying file.
Returns:
file object: file descriptor for file.
)�_check_not_closedrq �filenor- s r' r� zLZ4FrameFile.filenoG s! � �
� � � ��x�x��� � r) c �Z � | j � xr | j j � S )z�Return whether the file supports seeking.
Returns:
bool: ``True`` if the file supports seeking, ``False`` otherwise.
)�readabler� �seekabler- s r' r� zLZ4FrameFile.seekableQ s" � � �}�}��:�4�<�<�#8�#8�#:�:r) c �H � | j � | j t k( S )z�Return whether the file was opened for reading.
Returns:
bool: ``True`` if the file was opened for reading, ``False``
otherwise.
)r� rt ru r- s r' r� zLZ4FrameFile.readableZ s � �
� � � ��z�z�Z�'�'r) c �H � | j � | j t k( S )z�Return whether the file was opened for writing.
Returns:
bool: ``True`` if the file was opened for writing, ``False``
otherwise.
)r� rt rv r- s r' �writablezLZ4FrameFile.writablee s � �
� � � ��z�z�[�(�(r) c �X � | j � | j j |� S )z�Return buffered data without advancing the file position.
Always returns at least one byte of data, unless at EOF. The exact
number of bytes returned is unspecified.
Returns:
bytes: uncompressed data
)�_check_can_readr� �peek�r& �sizes r' r� zLZ4FrameFile.peekp s' � �
� � � � �|�|� � ��&�&r) c �~ � t � } | j t j � }||z
}|s t |� S �3r+ )rX rn r� �DEFAULT_BUFFER_SIZErW )r& �chunksr; s r' �readallzLZ4FrameFile.readall s> � ������9�9�R� 3� 3�4�D� �d�N�F����V�}� �
r) c � � | j � |dk r#t j dk\ r| j � S | j j |� S )a� 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
r )r �
)r� r{ r| r� r� rn r� s r' rn zLZ4FrameFile.read� sE � �
� � � � �!�8��(�(�G�3��<�<�>� !��|�|� � ��&�&r) c � � | j � |dk rt j }| j j |� S )a� Read up to ``size`` uncompressed bytes.
This method tries to avoid making multiple reads from the underlying
stream.
This method reads up to a buffer's worth of data if ``size`` is
negative.
Returns ``b''`` if the file is at EOF.
Args:
size(int): If non-negative, specifies the maximum number of
uncompressed bytes to return.
Returns:
bytes: uncompressed data
r )r� r� r� r� �read1r� s r' r� zLZ4FrameFile.read1� s7 � �&
� � � � �!�8��)�)�D��|�|�!�!�$�'�'r) c �X � | j � | j j |� S )a� Read a line of uncompressed bytes from the file.
The terminating newline (if present) is retained. If size is
non-negative, no more than size bytes will be read (in which case the
line may be incomplete). Returns b'' if already at EOF.
Args:
size(int): If non-negative, specifies the maximum number of
uncompressed bytes to return.
Returns:
bytes: uncompressed data
)r� r� �readliner� s r' r� zLZ4FrameFile.readline� s% � �
� � � ��|�|�$�$�T�*�*r) c �� � t |t t f� r t |� }nt |� }|j
}| j
� | j j � sA| j j | j �� }| j j |� | j j |� }| j j |� | xj |z
c_ |S )a� Write a bytes object to the file.
Returns the number of uncompressed bytes written, which is
always the length of data in bytes. Note that due to buffering,
the file on disk may not reflect the data written until close()
is called.
Args:
data(bytes): uncompressed data to compress and write to the file
Returns:
int: the number of uncompressed bytes written to the file
rp )rV rW rX r[ rY �nbytes�_check_can_writerw rD r9 r� rq ro r rx )r& r; �length�header�
compresseds r' ro zLZ4FrameFile.write� s� � � �d�U�I� .� /���Y�F� �d�#�D��[�[�F� � � � �� � �'�'�)��%�%�+�+��8I�8I�+�J�F� �H�H�N�N�6� "��%�%�.�.�t�4�
� �����z�"� � � �V�� ��
r) c �� � | j � rM| j j � r3| j j | j j � � | j j � y)z�Flush the file, keeping it open.
May be called more than once without error. The file may continue
to be used normally after flushing.
N)r� rw rB rq ro r> r- s r' r> zLZ4FrameFile.flush� sK � � �=�=�?�t� /� /� ;� ;� =� �H�H�N�N�4�+�+�1�1�3� 4� �����r) c �Z � | j � | j j ||� S )aE Change the file position.
The new position is specified by ``offset``, relative to the position
indicated by ``whence``. Possible values for ``whence`` are:
- ``io.SEEK_SET`` or 0: start of stream (default): offset must not be
negative
- ``io.SEEK_CUR`` or 1: current stream position
- ``io.SEEK_END`` or 2: end of stream; offset must not be positive
Returns the new file position.
Note that seeking is emulated, so depending on the parameters, this
operation may be extremely slow.
Args:
offset(int): new position in the file
whence(int): position with which ``offset`` is measured. Allowed
values are 0, 1, 2. The default is 0 (start of stream).
Returns:
int: new file position
)�_check_can_seekr� �seek)r& �offset�whences r' r� zLZ4FrameFile.seek� s' � �2
� � � ��|�|� � ���0�0r) c � � | j � | j t k( r| j j � S | j
S )z|Return the current file position.
Args:
None
Returns:
int: file position
)r� rt ru r� �tellrx r- s r' r� zLZ4FrameFile.tell s9 � �
� � � � �:�:�� #��<�<�$�$�&� &��y�y�r) r_ )rE rF rG r r rH r( r� �propertyr� r� r� r� r� r� r� rn r� r� ro r> r� �SEEK_SETr� r� r, r) r' rb rb � s� � �-�^ !%�3� -� "�#7�"'� %� !�"'� �8L�t*�0 �*� �*�!�;� (� )�
'� �'�((�0+�$ �B� #%�+�+� 1�8
r) rb re TFc
� � d|v rd|v r5t d|��� �|� t d� �|� t d� �|� t d� �|j dd� }
t | |
||||| |
| | ��
}d|v rt j ||||� S |S ) a
Open an LZ4Frame-compressed file in binary or text mode.
``filename`` can be either an actual file name (given as a str, bytes, or
PathLike object), in which case the named file is opened, or it can be an
existing file object to read from or write to.
The ``mode`` argument can be ``'r'``, ``'rb'`` (default), ``'w'``,
``'wb'``, ``'x'``, ``'xb'``, ``'a'``, or ``'ab'`` for binary mode, or
``'rt'``, ``'wt'``, ``'xt'``, or ``'at'`` for text mode.
For binary mode, this function is equivalent to the `LZ4FrameFile`
constructor: `LZ4FrameFile(filename, mode, ...)`.
For text mode, an `LZ4FrameFile` object is created, and wrapped in an
``io.TextIOWrapper`` instance with the specified encoding, error handling
behavior, and line ending(s).
Args:
filename (str, bytes, os.PathLike): file name or file object to open
Keyword Args:
mode (str): mode for opening the file
encoding (str): the name of the encoding that will be used for
encoding/deconging the stream. It defaults to
``locale.getpreferredencoding(False)``. See ``io.TextIOWrapper``
for further details.
errors (str): specifies how encoding and decoding errors are to be
handled. See ``io.TextIOWrapper`` for further details.
newline (str): controls how line endings are handled. See
``io.TextIOWrapper`` for further details.
return_bytearray (bool): When ``False`` a bytes object is returned
from the calls to methods of this class. When ``True`` a bytearray
object will be returned. The default is ``False``.
source_size (int): Optionally specify the total size of the
uncompressed data. If specified, will be stored in the compressed
frame header as an 8-byte field for later use during decompression.
Default is 0 (no size stored). Only used for writing compressed
files.
block_size (int): Compressor setting. See
`lz4.frame.LZ4FrameCompressor`.
block_linked (bool): Compressor setting. See
`lz4.frame.LZ4FrameCompressor`.
compression_level (int): Compressor setting. See
`lz4.frame.LZ4FrameCompressor`.
content_checksum (bool): Compressor setting. See
`lz4.frame.LZ4FrameCompressor`.
block_checksum (bool): Compressor setting. See
`lz4.frame.LZ4FrameCompressor`.
auto_flush (bool): Compressor setting. See
`lz4.frame.LZ4FrameCompressor`.
�trm zInvalid mode: z0Argument 'encoding' not supported in binary modez.Argument 'errors' not supported in binary modez/Argument 'newline' not supported in binary mode� ) r� r r r r r! r" r# r7 )ry �replacerb r� �
TextIOWrapper)r� r� �encoding�errors�newliner r r r r! r" r# r7 rt � binary_files r' r� r� s� � �@ �d�{� �$�;� �4� 9�:� :� � � �B��
� � � � M�N� N� � � � N�O� O� �L�L��b� !�E� ��
� �!�+�)�%� �)� � �K� �d�{�� � � �X�v�w�G�G��r) )+r r� r~ r� r{ �_framer r r r r r r
r r r
r �_BLOCKSIZE_DEFAULTr �_BLOCKSIZE_MAX64KBr �_BLOCKSIZE_MAX256KBr �_BLOCKSIZE_MAX1MBr �_BLOCKSIZE_MAX4MBr �_docr � ImportErrorr� rH �COMPRESSIONLEVEL_MINHC�COMPRESSIONLEVEL_MAX�objectr rJ rs ru rv �
BaseStreamrb r� r, r) r' �<module>r� s) ��
� � � �
�� � � � �& �� ��
'� �� '� �� )� �� %� �� %� �� � �� � �� � ��T �� T �nv �6� v �r � �
�
�� �a�<�*�*� a�H ����%��/� � �� ��_��E � � � �s �B � B(�'B(