Add py free-threaded support

Modernize testing (-> re-enable tests on Windows)

PiperOrigin-RevId: 830892275

Author: eustas

.github/workflows/build_test.yml

@@ -133,12 +133,22 @@ jobs:
             c_compiler: clang
             cxx_compiler: clang++
 
-          - name: python3.10-win
+          - name: python3.14:clang
             build_system: python
-            python_version: "3.10"
-            # TODO: investigate why win-builds can't run tests
-            py_setuptools_cmd: build_ext
-            os: windows-2022
+            python_version: "3.14"
+            c_compiler: clang
+            cxx_compiler: clang++
+
+          - name: python3.14t:clang
+            build_system: python
+            python_version: "3.14t"
+            c_compiler: clang
+            cxx_compiler: clang++
+
+          - name: python3.14-win
+            build_system: python
+            python_version: "3.14"
+            os: windows-latest
 
           - name: maven
             build_system: maven
@@ -332,9 +342,9 @@ jobs:
       if: ${{ matrix.build_system == 'python' }}
       run: |
         python -VV
-        python -c "import sys; sys.exit('Invalid python version') if '.'.join(map(str,sys.version_info[0:2])) != '${{ matrix.python_version }}' else True"
-        pip install setuptools==51.3.3
-        python setup.py ${{ matrix.py_setuptools_cmd || 'test'}}
+        pip install "setuptools>=70.0.0" pytest
+        python setup.py build_ext --inplace
+        pytest ./python/tests
 
   build_test_dotnet:
     name: Build and test with .NET

.github/workflows/codeql.yml

@@ -71,6 +71,8 @@ jobs:
     - if: matrix.language == 'cpp' || matrix.language == 'python'
       name: Build Python
       run: |
+        python -VV
+        pip install "setuptools>=70.0.0"
         python setup.py build_ext
 
     - name: Perform CodeQL Analysis

python/_brotli.c

@@ -22,6 +22,28 @@
 #error "Only Python 3.10+ is supported"
 #endif
 
+/*
+Decoder / encoder nature does not support concurrent access. Attempt to enter
+concurrently will result in an exception.
+
+"Critical" parts used in prologues to ensure that only one thread enters.
+For consistency, we use them in epilogues as well. "Critical" is essential for
+free-threaded. In GIL environment those rendered as a scope (i.e. `{` and `}`).
+
+NB: `Py_BEGIN_ALLOW_THREADS` / `Py_END_ALLOW_THREADS` are still required to
+unblock the stop-the-world  GC.
+*/
+#ifdef Py_GIL_DISABLED
+#if PY_MAJOR_VERSION < 3 || (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION < 13)
+#error "Critical sections are only available in Python 3.13+"
+#endif
+#define BROTLI_CRITICAL_START Py_BEGIN_CRITICAL_SECTION(self)
+#define BROTLI_CRITICAL_END Py_END_CRITICAL_SECTION()
+#else
+#define BROTLI_CRITICAL_START {
+#define BROTLI_CRITICAL_END }
+#endif
+
 static const char kErrorAttr[] = "error";
 static const char kModuleAttr[] = "_module";
 
