winloop 0.1.4__tar.gz → 0.1.5__tar.gz

{winloop-0.1.4/winloop.egg-info → winloop-0.1.5}/PKG-INFO

@@ -1,22 +1,44 @@
 Metadata-Version: 2.1
 Name: winloop
-Version: 0.1.4
+Version: 0.1.5
 Summary: Windows version of uvloop
 Author: Vizonex
-Keywords: winloop,libuv,windows,fast-asyncio,uvloop-alternative
+License: MIT License
+Project-URL: github, https://github.com/Vizonex/Winloop
+Keywords: asyncio,networking
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: Intended Audience :: Developers
-Classifier: Framework :: AsyncIO
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.8.0
 Description-Content-Type: text/markdown
 License-File: LICENSE-APACHE
 License-File: LICENSE-MIT
+Provides-Extra: test
+Requires-Dist: aiohttp>=3.8.1; python_version < "3.12" and extra == "test"
+Requires-Dist: aiohttp==3.9.0b0; python_version >= "3.12" and extra == "test"
+Requires-Dist: flake8~=5.0; extra == "test"
+Requires-Dist: psutil; extra == "test"
+Requires-Dist: pycodestyle~=2.9.0; extra == "test"
+Requires-Dist: pyOpenSSL~=23.0.0; extra == "test"
+Requires-Dist: mypy>=0.800; extra == "test"
+Requires-Dist: Cython<0.30.0,>=0.29.36; extra == "test"
+Provides-Extra: docs
+Requires-Dist: Sphinx~=4.1.2; extra == "docs"
+Requires-Dist: sphinxcontrib-asyncio~=0.3.0; extra == "docs"
+Requires-Dist: sphinx_rtd_theme~=0.5.2; extra == "docs"
 
 <img src="https://raw.githubusercontent.com/Vizonex/Winloop/main/winloop.png" width="200px"/>
 <a href="https://github.com/psf/black"><img alt="Code style: black" src="https://img.shields.io/badge/code%20style-black-000000.svg"></a>

winloop-0.1.5/pyproject.toml

@@ -0,0 +1,79 @@
+[project]
+name = "winloop"
+description = "Windows version of uvloop"
+authors = [{name = "Vizonex"}]
+requires-python = '>=3.8.0'
+readme = "README.md"
+license = {text = "MIT License"}
+dynamic = ["version"]
+keywords = [
+    "asyncio",
+    "networking",
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Framework :: AsyncIO",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: POSIX",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Topic :: System :: Networking",
+]
+
+[project.urls]
+github = "https://github.com/Vizonex/Winloop"
+
+[project.optional-dependencies]
+test = [
+    # pycodestyle is a dependency of flake8, but it must be frozen because
+    # their combination breaks too often
+    # (example breakage: https://gitlab.com/pycqa/flake8/issues/427)
+    'aiohttp>=3.8.1; python_version < "3.12"',
+    'aiohttp==3.9.0b0; python_version >= "3.12"',
+    'flake8~=5.0',
+    'psutil',
+    'pycodestyle~=2.9.0',
+    'pyOpenSSL~=23.0.0',
+    'mypy>=0.800',
+    'Cython(>=0.29.36,<0.30.0)',
+]
+docs = [
+    'Sphinx~=4.1.2',
+    'sphinxcontrib-asyncio~=0.3.0',
+    'sphinx_rtd_theme~=0.5.2',
+]
+
+[build-system]
+requires = [
+    "setuptools>=60",
+    "wheel",
+    "Cython(>=0.29.36,<0.30.0)",
+]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+zip-safe = false
+packages = ["winloop"]
+
+[tool.setuptools.exclude-package-data]
+"*" = ["*.c", "*.h"]
+
+[tool.cibuildwheel]
+build-frontend = "build"
+# Winloop comment: skip tests for now ("ImportError: cannot import name 'includes' from ... " in GitHub action)
+#test-extras = "test"
+#test-command = "python -m unittest discover -v {project}/tests"
+
+[tool.pytest.ini_options]
+addopts = "--capture=no --assert=plain --strict-markers --tb=native --import-mode=importlib"
+testpaths = "tests"
+filterwarnings = "default"

winloop-0.1.5/setup.py

