Debian Codegraph @

src/c/compression_zstd/_zstdmodule.c

raw
1 /* Low level interface to the Zstandard algorithm & the zstd library. */
2
3 #ifndef Py_BUILD_CORE_BUILTIN
4 # define Py_BUILD_CORE_MODULE 1
5 #endif
6
7 #include "backports_zstd_compat.h"
8
9 #include "Python.h"
10
11 #include "_zstdmodule.h"
12
13 #include <zstd.h> // ZSTD_*()
14 #include <zdict.h> // ZDICT_*()
15
16 /*[clinic input]
17 module _zstd
18
19 [clinic start generated code]*/
20 /*[clinic end generated code: output=da39a3ee5e6b4b0d input=4b5f5587aac15c14]*/
21 #include "clinic/_zstdmodule.c.h"
22
23
24 ZstdDict *
25 _Py_parse_zstd_dict(const _zstd_state *state, PyObject *dict, int *ptype)
26 {
27 if (state == NULL) {
28 return NULL;
29 }
30
31 /* Check ZstdDict */
32 if (PyObject_TypeCheck(dict, state->ZstdDict_type)) {
33 return (ZstdDict*)dict;
34 }
35
36 /* Check (ZstdDict, type) */
37 if (PyTuple_CheckExact(dict) && PyTuple_GET_SIZE(dict) == 2
38 && PyObject_TypeCheck(PyTuple_GET_ITEM(dict, 0), state->ZstdDict_type)
39 && PyLong_Check(PyTuple_GET_ITEM(dict, 1)))
40 {
41 int type = PyLong_AsInt(PyTuple_GET_ITEM(dict, 1));
42 if (type == -1 && PyErr_Occurred()) {
43 return NULL;
44 }
45 if (type == DICT_TYPE_DIGESTED
46 || type == DICT_TYPE_UNDIGESTED
47 || type == DICT_TYPE_PREFIX)
48 {
49 *ptype = type;
50 return (ZstdDict*)PyTuple_GET_ITEM(dict, 0);
51 }
52 }
53
54 /* Wrong type */
55 PyErr_SetString(PyExc_TypeError,
56 "zstd_dict argument should be a ZstdDict object.");
57 return NULL;
58 }
59
60 /* Format error message and set ZstdError. */
61 void
62 set_zstd_error(const _zstd_state *state, error_type type, size_t zstd_ret)
63 {
64 const char *msg;
65 assert(ZSTD_isError(zstd_ret));
66
67 if (state == NULL) {
68 return;
69 }
70 switch (type) {
71 case ERR_DECOMPRESS:
72 msg = "Unable to decompress Zstandard data: %s";
73 break;
74 case ERR_COMPRESS:
75 msg = "Unable to compress Zstandard data: %s";
76 break;
77 case ERR_SET_PLEDGED_INPUT_SIZE:
78 msg = "Unable to set pledged uncompressed content size: %s";
79 break;
80
81 case ERR_LOAD_D_DICT:
82 msg = "Unable to load Zstandard dictionary or prefix for "
83 "decompression: %s";
84 break;
85 case ERR_LOAD_C_DICT:
86 msg = "Unable to load Zstandard dictionary or prefix for "
87 "compression: %s";
88 break;
89
90 case ERR_GET_C_BOUNDS:
91 msg = "Unable to get zstd compression parameter bounds: %s";
92 break;
93 case ERR_GET_D_BOUNDS:
94 msg = "Unable to get zstd decompression parameter bounds: %s";
95 break;
96 case ERR_SET_C_LEVEL:
97 msg = "Unable to set zstd compression level: %s";
98 break;
99
100 case ERR_TRAIN_DICT:
101 msg = "Unable to train the Zstandard dictionary: %s";
102 break;
103 case ERR_FINALIZE_DICT:
104 msg = "Unable to finalize the Zstandard dictionary: %s";
105 break;
106
107 default:
108 Py_UNREACHABLE();
109 }
110 PyErr_Format(state->ZstdError, msg, ZSTD_getErrorName(zstd_ret));
111 }
112
113 typedef struct {
114 int parameter;
115 char parameter_name[32];
116 } ParameterInfo;
117
118 static const ParameterInfo cp_list[] = {
119 {ZSTD_c_compressionLevel, "compression_level"},
120 {ZSTD_c_windowLog, "window_log"},
121 {ZSTD_c_hashLog, "hash_log"},
122 {ZSTD_c_chainLog, "chain_log"},
123 {ZSTD_c_searchLog, "search_log"},
124 {ZSTD_c_minMatch, "min_match"},
125 {ZSTD_c_targetLength, "target_length"},
126 {ZSTD_c_strategy, "strategy"},
127
128 {ZSTD_c_enableLongDistanceMatching, "enable_long_distance_matching"},
129 {ZSTD_c_ldmHashLog, "ldm_hash_log"},
130 {ZSTD_c_ldmMinMatch, "ldm_min_match"},
131 {ZSTD_c_ldmBucketSizeLog, "ldm_bucket_size_log"},
132 {ZSTD_c_ldmHashRateLog, "ldm_hash_rate_log"},
133
134 {ZSTD_c_contentSizeFlag, "content_size_flag"},
135 {ZSTD_c_checksumFlag, "checksum_flag"},
136 {ZSTD_c_dictIDFlag, "dict_id_flag"},
137
138 {ZSTD_c_nbWorkers, "nb_workers"},
139 {ZSTD_c_jobSize, "job_size"},
140 {ZSTD_c_overlapLog, "overlap_log"}
141 };
142
143 static const ParameterInfo dp_list[] = {
144 {ZSTD_d_windowLogMax, "window_log_max"}
145 };
146
147 void
148 set_parameter_error(int is_compress, int key_v, int value_v)
149 {
150 ParameterInfo const *list;
151 int list_size;
152 char *type;
153 ZSTD_bounds bounds;
154 char pos_msg[64];
155
156 if (is_compress) {
157 list = cp_list;
158 list_size = Py_ARRAY_LENGTH(cp_list);
159 type = "compression";
160 }
161 else {
162 list = dp_list;
163 list_size = Py_ARRAY_LENGTH(dp_list);
164 type = "decompression";
165 }
166
167 /* Find parameter's name */
168 char const *name = NULL;
169 for (int i = 0; i < list_size; i++) {
170 if (key_v == (list+i)->parameter) {
171 name = (list+i)->parameter_name;
172 break;
173 }
174 }
175
176 /* Unknown parameter */
177 if (name == NULL) {
178 PyOS_snprintf(pos_msg, sizeof(pos_msg),
179 "unknown parameter (key %d)", key_v);
180 name = pos_msg;
181 }
182
183 /* Get parameter bounds */
184 if (is_compress) {
185 bounds = ZSTD_cParam_getBounds(key_v);
186 }
187 else {
188 bounds = ZSTD_dParam_getBounds(key_v);
189 }
190 if (ZSTD_isError(bounds.error)) {
191 PyErr_Format(PyExc_ValueError, "invalid %s parameter '%s'",
192 type, name);
193 return;
194 }
195
196 /* Error message */
197 PyErr_Format(PyExc_ValueError,
198 "%s parameter '%s' received an illegal value %d; "
199 "the valid range is [%d, %d]",
200 type, name, value_v, bounds.lowerBound, bounds.upperBound);
201 }
202
203 static inline _zstd_state*
204 get_zstd_state(PyObject *module)
205 {
206 void *state = PyModule_GetState(module);
207 assert(state != NULL);
208 return (_zstd_state *)state;
209 }
210
211 static Py_ssize_t
212 calculate_samples_stats(PyBytesObject *samples_bytes, PyObject *samples_sizes,
213 size_t **chunk_sizes)
214 {
215 Py_ssize_t chunks_number;
216 Py_ssize_t sizes_sum;
217 Py_ssize_t i;
218
219 chunks_number = PyTuple_GET_SIZE(samples_sizes);
220 if ((size_t) chunks_number > UINT32_MAX) {
221 PyErr_Format(PyExc_ValueError,
222 "The number of samples should be <= %u.", UINT32_MAX);
223 return -1;
224 }
225
226 /* Prepare chunk_sizes */
227 *chunk_sizes = PyMem_New(size_t, chunks_number);
228 if (*chunk_sizes == NULL) {
229 PyErr_NoMemory();
230 return -1;
231 }
232
233 sizes_sum = PyBytes_GET_SIZE(samples_bytes);
234 for (i = 0; i < chunks_number; i++) {
235 size_t size = PyLong_AsSize_t(PyTuple_GET_ITEM(samples_sizes, i));
236 (*chunk_sizes)[i] = size;
237 if (size == (size_t)-1 && PyErr_Occurred()) {
238 if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
239 goto sum_error;
240 }
241 return -1;
242 }
243 if ((size_t)sizes_sum < size) {
244 goto sum_error;
245 }
246 sizes_sum -= size;
247 }
248
249 if (sizes_sum != 0) {
250 sum_error:
251 PyErr_SetString(PyExc_ValueError,
252 "The samples size tuple doesn't match the "
253 "concatenation's size.");
254 return -1;
255 }
256 return chunks_number;
257 }
258
259
260 /*[clinic input]
261 _zstd.train_dict
262
263 samples_bytes: PyBytesObject
264 Concatenation of samples.
265 samples_sizes: object(subclass_of='&PyTuple_Type')
266 Tuple of samples' sizes.
267 dict_size: Py_ssize_t
268 The size of the dictionary.
269 /
270
271 Train a Zstandard dictionary on sample data.
272 [clinic start generated code]*/
273
274 static PyObject *
275 _zstd_train_dict_impl(PyObject *module, PyBytesObject *samples_bytes,
276 PyObject *samples_sizes, Py_ssize_t dict_size)
277 /*[clinic end generated code: output=8e87fe43935e8f77 input=d20dedb21c72cb62]*/
278 {
279 PyObject *dst_dict_bytes = NULL;
280 size_t *chunk_sizes = NULL;
281 Py_ssize_t chunks_number;
282 size_t zstd_ret;
283
284 /* Check arguments */
285 if (dict_size <= 0) {
286 PyErr_SetString(PyExc_ValueError,
287 "dict_size argument should be positive number.");
288 return NULL;
289 }
290
291 /* Check that the samples are valid and get their sizes */
292 chunks_number = calculate_samples_stats(samples_bytes, samples_sizes,
293 &chunk_sizes);
294 if (chunks_number < 0) {
295 goto error;
296 }
297
298 /* Allocate dict buffer */
299 dst_dict_bytes = PyBytes_FromStringAndSize(NULL, dict_size);
300 if (dst_dict_bytes == NULL) {
301 goto error;
302 }
303
304 /* Train the dictionary */
305 char *dst_dict_buffer = PyBytes_AS_STRING(dst_dict_bytes);
306 const char *samples_buffer = PyBytes_AS_STRING(samples_bytes);
307 Py_BEGIN_ALLOW_THREADS
308 zstd_ret = ZDICT_trainFromBuffer(dst_dict_buffer, dict_size,
309 samples_buffer,
310 chunk_sizes, (uint32_t)chunks_number);
311 Py_END_ALLOW_THREADS
312
313 /* Check Zstandard dict error */
314 if (ZDICT_isError(zstd_ret)) {
315 _zstd_state* mod_state = get_zstd_state(module);
316 set_zstd_error(mod_state, ERR_TRAIN_DICT, zstd_ret);
317 goto error;
318 }
319
320 /* Resize dict_buffer */
321 if (_PyBytes_Resize(&dst_dict_bytes, zstd_ret) < 0) {
322 goto error;
323 }
324
325 goto success;
326
327 error:
328 Py_CLEAR(dst_dict_bytes);
329
330 success:
331 PyMem_Free(chunk_sizes);
332 return dst_dict_bytes;
333 }
334
335 /*[clinic input]
336 _zstd.finalize_dict
337
338 custom_dict_bytes: PyBytesObject
339 Custom dictionary content.
340 samples_bytes: PyBytesObject
341 Concatenation of samples.
342 samples_sizes: object(subclass_of='&PyTuple_Type')
343 Tuple of samples' sizes.
344 dict_size: Py_ssize_t
345 The size of the dictionary.
346 compression_level: int
347 Optimize for a specific Zstandard compression level, 0 means default.
348 /
349
350 Finalize a Zstandard dictionary.
351 [clinic start generated code]*/
352
353 static PyObject *
354 _zstd_finalize_dict_impl(PyObject *module, PyBytesObject *custom_dict_bytes,
355 PyBytesObject *samples_bytes,
356 PyObject *samples_sizes, Py_ssize_t dict_size,
357 int compression_level)
358 /*[clinic end generated code: output=f91821ba5ae85bda input=3c7e2480aa08fb56]*/
359 {
360 Py_ssize_t chunks_number;
361 size_t *chunk_sizes = NULL;
362 PyObject *dst_dict_bytes = NULL;
363 size_t zstd_ret;
364 ZDICT_params_t params;
365
366 /* Check arguments */
367 if (dict_size <= 0) {
368 PyErr_SetString(PyExc_ValueError,
369 "dict_size argument should be positive number.");
370 return NULL;
371 }
372
373 /* Check that the samples are valid and get their sizes */
374 chunks_number = calculate_samples_stats(samples_bytes, samples_sizes,
375 &chunk_sizes);
376 if (chunks_number < 0) {
377 goto error;
378 }
379
380 /* Allocate dict buffer */
381 dst_dict_bytes = PyBytes_FromStringAndSize(NULL, dict_size);
382 if (dst_dict_bytes == NULL) {
383 goto error;
384 }
385
386 /* Parameters */
387
388 /* Optimize for a specific Zstandard compression level, 0 means default. */
389 params.compressionLevel = compression_level;
390 /* Write log to stderr, 0 = none. */
391 params.notificationLevel = 0;
392 /* Force dictID value, 0 means auto mode (32-bits random value). */
393 params.dictID = 0;
394
395 /* Finalize the dictionary */
396 Py_BEGIN_ALLOW_THREADS
397 zstd_ret = ZDICT_finalizeDictionary(
398 PyBytes_AS_STRING(dst_dict_bytes), dict_size,
399 PyBytes_AS_STRING(custom_dict_bytes),
400 Py_SIZE(custom_dict_bytes),
401 PyBytes_AS_STRING(samples_bytes), chunk_sizes,
402 (uint32_t)chunks_number, params);
403 Py_END_ALLOW_THREADS
404
405 /* Check Zstandard dict error */
406 if (ZDICT_isError(zstd_ret)) {
407 _zstd_state* mod_state = get_zstd_state(module);
408 set_zstd_error(mod_state, ERR_FINALIZE_DICT, zstd_ret);
409 goto error;
410 }
411
412 /* Resize dict_buffer */
413 if (_PyBytes_Resize(&dst_dict_bytes, zstd_ret) < 0) {
414 goto error;
415 }
416
417 goto success;
418
419 error:
420 Py_CLEAR(dst_dict_bytes);
421
422 success:
423 PyMem_Free(chunk_sizes);
424 return dst_dict_bytes;
425 }
426
427
428 /*[clinic input]
429 _zstd.get_param_bounds
430
431 parameter: int
432 The parameter to get bounds.
433 is_compress: bool
434 True for CompressionParameter, False for DecompressionParameter.
435
436 Get CompressionParameter/DecompressionParameter bounds.
437 [clinic start generated code]*/
438
439 static PyObject *
440 _zstd_get_param_bounds_impl(PyObject *module, int parameter, int is_compress)
441 /*[clinic end generated code: output=4acf5a876f0620ca input=45742ef0a3531b65]*/
442 {
443 ZSTD_bounds bound;
444 if (is_compress) {
445 bound = ZSTD_cParam_getBounds(parameter);
446 if (ZSTD_isError(bound.error)) {
447 _zstd_state* mod_state = get_zstd_state(module);
448 set_zstd_error(mod_state, ERR_GET_C_BOUNDS, bound.error);
449 return NULL;
450 }
451 }
452 else {
453 bound = ZSTD_dParam_getBounds(parameter);
454 if (ZSTD_isError(bound.error)) {
455 _zstd_state* mod_state = get_zstd_state(module);
456 set_zstd_error(mod_state, ERR_GET_D_BOUNDS, bound.error);
457 return NULL;
458 }
459 }
460
461 return Py_BuildValue("ii", bound.lowerBound, bound.upperBound);
462 }
463
464 /*[clinic input]
465 _zstd.get_frame_size
466
467 frame_buffer: Py_buffer
468 A bytes-like object, it should start from the beginning of a frame,
469 and contains at least one complete frame.
470
471 Get the size of a Zstandard frame, including the header and optional checksum.
472 [clinic start generated code]*/
473
474 static PyObject *
475 _zstd_get_frame_size_impl(PyObject *module, Py_buffer *frame_buffer)
476 /*[clinic end generated code: output=a7384c2f8780f442 input=3b9f73f8c8129d38]*/
477 {
478 size_t frame_size;
479
480 frame_size = ZSTD_findFrameCompressedSize(frame_buffer->buf,
481 frame_buffer->len);
482 if (ZSTD_isError(frame_size)) {
483 _zstd_state* mod_state = get_zstd_state(module);
484 PyErr_Format(mod_state->ZstdError,
485 "Error when finding the compressed size of a Zstandard frame. "
486 "Ensure the frame_buffer argument starts from the "
487 "beginning of a frame, and its length is not less than this "
488 "complete frame. Zstd error message: %s.",
489 ZSTD_getErrorName(frame_size));
490 return NULL;
491 }
492
493 return PyLong_FromSize_t(frame_size);
494 }
495
496 /*[clinic input]
497 _zstd.get_frame_info
498
499 frame_buffer: Py_buffer
500 A bytes-like object, containing the header of a Zstandard frame.
501
502 Get Zstandard frame infomation from a frame header.
503 [clinic start generated code]*/
504
505 static PyObject *
506 _zstd_get_frame_info_impl(PyObject *module, Py_buffer *frame_buffer)
507 /*[clinic end generated code: output=56e033cf48001929 input=94b240583ae22ca5]*/
508 {
509 uint64_t decompressed_size;
510 uint32_t dict_id;
511
512 /* ZSTD_getFrameContentSize */
513 decompressed_size = ZSTD_getFrameContentSize(frame_buffer->buf,
514 frame_buffer->len);
515
516 /* #define ZSTD_CONTENTSIZE_UNKNOWN (0ULL - 1)
517 #define ZSTD_CONTENTSIZE_ERROR (0ULL - 2) */
518 if (decompressed_size == ZSTD_CONTENTSIZE_ERROR) {
519 _zstd_state* mod_state = get_zstd_state(module);
520 PyErr_SetString(mod_state->ZstdError,
521 "Error when getting information from the header of "
522 "a Zstandard frame. Ensure the frame_buffer argument "
523 "starts from the beginning of a frame, and its length "
524 "is not less than the frame header (6~18 bytes).");
525 return NULL;
526 }
527
528 /* ZSTD_getDictID_fromFrame */
529 dict_id = ZSTD_getDictID_fromFrame(frame_buffer->buf, frame_buffer->len);
530
531 /* Build tuple */
532 if (decompressed_size == ZSTD_CONTENTSIZE_UNKNOWN) {
533 return Py_BuildValue("OI", Py_None, dict_id);
534 }
535 return Py_BuildValue("KI", decompressed_size, dict_id);
536 }
537
538 /*[clinic input]
539 _zstd.set_parameter_types
540
541 c_parameter_type: object(subclass_of='&PyType_Type')
542 CompressionParameter IntEnum type object
543 d_parameter_type: object(subclass_of='&PyType_Type')
544 DecompressionParameter IntEnum type object
545
546 Set CompressionParameter and DecompressionParameter types for validity check.
547 [clinic start generated code]*/
548
549 static PyObject *
550 _zstd_set_parameter_types_impl(PyObject *module, PyObject *c_parameter_type,
551 PyObject *d_parameter_type)
552 /*[clinic end generated code: output=f3313b1294f19502 input=75d7a953580fae5f]*/
553 {
554 _zstd_state* mod_state = get_zstd_state(module);
555
556 Py_INCREF(c_parameter_type);
557 Py_XSETREF(mod_state->CParameter_type, (PyTypeObject*)c_parameter_type);
558 Py_INCREF(d_parameter_type);
559 Py_XSETREF(mod_state->DParameter_type, (PyTypeObject*)d_parameter_type);
560
561 Py_RETURN_NONE;
562 }
563
564 static PyMethodDef _zstd_methods[] = {
565 _ZSTD_TRAIN_DICT_METHODDEF
566 _ZSTD_FINALIZE_DICT_METHODDEF
567 _ZSTD_GET_PARAM_BOUNDS_METHODDEF
568 _ZSTD_GET_FRAME_SIZE_METHODDEF
569 _ZSTD_GET_FRAME_INFO_METHODDEF
570 _ZSTD_SET_PARAMETER_TYPES_METHODDEF
571 {NULL, NULL}
572 };
573
574 static int
575 _zstd_exec(PyObject *m)
576 {
577 #define ADD_TYPE(TYPE, SPEC) \
578 do { \
579 TYPE = (PyTypeObject *)PyType_FromModuleAndSpec(m, &(SPEC), NULL); \
580 if (TYPE == NULL) { \
581 return -1; \
582 } \
583 if (PyModule_AddType(m, TYPE) < 0) { \
584 return -1; \
585 } \
586 } while (0)
587
588 #define ADD_INT_MACRO(MACRO) \
589 if (PyModule_AddIntConstant((m), #MACRO, (MACRO)) < 0) { \
590 return -1; \
591 }
592
593 #define ADD_INT_CONST_TO_TYPE(TYPE, NAME, VALUE) \
594 do { \
595 PyObject *v = PyLong_FromLong((VALUE)); \
596 if (v == NULL || PyObject_SetAttrString((PyObject *)(TYPE), \
597 (NAME), v) < 0) { \
598 Py_XDECREF(v); \
599 return -1; \
600 } \
601 Py_DECREF(v); \
602 } while (0)
603
604 _zstd_state* mod_state = get_zstd_state(m);
605
606 /* Reusable objects & variables */
607 mod_state->CParameter_type = NULL;
608 mod_state->DParameter_type = NULL;
609
610 /* Create and add heap types */
611 ADD_TYPE(mod_state->ZstdDict_type, zstd_dict_type_spec);
612 ADD_TYPE(mod_state->ZstdCompressor_type, zstd_compressor_type_spec);
613 ADD_TYPE(mod_state->ZstdDecompressor_type, zstd_decompressor_type_spec);
614 mod_state->ZstdError = PyErr_NewExceptionWithDoc(
615 "backports.zstd.ZstdError",
616 "An error occurred in the zstd library.",
617 NULL, NULL);
618 if (mod_state->ZstdError == NULL) {
619 return -1;
620 }
621 if (PyModule_AddType(m, (PyTypeObject *)mod_state->ZstdError) < 0) {
622 return -1;
623 }
624
625 /* Add constants */
626 if (PyModule_AddIntConstant(m, "zstd_version_number",
627 ZSTD_versionNumber()) < 0) {
628 return -1;
629 }
630
631 if (PyModule_AddStringConstant(m, "zstd_version",
632 ZSTD_versionString()) < 0) {
633 return -1;
634 }
635
636 #if ZSTD_VERSION_NUMBER >= 10500
637 if (PyModule_AddIntConstant(m, "ZSTD_CLEVEL_DEFAULT",
638 ZSTD_defaultCLevel()) < 0) {
639 return -1;
640 }
641 #else
642 ADD_INT_MACRO(ZSTD_CLEVEL_DEFAULT);
643 #endif
644
645 if (PyModule_Add(m, "ZSTD_DStreamOutSize",
646 PyLong_FromSize_t(ZSTD_DStreamOutSize())) < 0) {
647 return -1;
648 }
649
650 /* Add zstd compression parameters. All should also be in cp_list. */
651 ADD_INT_MACRO(ZSTD_c_compressionLevel);
652 ADD_INT_MACRO(ZSTD_c_windowLog);
653 ADD_INT_MACRO(ZSTD_c_hashLog);
654 ADD_INT_MACRO(ZSTD_c_chainLog);
655 ADD_INT_MACRO(ZSTD_c_searchLog);
656 ADD_INT_MACRO(ZSTD_c_minMatch);
657 ADD_INT_MACRO(ZSTD_c_targetLength);
658 ADD_INT_MACRO(ZSTD_c_strategy);
659
660 ADD_INT_MACRO(ZSTD_c_enableLongDistanceMatching);
661 ADD_INT_MACRO(ZSTD_c_ldmHashLog);
662 ADD_INT_MACRO(ZSTD_c_ldmMinMatch);
663 ADD_INT_MACRO(ZSTD_c_ldmBucketSizeLog);
664 ADD_INT_MACRO(ZSTD_c_ldmHashRateLog);
665
666 ADD_INT_MACRO(ZSTD_c_contentSizeFlag);
667 ADD_INT_MACRO(ZSTD_c_checksumFlag);
668 ADD_INT_MACRO(ZSTD_c_dictIDFlag);
669
670 ADD_INT_MACRO(ZSTD_c_nbWorkers);
671 ADD_INT_MACRO(ZSTD_c_jobSize);
672 ADD_INT_MACRO(ZSTD_c_overlapLog);
673
674 /* Add zstd decompression parameters. All should also be in dp_list. */
675 ADD_INT_MACRO(ZSTD_d_windowLogMax);
676
677 /* Add ZSTD_strategy enum members */
678 ADD_INT_MACRO(ZSTD_fast);
679 ADD_INT_MACRO(ZSTD_dfast);
680 ADD_INT_MACRO(ZSTD_greedy);
681 ADD_INT_MACRO(ZSTD_lazy);
682 ADD_INT_MACRO(ZSTD_lazy2);
683 ADD_INT_MACRO(ZSTD_btlazy2);
684 ADD_INT_MACRO(ZSTD_btopt);
685 ADD_INT_MACRO(ZSTD_btultra);
686 ADD_INT_MACRO(ZSTD_btultra2);
687
688 /* Add ZSTD_EndDirective enum members to ZstdCompressor */
689 ADD_INT_CONST_TO_TYPE(mod_state->ZstdCompressor_type,
690 "CONTINUE", ZSTD_e_continue);
691 ADD_INT_CONST_TO_TYPE(mod_state->ZstdCompressor_type,
692 "FLUSH_BLOCK", ZSTD_e_flush);
693 ADD_INT_CONST_TO_TYPE(mod_state->ZstdCompressor_type,
694 "FLUSH_FRAME", ZSTD_e_end);
695
696 /* Make ZstdCompressor immutable (set Py_TPFLAGS_IMMUTABLETYPE) */
697 PyType_Freeze(mod_state->ZstdCompressor_type);
698
699 #undef ADD_TYPE
700 #undef ADD_INT_MACRO
701 #undef ADD_ZSTD_COMPRESSOR_INT_CONST
702
703 return 0;
704 }
705
706 static int
707 _zstd_traverse(PyObject *module, visitproc visit, void *arg)
708 {
709 _zstd_state* mod_state = get_zstd_state(module);
710
711 Py_VISIT(mod_state->ZstdDict_type);
712 Py_VISIT(mod_state->ZstdCompressor_type);
713
714 Py_VISIT(mod_state->ZstdDecompressor_type);
715
716 Py_VISIT(mod_state->ZstdError);
717
718 Py_VISIT(mod_state->CParameter_type);
719 Py_VISIT(mod_state->DParameter_type);
720 return 0;
721 }
722
723 static int
724 _zstd_clear(PyObject *module)
725 {
726 _zstd_state* mod_state = get_zstd_state(module);
727
728 Py_CLEAR(mod_state->ZstdDict_type);
729 Py_CLEAR(mod_state->ZstdCompressor_type);
730
731 Py_CLEAR(mod_state->ZstdDecompressor_type);
732
733 Py_CLEAR(mod_state->ZstdError);
734
735 Py_CLEAR(mod_state->CParameter_type);
736 Py_CLEAR(mod_state->DParameter_type);
737 return 0;
738 }
739
740 static void
741 _zstd_free(void *module)
742 {
743 (void)_zstd_clear((PyObject *)module);
744 }
745
746 static struct PyModuleDef_Slot _zstd_slots[] = {
747 {Py_mod_exec, _zstd_exec},
748 {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
749 {Py_mod_gil, Py_MOD_GIL_NOT_USED},
750 {0, NULL},
751 };
752
753 static struct PyModuleDef _zstdmodule = {
754 .m_base = PyModuleDef_HEAD_INIT,
755 .m_name = "_zstd",
756 .m_doc = "Implementation module for Zstandard compression.",
757 .m_size = sizeof(_zstd_state),
758 .m_slots = _zstd_slots,
759 .m_methods = _zstd_methods,
760 .m_traverse = _zstd_traverse,
761 .m_clear = _zstd_clear,
762 .m_free = _zstd_free,
763 };
764
765 PyMODINIT_FUNC
766 PyInit__zstd(void)
767 {
768 return PyModuleDef_Init(&_zstdmodule);
769 }