1/*[clinic input]
2preserve
3[clinic start generated code]*/
4
5PyDoc_STRVAR(_lzma_LZMACompressor_compress__doc__,
6"compress($self, data, /)\n"
7"--\n"
8"\n"
9"Provide data to the compressor object.\n"
10"\n"
11"Returns a chunk of compressed data if possible, or b\'\' otherwise.\n"
12"\n"
13"When you have finished providing data to the compressor, call the\n"
14"flush() method to finish the compression process.");
15
16#define _LZMA_LZMACOMPRESSOR_COMPRESS_METHODDEF    \
17    {"compress", (PyCFunction)_lzma_LZMACompressor_compress, METH_O, _lzma_LZMACompressor_compress__doc__},
18
19static PyObject *
20_lzma_LZMACompressor_compress_impl(Compressor *self, Py_buffer *data);
21
22static PyObject *
23_lzma_LZMACompressor_compress(Compressor *self, PyObject *arg)
24{
25    PyObject *return_value = NULL;
26    Py_buffer data = {NULL, NULL};
27
28    if (PyObject_GetBuffer(arg, &data, PyBUF_SIMPLE) != 0) {
29        goto exit;
30    }
31    if (!PyBuffer_IsContiguous(&data, 'C')) {
32        _PyArg_BadArgument("compress", "argument", "contiguous buffer", arg);
33        goto exit;
34    }
35    return_value = _lzma_LZMACompressor_compress_impl(self, &data);
36
37exit:
38    /* Cleanup for data */
39    if (data.obj) {
40       PyBuffer_Release(&data);
41    }
42
43    return return_value;
44}
45
46PyDoc_STRVAR(_lzma_LZMACompressor_flush__doc__,
47"flush($self, /)\n"
48"--\n"
49"\n"
50"Finish the compression process.\n"
51"\n"
52"Returns the compressed data left in internal buffers.\n"
53"\n"
54"The compressor object may not be used after this method is called.");
55
56#define _LZMA_LZMACOMPRESSOR_FLUSH_METHODDEF    \
57    {"flush", (PyCFunction)_lzma_LZMACompressor_flush, METH_NOARGS, _lzma_LZMACompressor_flush__doc__},
58
59static PyObject *
60_lzma_LZMACompressor_flush_impl(Compressor *self);
61
62static PyObject *
63_lzma_LZMACompressor_flush(Compressor *self, PyObject *Py_UNUSED(ignored))
64{
65    return _lzma_LZMACompressor_flush_impl(self);
66}
67
68PyDoc_STRVAR(_lzma_LZMADecompressor_decompress__doc__,
69"decompress($self, /, data, max_length=-1)\n"
70"--\n"
71"\n"
72"Decompress *data*, returning uncompressed data as bytes.\n"
73"\n"
74"If *max_length* is nonnegative, returns at most *max_length* bytes of\n"
75"decompressed data. If this limit is reached and further output can be\n"
76"produced, *self.needs_input* will be set to ``False``. In this case, the next\n"
77"call to *decompress()* may provide *data* as b\'\' to obtain more of the output.\n"
78"\n"
79"If all of the input data was decompressed and returned (either because this\n"
80"was less than *max_length* bytes, or because *max_length* was negative),\n"
81"*self.needs_input* will be set to True.\n"
82"\n"
83"Attempting to decompress data after the end of stream is reached raises an\n"
84"EOFError.  Any data found after the end of the stream is ignored and saved in\n"
85"the unused_data attribute.");
86
87#define _LZMA_LZMADECOMPRESSOR_DECOMPRESS_METHODDEF    \
88    {"decompress", _PyCFunction_CAST(_lzma_LZMADecompressor_decompress), METH_FASTCALL|METH_KEYWORDS, _lzma_LZMADecompressor_decompress__doc__},
89
90static PyObject *
91_lzma_LZMADecompressor_decompress_impl(Decompressor *self, Py_buffer *data,
92                                       Py_ssize_t max_length);
93
94static PyObject *
95_lzma_LZMADecompressor_decompress(Decompressor *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
96{
97    PyObject *return_value = NULL;
98    static const char * const _keywords[] = {"data", "max_length", NULL};
99    static _PyArg_Parser _parser = {NULL, _keywords, "decompress", 0};
100    PyObject *argsbuf[2];
101    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
102    Py_buffer data = {NULL, NULL};
103    Py_ssize_t max_length = -1;
104
105    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
106    if (!args) {
107        goto exit;
108    }
109    if (PyObject_GetBuffer(args[0], &data, PyBUF_SIMPLE) != 0) {
110        goto exit;
111    }
112    if (!PyBuffer_IsContiguous(&data, 'C')) {
113        _PyArg_BadArgument("decompress", "argument 'data'", "contiguous buffer", args[0]);
114        goto exit;
115    }
116    if (!noptargs) {
117        goto skip_optional_pos;
118    }
119    {
120        Py_ssize_t ival = -1;
121        PyObject *iobj = _PyNumber_Index(args[1]);
122        if (iobj != NULL) {
123            ival = PyLong_AsSsize_t(iobj);
124            Py_DECREF(iobj);
125        }
126        if (ival == -1 && PyErr_Occurred()) {
127            goto exit;
128        }
129        max_length = ival;
130    }
131skip_optional_pos:
132    return_value = _lzma_LZMADecompressor_decompress_impl(self, &data, max_length);
133
134exit:
135    /* Cleanup for data */
136    if (data.obj) {
137       PyBuffer_Release(&data);
138    }
139
140    return return_value;
141}
142
143PyDoc_STRVAR(_lzma_LZMADecompressor___init____doc__,
144"LZMADecompressor(format=FORMAT_AUTO, memlimit=None, filters=None)\n"
145"--\n"
146"\n"
147"Create a decompressor object for decompressing data incrementally.\n"
148"\n"
149"  format\n"
150"    Specifies the container format of the input stream.  If this is\n"
151"    FORMAT_AUTO (the default), the decompressor will automatically detect\n"
152"    whether the input is FORMAT_XZ or FORMAT_ALONE.  Streams created with\n"
153"    FORMAT_RAW cannot be autodetected.\n"
154"  memlimit\n"
155"    Limit the amount of memory used by the decompressor.  This will cause\n"
156"    decompression to fail if the input cannot be decompressed within the\n"
157"    given limit.\n"
158"  filters\n"
159"    A custom filter chain.  This argument is required for FORMAT_RAW, and\n"
160"    not accepted with any other format.  When provided, this should be a\n"
161"    sequence of dicts, each indicating the ID and options for a single\n"
162"    filter.\n"
163"\n"
164"For one-shot decompression, use the decompress() function instead.");
165
166static int
167_lzma_LZMADecompressor___init___impl(Decompressor *self, int format,
168                                     PyObject *memlimit, PyObject *filters);
169
170static int
171_lzma_LZMADecompressor___init__(PyObject *self, PyObject *args, PyObject *kwargs)
172{
173    int return_value = -1;
174    static const char * const _keywords[] = {"format", "memlimit", "filters", NULL};
175    static _PyArg_Parser _parser = {NULL, _keywords, "LZMADecompressor", 0};
176    PyObject *argsbuf[3];
177    PyObject * const *fastargs;
178    Py_ssize_t nargs = PyTuple_GET_SIZE(args);
179    Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;
180    int format = FORMAT_AUTO;
181    PyObject *memlimit = Py_None;
182    PyObject *filters = Py_None;
183
184    fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 0, 3, 0, argsbuf);
185    if (!fastargs) {
186        goto exit;
187    }
188    if (!noptargs) {
189        goto skip_optional_pos;
190    }
191    if (fastargs[0]) {
192        format = _PyLong_AsInt(fastargs[0]);
193        if (format == -1 && PyErr_Occurred()) {
194            goto exit;
195        }
196        if (!--noptargs) {
197            goto skip_optional_pos;
198        }
199    }
200    if (fastargs[1]) {
201        memlimit = fastargs[1];
202        if (!--noptargs) {
203            goto skip_optional_pos;
204        }
205    }
206    filters = fastargs[2];
207skip_optional_pos:
208    return_value = _lzma_LZMADecompressor___init___impl((Decompressor *)self, format, memlimit, filters);
209
210exit:
211    return return_value;
212}
213
214PyDoc_STRVAR(_lzma_is_check_supported__doc__,
215"is_check_supported($module, check_id, /)\n"
216"--\n"
217"\n"
218"Test whether the given integrity check is supported.\n"
219"\n"
220"Always returns True for CHECK_NONE and CHECK_CRC32.");
221
222#define _LZMA_IS_CHECK_SUPPORTED_METHODDEF    \
223    {"is_check_supported", (PyCFunction)_lzma_is_check_supported, METH_O, _lzma_is_check_supported__doc__},
224
225static PyObject *
226_lzma_is_check_supported_impl(PyObject *module, int check_id);
227
228static PyObject *
229_lzma_is_check_supported(PyObject *module, PyObject *arg)
230{
231    PyObject *return_value = NULL;
232    int check_id;
233
234    check_id = _PyLong_AsInt(arg);
235    if (check_id == -1 && PyErr_Occurred()) {
236        goto exit;
237    }
238    return_value = _lzma_is_check_supported_impl(module, check_id);
239
240exit:
241    return return_value;
242}
243
244PyDoc_STRVAR(_lzma__decode_filter_properties__doc__,
245"_decode_filter_properties($module, filter_id, encoded_props, /)\n"
246"--\n"
247"\n"
248"Return a bytes object encoding the options (properties) of the filter specified by *filter* (a dict).\n"
249"\n"
250"The result does not include the filter ID itself, only the options.");
251
252#define _LZMA__DECODE_FILTER_PROPERTIES_METHODDEF    \
253    {"_decode_filter_properties", _PyCFunction_CAST(_lzma__decode_filter_properties), METH_FASTCALL, _lzma__decode_filter_properties__doc__},
254
255static PyObject *
256_lzma__decode_filter_properties_impl(PyObject *module, lzma_vli filter_id,
257                                     Py_buffer *encoded_props);
258
259static PyObject *
260_lzma__decode_filter_properties(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
261{
262    PyObject *return_value = NULL;
263    lzma_vli filter_id;
264    Py_buffer encoded_props = {NULL, NULL};
265
266    if (!_PyArg_CheckPositional("_decode_filter_properties", nargs, 2, 2)) {
267        goto exit;
268    }
269    if (!lzma_vli_converter(args[0], &filter_id)) {
270        goto exit;
271    }
272    if (PyObject_GetBuffer(args[1], &encoded_props, PyBUF_SIMPLE) != 0) {
273        goto exit;
274    }
275    if (!PyBuffer_IsContiguous(&encoded_props, 'C')) {
276        _PyArg_BadArgument("_decode_filter_properties", "argument 2", "contiguous buffer", args[1]);
277        goto exit;
278    }
279    return_value = _lzma__decode_filter_properties_impl(module, filter_id, &encoded_props);
280
281exit:
282    /* Cleanup for encoded_props */
283    if (encoded_props.obj) {
284       PyBuffer_Release(&encoded_props);
285    }
286
287    return return_value;
288}
289/*[clinic end generated code: output=bce20bac13b0f252 input=a9049054013a1b77]*/
290