@@ -522,13 +544,22 @@ static PyObject* brotli_Compressor_process(PyBrotli_Compressor* self,
   PyObject* ret = NULL;
   PyObject* input_object = NULL;
   Py_buffer input;
+  int ok = 1;
 
+  BROTLI_CRITICAL_START;
   if (self->healthy == 0) {
     set_brotli_exception(self_type, kCompressUnhealthyError);
-    return NULL;
+    ok = 0;
   }
   if (self->processing != 0) {
     set_brotli_exception(self_type, kCompressConcurrentError);
+    ok = 0;
+  }
+  if (ok) {
+    self->processing = 1;
+  }
+  BROTLI_CRITICAL_END;
+  if (!ok) {
     return NULL;
   }
 
@@ -539,49 +570,76 @@ static PyObject* brotli_Compressor_process(PyBrotli_Compressor* self,
     return NULL;
   }
 
-  self->processing = 1;
   ret = compress_stream(self, BROTLI_OPERATION_PROCESS, (uint8_t*)input.buf,
                         input.len);
   PyBuffer_Release(&input);
+
+  BROTLI_CRITICAL_START;
   self->processing = 0;
+  BROTLI_CRITICAL_END;
+
   return ret;
 }
 
 static PyObject* brotli_Compressor_flush(PyBrotli_Compressor* self) {
   PyObject* self_type = (PyObject*)Py_TYPE((PyObject*)self);
   PyObject* ret = NULL;
+  int ok = 1;
 
+  BROTLI_CRITICAL_START;
   if (self->healthy == 0) {
     set_brotli_exception(self_type, kCompressUnhealthyError);
-    return NULL;
+    ok = 0;
   }
   if (self->processing != 0) {
     set_brotli_exception(self_type, kCompressConcurrentError);
+    ok = 0;
+  }
+  if (ok) {
+    self->processing = 1;
+  }
+  BROTLI_CRITICAL_END;
+  if (!ok) {
     return NULL;
   }
 
-  self->processing = 1;
   ret = compress_stream(self, BROTLI_OPERATION_FLUSH, NULL, 0);
+
+  BROTLI_CRITICAL_START;
   self->processing = 0;
+  BROTLI_CRITICAL_END;
+
   return ret;
 }
 
 static PyObject* brotli_Compressor_finish(PyBrotli_Compressor* self) {
   PyObject* self_type = (PyObject*)Py_TYPE((PyObject*)self);
   PyObject* ret = NULL;
+  int ok = 1;
 
+  BROTLI_CRITICAL_START;
   if (self->healthy == 0) {
     set_brotli_exception(self_type, kCompressUnhealthyError);
-    return NULL;
+    ok = 0;
   }
   if (self->processing != 0) {
     set_brotli_exception(self_type, kCompressConcurrentError);
+    ok = 0;
+  }
+  if (ok) {
+    self->processing = 1;
+  }
+  BROTLI_CRITICAL_END;
+  if (!ok) {
     return NULL;
   }
 
-  self->processing = 1;
   ret = compress_stream(self, BROTLI_OPERATION_FINISH, NULL, 0);
+
+  BROTLI_CRITICAL_START;
   self->processing = 0;
+  BROTLI_CRITICAL_END;
+
   if (ret != NULL) {
     assert(BrotliEncoderIsFinished(self->enc));
   }
@@ -664,13 +722,22 @@ static PyObject* brotli_Decompressor_process(PyBrotli_Decompressor* self,
   uint8_t* new_tail = NULL;
   size_t new_tail_length = 0;
   int oom = 0;
+  int ok = 1;
 
+  BROTLI_CRITICAL_START;
   if (self->healthy == 0) {
     set_brotli_exception(self_type, kDecompressUnhealthyError);
-    return NULL;
+    ok = 0;
   }
   if (self->processing != 0) {
     set_brotli_exception(self_type, kDecompressConcurrentError);
+    ok = 0;
+  }
+  if (ok) {
+    self->processing = 1;
+  }
+  BROTLI_CRITICAL_END;
+  if (!ok) {
     return NULL;
   }
 
@@ -683,7 +750,6 @@ static PyObject* brotli_Decompressor_process(PyBrotli_Decompressor* self,
   }
 
   Buffer_Init(&buffer);
-  self->processing = 1;
 
   if (self->unconsumed_data_length > 0) {
     if (input.len > 0) {
@@ -759,17 +825,22 @@ static PyObject* brotli_Decompressor_process(PyBrotli_Decompressor* self,
   }
   PyBuffer_Release(&input);
   Buffer_Cleanup(&buffer);
+
+  ok = (PyErr_Occurred() == NULL) ? 1 : 0;
+  BROTLI_CRITICAL_START;
   if (self->unconsumed_data) {
     free(self->unconsumed_data);
     self->unconsumed_data = NULL;
   }
   self->unconsumed_data = new_tail;
   self->unconsumed_data_length = new_tail_length;
-  if (PyErr_Occurred() != NULL) {
+  if (!ok) {
     assert(ret == NULL);
     self->healthy = 0;
   }
   self->processing = 0;
+  BROTLI_CRITICAL_END;
+
   return ret;
 }
 
@@ -1003,7 +1074,9 @@ static PyMethodDef brotli_methods[] = {
 
 static PyModuleDef_Slot brotli_mod_slots[] = {
     {Py_mod_exec, brotli_init_mod},
-#if (PY_MAJOR_VERSION > 3) || (PY_MINOR_VERSION >= 12)
+#ifdef Py_GIL_DISABLED
+    {Py_mod_gil, Py_MOD_GIL_NOT_USED},
+#elif (PY_MAJOR_VERSION > 3) || (PY_MINOR_VERSION >= 12)
     {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
 #endif
     {0, NULL}};