Debian Codegraph @

src/c/compression_zstd/clinic/_zstdmodule.c.h

raw
1 /*[clinic input]
2 preserve
3 [clinic start generated code]*/
4
5 #include "backports_zstd_edits.h"
6
7 PyDoc_STRVAR(_zstd_train_dict__doc__,
8 "train_dict($module, samples_bytes, samples_sizes, dict_size, /)\n"
9 "--\n"
10 "\n"
11 "Train a Zstandard dictionary on sample data.\n"
12 "\n"
13 " samples_bytes\n"
14 " Concatenation of samples.\n"
15 " samples_sizes\n"
16 " Tuple of samples\' sizes.\n"
17 " dict_size\n"
18 " The size of the dictionary.");
19
20 #define _ZSTD_TRAIN_DICT_METHODDEF \
21 {"train_dict", _PyCFunction_CAST(_zstd_train_dict), METH_FASTCALL, _zstd_train_dict__doc__},
22
23 static PyObject *
24 _zstd_train_dict_impl(PyObject *module, PyBytesObject *samples_bytes,
25 PyObject *samples_sizes, Py_ssize_t dict_size);
26
27 static PyObject *
28 _zstd_train_dict(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
29 {
30 PyObject *return_value = NULL;
31 PyBytesObject *samples_bytes;
32 PyObject *samples_sizes;
33 Py_ssize_t dict_size;
34
35 if (!BACKPORTSZSTD__PyArg_CheckPositional("train_dict", nargs, 3, 3)) {
36 goto exit;
37 }
38 if (!PyBytes_Check(args[0])) {
39 BACKPORTSZSTD__PyArg_BadArgument("train_dict", "argument 1", "bytes", args[0]);
40 goto exit;
41 }
42 samples_bytes = (PyBytesObject *)args[0];
43 if (!PyTuple_Check(args[1])) {
44 BACKPORTSZSTD__PyArg_BadArgument("train_dict", "argument 2", "tuple", args[1]);
45 goto exit;
46 }
47 samples_sizes = args[1];
48 {
49 Py_ssize_t ival = -1;
50 PyObject *iobj = BACKPORTSZSTD__PyNumber_Index(args[2]);
51 if (iobj != NULL) {
52 ival = PyLong_AsSsize_t(iobj);
53 Py_DECREF(iobj);
54 }
55 if (ival == -1 && PyErr_Occurred()) {
56 goto exit;
57 }
58 dict_size = ival;
59 }
60 return_value = _zstd_train_dict_impl(module, samples_bytes, samples_sizes, dict_size);
61
62 exit:
63 return return_value;
64 }
65
66 PyDoc_STRVAR(_zstd_finalize_dict__doc__,
67 "finalize_dict($module, custom_dict_bytes, samples_bytes, samples_sizes,\n"
68 " dict_size, compression_level, /)\n"
69 "--\n"
70 "\n"
71 "Finalize a Zstandard dictionary.\n"
72 "\n"
73 " custom_dict_bytes\n"
74 " Custom dictionary content.\n"
75 " samples_bytes\n"
76 " Concatenation of samples.\n"
77 " samples_sizes\n"
78 " Tuple of samples\' sizes.\n"
79 " dict_size\n"
80 " The size of the dictionary.\n"
81 " compression_level\n"
82 " Optimize for a specific Zstandard compression level, 0 means default.");
83
84 #define _ZSTD_FINALIZE_DICT_METHODDEF \
85 {"finalize_dict", _PyCFunction_CAST(_zstd_finalize_dict), METH_FASTCALL, _zstd_finalize_dict__doc__},
86
87 static PyObject *
88 _zstd_finalize_dict_impl(PyObject *module, PyBytesObject *custom_dict_bytes,
89 PyBytesObject *samples_bytes,
90 PyObject *samples_sizes, Py_ssize_t dict_size,
91 int compression_level);
92
93 static PyObject *
94 _zstd_finalize_dict(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
95 {
96 PyObject *return_value = NULL;
97 PyBytesObject *custom_dict_bytes;
98 PyBytesObject *samples_bytes;
99 PyObject *samples_sizes;
100 Py_ssize_t dict_size;
101 int compression_level;
102
103 if (!BACKPORTSZSTD__PyArg_CheckPositional("finalize_dict", nargs, 5, 5)) {
104 goto exit;
105 }
106 if (!PyBytes_Check(args[0])) {
107 BACKPORTSZSTD__PyArg_BadArgument("finalize_dict", "argument 1", "bytes", args[0]);
108 goto exit;
109 }
110 custom_dict_bytes = (PyBytesObject *)args[0];
111 if (!PyBytes_Check(args[1])) {
112 BACKPORTSZSTD__PyArg_BadArgument("finalize_dict", "argument 2", "bytes", args[1]);
113 goto exit;
114 }
115 samples_bytes = (PyBytesObject *)args[1];
116 if (!PyTuple_Check(args[2])) {
117 BACKPORTSZSTD__PyArg_BadArgument("finalize_dict", "argument 3", "tuple", args[2]);
118 goto exit;
119 }
120 samples_sizes = args[2];
121 {
122 Py_ssize_t ival = -1;
123 PyObject *iobj = BACKPORTSZSTD__PyNumber_Index(args[3]);
124 if (iobj != NULL) {
125 ival = PyLong_AsSsize_t(iobj);
126 Py_DECREF(iobj);
127 }
128 if (ival == -1 && PyErr_Occurred()) {
129 goto exit;
130 }
131 dict_size = ival;
132 }
133 compression_level = PyLong_AsInt(args[4]);
134 if (compression_level == -1 && PyErr_Occurred()) {
135 goto exit;
136 }
137 return_value = _zstd_finalize_dict_impl(module, custom_dict_bytes, samples_bytes, samples_sizes, dict_size, compression_level);
138
139 exit:
140 return return_value;
141 }
142
143 PyDoc_STRVAR(_zstd_get_param_bounds__doc__,
144 "get_param_bounds($module, /, parameter, is_compress)\n"
145 "--\n"
146 "\n"
147 "Get CompressionParameter/DecompressionParameter bounds.\n"
148 "\n"
149 " parameter\n"
150 " The parameter to get bounds.\n"
151 " is_compress\n"
152 " True for CompressionParameter, False for DecompressionParameter.");
153
154 #define _ZSTD_GET_PARAM_BOUNDS_METHODDEF \
155 {"get_param_bounds", _PyCFunction_CAST(_zstd_get_param_bounds), METH_FASTCALL|METH_KEYWORDS, _zstd_get_param_bounds__doc__},
156
157 static PyObject *
158 _zstd_get_param_bounds_impl(PyObject *module, int parameter, int is_compress);
159
160 static PyObject *
161 _zstd_get_param_bounds(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
162 {
163 PyObject *return_value = NULL;
164 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
165
166 #define NUM_KEYWORDS 2
167 static struct {
168 PyGC_Head _this_is_not_used;
169 PyObject_VAR_HEAD
170 Py_hash_t ob_hash;
171 PyObject *ob_item[NUM_KEYWORDS];
172 } _kwtuple = {
173 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
174 .ob_hash = -1,
175 .ob_item = { &_Py_ID(parameter), &_Py_ID(is_compress), },
176 };
177 #undef NUM_KEYWORDS
178 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
179
180 #else // !Py_BUILD_CORE
181 # define KWTUPLE NULL
182 #endif // !Py_BUILD_CORE
183
184 static const char * const _keywords[] = {"parameter", "is_compress", NULL};
185 static _PyArg_Parser _parser = {
186 .keywords = _keywords,
187 .fname = "get_param_bounds",
188 .kwtuple = KWTUPLE,
189 };
190 #undef KWTUPLE
191 PyObject *argsbuf[2];
192 int parameter;
193 int is_compress;
194
195 args = BACKPORTSZSTD__PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
196 /*minpos*/ 2, /*maxpos*/ 2, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
197 if (!args) {
198 goto exit;
199 }
200 parameter = PyLong_AsInt(args[0]);
201 if (parameter == -1 && PyErr_Occurred()) {
202 goto exit;
203 }
204 is_compress = PyObject_IsTrue(args[1]);
205 if (is_compress < 0) {
206 goto exit;
207 }
208 return_value = _zstd_get_param_bounds_impl(module, parameter, is_compress);
209
210 exit:
211 return return_value;
212 }
213
214 PyDoc_STRVAR(_zstd_get_frame_size__doc__,
215 "get_frame_size($module, /, frame_buffer)\n"
216 "--\n"
217 "\n"
218 "Get the size of a Zstandard frame, including the header and optional checksum.\n"
219 "\n"
220 " frame_buffer\n"
221 " A bytes-like object, it should start from the beginning of a frame,\n"
222 " and contains at least one complete frame.");
223
224 #define _ZSTD_GET_FRAME_SIZE_METHODDEF \
225 {"get_frame_size", _PyCFunction_CAST(_zstd_get_frame_size), METH_FASTCALL|METH_KEYWORDS, _zstd_get_frame_size__doc__},
226
227 static PyObject *
228 _zstd_get_frame_size_impl(PyObject *module, Py_buffer *frame_buffer);
229
230 static PyObject *
231 _zstd_get_frame_size(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
232 {
233 PyObject *return_value = NULL;
234 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
235
236 #define NUM_KEYWORDS 1
237 static struct {
238 PyGC_Head _this_is_not_used;
239 PyObject_VAR_HEAD
240 Py_hash_t ob_hash;
241 PyObject *ob_item[NUM_KEYWORDS];
242 } _kwtuple = {
243 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
244 .ob_hash = -1,
245 .ob_item = { &_Py_ID(frame_buffer), },
246 };
247 #undef NUM_KEYWORDS
248 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
249
250 #else // !Py_BUILD_CORE
251 # define KWTUPLE NULL
252 #endif // !Py_BUILD_CORE
253
254 static const char * const _keywords[] = {"frame_buffer", NULL};
255 static _PyArg_Parser _parser = {
256 .keywords = _keywords,
257 .fname = "get_frame_size",
258 .kwtuple = KWTUPLE,
259 };
260 #undef KWTUPLE
261 PyObject *argsbuf[1];
262 Py_buffer frame_buffer = {NULL, NULL};
263
264 args = BACKPORTSZSTD__PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
265 /*minpos*/ 1, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
266 if (!args) {
267 goto exit;
268 }
269 if (PyObject_GetBuffer(args[0], &frame_buffer, PyBUF_SIMPLE) != 0) {
270 goto exit;
271 }
272 return_value = _zstd_get_frame_size_impl(module, &frame_buffer);
273
274 exit:
275 /* Cleanup for frame_buffer */
276 if (frame_buffer.obj) {
277 PyBuffer_Release(&frame_buffer);
278 }
279
280 return return_value;
281 }
282
283 PyDoc_STRVAR(_zstd_get_frame_info__doc__,
284 "get_frame_info($module, /, frame_buffer)\n"
285 "--\n"
286 "\n"
287 "Get Zstandard frame infomation from a frame header.\n"
288 "\n"
289 " frame_buffer\n"
290 " A bytes-like object, containing the header of a Zstandard frame.");
291
292 #define _ZSTD_GET_FRAME_INFO_METHODDEF \
293 {"get_frame_info", _PyCFunction_CAST(_zstd_get_frame_info), METH_FASTCALL|METH_KEYWORDS, _zstd_get_frame_info__doc__},
294
295 static PyObject *
296 _zstd_get_frame_info_impl(PyObject *module, Py_buffer *frame_buffer);
297
298 static PyObject *
299 _zstd_get_frame_info(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
300 {
301 PyObject *return_value = NULL;
302 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
303
304 #define NUM_KEYWORDS 1
305 static struct {
306 PyGC_Head _this_is_not_used;
307 PyObject_VAR_HEAD
308 Py_hash_t ob_hash;
309 PyObject *ob_item[NUM_KEYWORDS];
310 } _kwtuple = {
311 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
312 .ob_hash = -1,
313 .ob_item = { &_Py_ID(frame_buffer), },
314 };
315 #undef NUM_KEYWORDS
316 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
317
318 #else // !Py_BUILD_CORE
319 # define KWTUPLE NULL
320 #endif // !Py_BUILD_CORE
321
322 static const char * const _keywords[] = {"frame_buffer", NULL};
323 static _PyArg_Parser _parser = {
324 .keywords = _keywords,
325 .fname = "get_frame_info",
326 .kwtuple = KWTUPLE,
327 };
328 #undef KWTUPLE
329 PyObject *argsbuf[1];
330 Py_buffer frame_buffer = {NULL, NULL};
331
332 args = BACKPORTSZSTD__PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
333 /*minpos*/ 1, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
334 if (!args) {
335 goto exit;
336 }
337 if (PyObject_GetBuffer(args[0], &frame_buffer, PyBUF_SIMPLE) != 0) {
338 goto exit;
339 }
340 return_value = _zstd_get_frame_info_impl(module, &frame_buffer);
341
342 exit:
343 /* Cleanup for frame_buffer */
344 if (frame_buffer.obj) {
345 PyBuffer_Release(&frame_buffer);
346 }
347
348 return return_value;
349 }
350
351 PyDoc_STRVAR(_zstd_set_parameter_types__doc__,
352 "set_parameter_types($module, /, c_parameter_type, d_parameter_type)\n"
353 "--\n"
354 "\n"
355 "Set CompressionParameter and DecompressionParameter types for validity check.\n"
356 "\n"
357 " c_parameter_type\n"
358 " CompressionParameter IntEnum type object\n"
359 " d_parameter_type\n"
360 " DecompressionParameter IntEnum type object");
361
362 #define _ZSTD_SET_PARAMETER_TYPES_METHODDEF \
363 {"set_parameter_types", _PyCFunction_CAST(_zstd_set_parameter_types), METH_FASTCALL|METH_KEYWORDS, _zstd_set_parameter_types__doc__},
364
365 static PyObject *
366 _zstd_set_parameter_types_impl(PyObject *module, PyObject *c_parameter_type,
367 PyObject *d_parameter_type);
368
369 static PyObject *
370 _zstd_set_parameter_types(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
371 {
372 PyObject *return_value = NULL;
373 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
374
375 #define NUM_KEYWORDS 2
376 static struct {
377 PyGC_Head _this_is_not_used;
378 PyObject_VAR_HEAD
379 Py_hash_t ob_hash;
380 PyObject *ob_item[NUM_KEYWORDS];
381 } _kwtuple = {
382 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
383 .ob_hash = -1,
384 .ob_item = { &_Py_ID(c_parameter_type), &_Py_ID(d_parameter_type), },
385 };
386 #undef NUM_KEYWORDS
387 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
388
389 #else // !Py_BUILD_CORE
390 # define KWTUPLE NULL
391 #endif // !Py_BUILD_CORE
392
393 static const char * const _keywords[] = {"c_parameter_type", "d_parameter_type", NULL};
394 static _PyArg_Parser _parser = {
395 .keywords = _keywords,
396 .fname = "set_parameter_types",
397 .kwtuple = KWTUPLE,
398 };
399 #undef KWTUPLE
400 PyObject *argsbuf[2];
401 PyObject *c_parameter_type;
402 PyObject *d_parameter_type;
403
404 args = BACKPORTSZSTD__PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
405 /*minpos*/ 2, /*maxpos*/ 2, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
406 if (!args) {
407 goto exit;
408 }
409 if (!PyObject_TypeCheck(args[0], &PyType_Type)) {
410 BACKPORTSZSTD__PyArg_BadArgument("set_parameter_types", "argument 'c_parameter_type'", (&PyType_Type)->tp_name, args[0]);
411 goto exit;
412 }
413 c_parameter_type = args[0];
414 if (!PyObject_TypeCheck(args[1], &PyType_Type)) {
415 BACKPORTSZSTD__PyArg_BadArgument("set_parameter_types", "argument 'd_parameter_type'", (&PyType_Type)->tp_name, args[1]);
416 goto exit;
417 }
418 d_parameter_type = args[1];
419 return_value = _zstd_set_parameter_types_impl(module, c_parameter_type, d_parameter_type);
420
421 exit:
422 return return_value;
423 }
424 /*[clinic end generated code: output=437b084f149e68e5 input=a9049054013a1b77]*/