@@ -0,0 +1,289 @@
+import sys
+
+vi = sys.version_info
+if vi < (3, 8):
+    raise RuntimeError('winloop requires Python 3.8 or greater')
+
+# Winloop comment: winloop now supports both Windows and non-Windows.
+# Below uvloop's setup.py is merged with winloop's previous setup.py.
+
+import os
+import os.path
+import pathlib
+import platform
+import re
+import shutil
+import subprocess
+
+from setuptools import setup, Extension
+from setuptools.command.build_ext import build_ext
+from setuptools.command.sdist import sdist
+
+
+CYTHON_DEPENDENCY = 'Cython(>=0.29.36,<0.30.0)'
+MACHINE = platform.machine()
+MODULES_CFLAGS = [os.getenv('UVLOOP_OPT_CFLAGS', '-O2')]
+_ROOT = pathlib.Path(__file__).parent
+LIBUV_DIR = str(_ROOT / 'vendor' / 'libuv')
+LIBUV_BUILD_DIR = str(_ROOT / 'build' / 'libuv-{}'.format(MACHINE))
+
+
+def _libuv_build_env():
+    env = os.environ.copy()
+
+    cur_cflags = env.get('CFLAGS', '')
+    if not re.search(r'-O\d', cur_cflags):
+        cur_cflags += ' -O2'
+
+    env['CFLAGS'] = (cur_cflags + ' -fPIC ' + env.get('ARCHFLAGS', ''))
+
+    return env
+
+
+def _libuv_autogen(env):
+    if os.path.exists(os.path.join(LIBUV_DIR, 'configure')):
+        # No need to use autogen, the configure script is there.
+        return
+
+    if not os.path.exists(os.path.join(LIBUV_DIR, 'autogen.sh')):
+        raise RuntimeError(
+            'the libuv submodule has not been checked out; '
+            'try running "git submodule init; git submodule update"')
+
+    subprocess.run(
+        ['/bin/sh', 'autogen.sh'], cwd=LIBUV_DIR, env=env, check=True)
+
+
+class uvloop_sdist(sdist):
+    def run(self):
+        if sys.platform != 'win32':
+            # Make sure sdist archive contains configure
+            # to avoid the dependency on autotools.
+            _libuv_autogen(_libuv_build_env())
+        super().run()
+
+
+class uvloop_build_ext(build_ext):
+    user_options = build_ext.user_options + [
+        ('cython-always', None,
+            'run cythonize() even if .c files are present'),
+        ('cython-annotate', None,
+            'Produce a colorized HTML version of the Cython source.'),
+        ('cython-directives=', None,
+            'Cythion compiler directives'),
+        ('use-system-libuv', None,
+            'Use the system provided libuv, instead of the bundled one'),
+    ]
+
+    boolean_options = build_ext.boolean_options + [
+        'cython-always',
+        'cython-annotate',
+        'use-system-libuv',
+    ]
+
+    def initialize_options(self):
+        super().initialize_options()
+        self.use_system_libuv = False
+        self.cython_always = False
+        self.cython_annotate = None
+        self.cython_directives = None
+
+    def finalize_options(self):
+        need_cythonize = self.cython_always
+        cfiles = {}
+
+        for extension in self.distribution.ext_modules:
+            for i, sfile in enumerate(extension.sources):
+                if sfile.endswith('.pyx'):
+                    prefix, ext = os.path.splitext(sfile)
+                    cfile = prefix + '.c'
+
+                    if os.path.exists(cfile) and not self.cython_always:
+                        extension.sources[i] = cfile
+                    else:
+                        if os.path.exists(cfile):
+                            cfiles[cfile] = os.path.getmtime(cfile)
+                        else:
+                            cfiles[cfile] = 0
+                        need_cythonize = True
+
+        if need_cythonize:
+            import pkg_resources
+
+            # Double check Cython presence in case setup_requires
+            # didn't go into effect (most likely because someone
+            # imported Cython before setup_requires injected the
+            # correct egg into sys.path.
+            try:
+                import Cython
+            except ImportError:
+                raise RuntimeError(
+                    'please install {} to compile uvloop from source'.format(
+                        CYTHON_DEPENDENCY))
+
+            cython_dep = pkg_resources.Requirement.parse(CYTHON_DEPENDENCY)
+            if Cython.__version__ not in cython_dep:
+                raise RuntimeError(
+                    'uvloop requires {}, got Cython=={}'.format(
+                        CYTHON_DEPENDENCY, Cython.__version__
+                    ))
+
+            from Cython.Build import cythonize
+
+            directives = {}
+            if self.cython_directives:
+                for directive in self.cython_directives.split(','):
+                    k, _, v = directive.partition('=')
+                    if v.lower() == 'false':
+                        v = False
+                    if v.lower() == 'true':
+                        v = True
+
+                    directives[k] = v
+
+            self.distribution.ext_modules[:] = cythonize(
+                self.distribution.ext_modules,
+                compiler_directives=directives,
+                annotate=self.cython_annotate)
+
+        super().finalize_options()
+
+    def build_libuv(self):
+        env = _libuv_build_env()
+
+        # Make sure configure and friends are present in case
+        # we are building from a git checkout.
+        _libuv_autogen(env)
+
+        # Copy the libuv tree to build/ so that its build
+        # products don't pollute sdist accidentally.
+        if os.path.exists(LIBUV_BUILD_DIR):
+            shutil.rmtree(LIBUV_BUILD_DIR)
+        shutil.copytree(LIBUV_DIR, LIBUV_BUILD_DIR)
+
+        # Sometimes pip fails to preserve the timestamps correctly,
+        # in which case, make will try to run autotools again.
+        subprocess.run(
+            ['touch', 'configure.ac', 'aclocal.m4', 'configure',
+             'Makefile.am', 'Makefile.in'],
+            cwd=LIBUV_BUILD_DIR, env=env, check=True)
+
+        if 'LIBUV_CONFIGURE_HOST' in env:
+            cmd = ['./configure', '--host=' + env['LIBUV_CONFIGURE_HOST']]
+        else:
+            cmd = ['./configure']
+        subprocess.run(
+            cmd,
+            cwd=LIBUV_BUILD_DIR, env=env, check=True)
+
+        j_flag = '-j{}'.format(os.cpu_count() or 1)
+        c_flag = "CFLAGS={}".format(env['CFLAGS'])
+        subprocess.run(
+            ['make', j_flag, c_flag],
+            cwd=LIBUV_BUILD_DIR, env=env, check=True)
+
+    def build_extensions(self):
+        if sys.platform == 'win32':
+            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
+
+        if self.use_system_libuv:
+            self.compiler.add_library('uv')
+
+            if sys.platform == 'darwin' and \
+                    os.path.exists('/opt/local/include'):
+                # Support macports on Mac OS X.
+                self.compiler.add_include_dir('/opt/local/include')
+        else:
+            libuv_lib = os.path.join(LIBUV_BUILD_DIR, '.libs', 'libuv.a')
+            if not os.path.exists(libuv_lib):
+                self.build_libuv()
+            if not os.path.exists(libuv_lib):
+                raise RuntimeError('failed to build libuv')
+
+            self.extensions[-1].extra_objects.extend([libuv_lib])
+            self.compiler.add_include_dir(os.path.join(LIBUV_DIR, 'include'))
+
+        if sys.platform.startswith('linux'):
+            self.compiler.add_library('rt')
+        elif sys.platform.startswith(('freebsd', 'dragonfly')):
+            self.compiler.add_library('kvm')
+        elif sys.platform.startswith('sunos'):
+            self.compiler.add_library('kstat')
+
+        self.compiler.add_library('pthread')
+
+        super().build_extensions()
+
+
+with open(str(_ROOT / 'winloop' / '_version.py')) as f:
+    for line in f:
+        if line.startswith('__version__ ='):
+            _, _, version = line.partition('=')
+            VERSION = version.strip(" \n'\"")
+            break
+    else:
+        raise RuntimeError(
+            'unable to read the version from winloop/_version.py')
+
+
+if sys.platform == 'win32':
+    from Cython.Build import cythonize
+    ext = cythonize([
+        Extension(
+            "winloop.loop",
+            sources=[
+                "winloop/loop.pyx"
+            ],
+            include_dirs=[
+                "vendor/libuv/src",
+                "vendor/libuv/src/win",
+                "vendor/libuv/include"
+            ],
+            extra_link_args=[  # subset of libuv Windows libraries
+                "Shell32.lib",
+                "Ws2_32.lib",
+                "Advapi32.lib",
+                "iphlpapi.lib",
+                "Userenv.lib",
+                "User32.lib",
+                "Dbghelp.lib",
+                "Ole32.lib"
+            ],
+            define_macros=[
+                ("WIN32_LEAN_AND_MEAN", 1),
+                ("_WIN32_WINNT", "0x0602")
+            ]
+        )
+    ])
+else:
+    ext = [
+            Extension(
+                "winloop.loop",
+                sources=[
+                    "winloop/loop.pyx",
+                ],
+                extra_compile_args=MODULES_CFLAGS
+            ),
+        ]
+
+setup_requires = []
+
+if not (_ROOT / 'winloop' / 'loop.c').exists() or '--cython-always' in sys.argv:
+    # No Cython output, require Cython to build.
+    setup_requires.append(CYTHON_DEPENDENCY)
+
+
+setup(
+    version=VERSION,
+    cmdclass={
+        'sdist': uvloop_sdist,
+        'build_ext': uvloop_build_ext
+    },
+    ext_modules=ext,
+    setup_requires=setup_requires
+)

