winloop 0.8.1__tar.gz → 0.8.3__tar.gz

{winloop-0.8.1 → winloop-0.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: winloop
-Version: 0.8.1
+Version: 0.8.3
 Summary: Windows version of uvloop
 Author-email: Vizonex <VizonexBusiness@gmail.com>
 License: MIT License
@@ -37,7 +37,7 @@ Requires-Dist: mypy>=0.800; extra == "test"
 Provides-Extra: dev
 Requires-Dist: packaging; extra == "dev"
 Requires-Dist: setuptools>=60; extra == "dev"
-Requires-Dist: Cython==3.3.0; extra == "dev"
+Requires-Dist: Cython==3.3.1; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: Sphinx<9.2.0,>=4.1.2; extra == "docs"
 Requires-Dist: sphinxcontrib-asyncio~=0.3.0; extra == "docs"
@@ -81,6 +81,14 @@ to compile this library on your own.
 python setup.py build_ext --inplace
 ```
 
+To link against a libuv you already have (for example from a package manager) instead of the bundled copy, pass `--use-system-libuv`. The build asks the linker for `uv` by name, so its headers and library must be on the compiler's include and linker search paths. The option is on by default under MinGW. It has no effect on non-MinGW Windows builds, which always compile the bundled libuv:
+
+```
+python setup.py build_ext --use-system-libuv --inplace
+```
+
+On Windows with MSVC, `INCLUDE` and `LIB` must point at libuv's include and lib directories. The result links `uv.lib` and needs `uv.dll` at run time. Python 3.8 and later ignore `PATH` when loading an extension's dependencies, so call `os.add_dll_directory` on the libuv `bin` directory before importing winloop, or copy `uv.dll` beside the extension.
+
 ## Testing with UV
 The __uv__ package manager is the preferred method for testing __winloop__ and it's author uses `ruff` and `uv` by default.
 

{winloop-0.8.1 → winloop-0.8.3}/README.md

@@ -35,6 +35,14 @@ to compile this library on your own.
 python setup.py build_ext --inplace
 ```
 
+To link against a libuv you already have (for example from a package manager) instead of the bundled copy, pass `--use-system-libuv`. The build asks the linker for `uv` by name, so its headers and library must be on the compiler's include and linker search paths. The option is on by default under MinGW. It has no effect on non-MinGW Windows builds, which always compile the bundled libuv:
+
+```
+python setup.py build_ext --use-system-libuv --inplace
+```
+
+On Windows with MSVC, `INCLUDE` and `LIB` must point at libuv's include and lib directories. The result links `uv.lib` and needs `uv.dll` at run time. Python 3.8 and later ignore `PATH` when loading an extension's dependencies, so call `os.add_dll_directory` on the libuv `bin` directory before importing winloop, or copy `uv.dll` beside the extension.
+
 ## Testing with UV
 The __uv__ package manager is the preferred method for testing __winloop__ and it's author uses `ruff` and `uv` by default.
 

{winloop-0.8.1 → winloop-0.8.3}/pyproject.toml

@@ -50,7 +50,7 @@ test = [
 dev = [
     'packaging',
     'setuptools>=60',
-    'Cython==3.3.0',
+    'Cython==3.3.1',
 ]
 docs = [
     'Sphinx>=4.1.2,<9.2.0',
@@ -63,7 +63,7 @@ requires = [
     "packaging",
     "setuptools>=60",
     "wheel",
-    "Cython==3.3.0",
+    "Cython==3.3.1",
 ]
 build-backend = "setuptools.build_meta"
 

{winloop-0.8.1 → winloop-0.8.3}/setup.py

@@ -212,12 +212,18 @@ class uvloop_build_ext(build_ext):
 
     def build_extensions(self):
         if sys.platform == "win32" and not MINGW:
-            path = pathlib.Path("vendor", "libuv", "src")
-            c_files = [p.as_posix() for p in path.iterdir() if p.suffix == ".c"]
-            c_files += [
-                p.as_posix() for p in (path / "win").iterdir() if p.suffix == ".c"
-            ]
-            self.extensions[-1].sources += c_files
+            if self.use_system_libuv:
+                # MSVC finds uv.h and uv.lib through INCLUDE and LIB.
+                ext = self.extensions[-1]
+                ext.include_dirs = [d for d in ext.include_dirs if not d.startswith("vendor/libuv")]
+                ext.extra_link_args.append("uv.lib")
+            else:
+                path = pathlib.Path("vendor", "libuv", "src")
+                c_files = [p.as_posix() for p in path.iterdir() if p.suffix == ".c"]
+                c_files += [
+                    p.as_posix() for p in (path / "win").iterdir() if p.suffix == ".c"
+                ]
+                self.extensions[-1].sources += c_files
             super().build_extensions()
             return
 

{winloop-0.8.1 → winloop-0.8.3}/tests/test_base.py

@@ -754,6 +754,59 @@ class _TestBase:
         # For Python 3.8-10 it takes much longer, say 64 seconds,
         # maybe because h.cancel above does not work somehow.
 
+    def test_call_soon_threadsafe_while_closing(self):
+        # SEE: https://github.com/MagicStack/uvloop/pull/789/changes
+        # Other threads post to loops that close at the same time.  On
+        # free-threaded Python this used to crash in call_soon_threadsafe()
+        # (handler_async was already None) or make close() fail.
+        OWNERS = 2
+        POSTERS = 4
+        stop = threading.Event()
+        loops = [None] * OWNERS
+        errors = []
+
+        def owner(i):
+            try:
+                while not stop.is_set():
+                    loop = self.new_loop()
+                    loops[i] = loop
+                    try:
+                        loop.call_later(0.0005, loop.stop)
+                        loop.run_forever()
+                    finally:
+                        loop.close()
+            except BaseException as ex:
+                errors.append(ex)
+
+        def poster(i):
+            n = 0
+            try:
+                while not stop.is_set():
+                    loop = loops[n % OWNERS]
+                    n += 1
+                    if loop is None:
+                        continue
+                    try:
+                        loop.call_soon_threadsafe(lambda: None)
+                    except RuntimeError as ex:
+                        if str(ex) != 'Event loop is closed':
+                            raise
+            except BaseException as ex:
+                errors.append(ex)
+
+        threads = [threading.Thread(target=owner, args=(i,), daemon=True)
+                   for i in range(OWNERS)]
+        threads += [threading.Thread(target=poster, args=(i,), daemon=True)
+                    for i in range(POSTERS)]
+        for t in threads:
+            t.start()
+        time.sleep(1)
+        stop.set()
+        for t in threads:
+            t.join(10)
+        self.assertFalse([t for t in threads if t.is_alive()],
+                         'threads hang, likely a deadlock')
+        self.assertEqual(errors, [])
 
 class TestBaseUV(_TestBase, UVTestCase):
     def test_loop_create_future(self):

{winloop-0.8.1 → winloop-0.8.3}/tests/test_context.py

@@ -6,12 +6,17 @@ import random
 import socket
 import ssl
 import sys
+import sysconfig
 import tempfile
 import unittest
 import weakref
 
 from winloop import _testbase as tb
 
+# Needed for a deadlock bug that is actually unrelated to uvloop/winloop they work
+# just fine. It's actually python's asyncio loop that is at fault.
+is_freethreaded_build = bool(sysconfig.get_config_var("Py_GIL_DISABLED"))
+
 
 class _BaseProtocol(asyncio.BaseProtocol):
     def __init__(self, cvar, *, loop=None):
@@ -406,6 +411,12 @@ class _ContextBaseTests(tb.SSLTestCase):
         self._run_server_test(test, async_sock=True)
 
     def test_create_ssl_server_connection_protocol(self):
+        if isinstance(self, Test_AIO_Context) and is_freethreaded_build:
+            raise unittest.SkipTest(
+                "3.14t and 3.15t are victim to a " \
+                "freezing bug in pure python asyncio."
+            )
+
         async def test(cvar, proto, ssl_sock, **_):
             def resume_reading(transport):
                 cvar.set("resume_reading")