winloop-0.1.5/tests/test_fs_event.py

@@ -0,0 +1,105 @@
+import asyncio
+import os.path
+import tempfile
+
+from winloop import _testbase as tb
+from winloop.loop import FileSystemEvent
+
+
+class Test_UV_FS_EVENT_CHANGE(tb.UVTestCase):
+    async def _file_writer(self):
+        f = await self.q.get()
+        while True:
+            f.write('hello uvloop\n')
+            f.flush()
+            # Winloop comment: insertion of os.fsync() call
+            # needed on Windows (Windows 10, Windows 11) to
+            # trigger change events; also works with Linux,
+            # but need to double check this.
+            os.fsync(f.fileno())
+            x = await self.q.get()
+            if x is None:
+                return
+
+    def fs_event_setup(self):
+        self.change_event_count = 0
+        self.fname = ''
+        self.q = asyncio.Queue()
+
+    def event_cb(self, ev_fname: bytes, evt: FileSystemEvent):
+        _d, fn = os.path.split(self.fname)
+        self.assertEqual(ev_fname, fn)
+        self.assertEqual(evt, FileSystemEvent.CHANGE)
+        self.change_event_count += 1
+        if self.change_event_count < 4:
+            self.q.put_nowait(0)
+        else:
+            self.q.put_nowait(None)
+
+    def test_fs_event_change(self):
+        self.fs_event_setup()
+
+        async def run(write_task):
+            self.q.put_nowait(tf)
+            try:
+                await asyncio.wait_for(write_task, 4)
+            except asyncio.TimeoutError:
+                write_task.cancel()
+
+        with tempfile.NamedTemporaryFile('wt') as tf:
+            self.fname = tf.name.encode()
+            h = self.loop._monitor_fs(tf.name, self.event_cb)
+            self.assertFalse(h.cancelled())
+
+            self.loop.run_until_complete(run(
+                self.loop.create_task(self._file_writer())))
+            h.cancel()
+            self.assertTrue(h.cancelled())
+
+        self.assertEqual(self.change_event_count, 4)
+
+
+class Test_UV_FS_EVENT_RENAME(tb.UVTestCase):
+    async def _file_renamer(self):
+        await self.q.get()
+        os.rename(os.path.join(self.dname, self.changed_name),
+                  os.path.join(self.dname, self.changed_name + "-new"))
+        await self.q.get()
+
+    def fs_event_setup(self):
+        self.dname = ''
+        self.changed_name = "hello_fs_event.txt"
+        self.changed_set = {self.changed_name, self.changed_name + '-new'}
+        self.q = asyncio.Queue()
+
+    def event_cb(self, ev_fname: bytes, evt: FileSystemEvent):
+        ev_fname = ev_fname.decode()
+        self.assertEqual(evt, FileSystemEvent.RENAME)
+        self.changed_set.remove(ev_fname)
+        if len(self.changed_set) == 0:
+            self.q.put_nowait(None)
+
+    def test_fs_event_rename(self):
+        self.fs_event_setup()
+
+        async def run(write_task):
+            self.q.put_nowait(0)
+            try:
+                await asyncio.wait_for(write_task, 4)
+            except asyncio.TimeoutError:
+                write_task.cancel()
+
+        with tempfile.TemporaryDirectory() as td_name:
+            self.dname = td_name
+            f = open(os.path.join(td_name, self.changed_name), 'wt')
+            f.write('hello!')
+            f.close()
+            h = self.loop._monitor_fs(td_name, self.event_cb)
+            self.assertFalse(h.cancelled())
+
+            self.loop.run_until_complete(run(
+                self.loop.create_task(self._file_renamer())))
+            h.cancel()
+            self.assertTrue(h.cancelled())
+
+        self.assertEqual(len(self.changed_set), 0)