winloop 0.1.1__tar.gz → 0.1.3__tar.gz

{winloop-0.1.1/winloop.egg-info → winloop-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: winloop
-Version: 0.1.1
+Version: 0.1.3
 Summary: An alternative library for uvloop compatibility with Windows
 Author: Vizonex
 License: MIT
@@ -17,32 +17,42 @@ License-File: LICENSE-MIT
 Requires-Dist: cython
 
 <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
-An Alternative library for uvloop compatability with windows because let's face it. Window's python asyncio is garabage escpecially when Windows Defender eats up half your ram. 
-I never really liked the fact that I couldn't make anything run faster escpecially when you have fiber internet connections in place and you've done all the optimizations you could possibly think of. It always felt disappointing when `libuv` is avalible on windows but doesn't have [compatability with uvloop at all.](https://github.com/MagicStack/uvloop/issues/14#issuecomment-575826367])
+An Alternative library for uvloop compatability with windows because let's face it. Window's python asyncio standard libaray is garabage escpecially when Windows Defender decides to eat half your ram. 
+I never really liked the fact that I couldn't make anything run faster escpecially when you have fiber internet connections in place and you've done all the optimizations you could possibly think of. It always felt disappointing when `libuv` is avalible for windows [but windows was never compatable with uvloop.](https://github.com/MagicStack/uvloop/issues/14#issuecomment-575826367])
 
-Because nobody was willing to step in after so many years of people waiting , I went ahead and downloaded the uvloop source code and modified the source code to be windows compatable by carefully removing and changing parts that were not made for windows, many hours of research went into making this library exist. 
+Because nobody was willing to step in after so many years of waiting, I went ahead and downloaded the source code for uvloop and started modifying the source code to be windows compatable by carefully removing and changing parts that were not made for windows. Many hours of research went into making this library exist. 
 
-The differences with __uvloop__ is that forking has been fully disabled and some smaller api calls had to be changed. Subprocesses instead release the gil instead of forking out although I might change that in the future if handling asynchronous subprocesses becomes a problem to handle...
+The differences with __uvloop__ is that forking has been fully disabled and some smaller api calls had to be changed, error handling has been carefully modified and subprocesses instead release the gil instead of forking out...
 
+There is a perfromance increase of about 5 times vs using the `WindowsSelectorEventLoopPolicy` and `WindowsProactorEventLoopPolicy` which have been known to trigger ssl problems in `python 3.9`. Winloop is a very good replacement for solving those ssl problem as well. This library also has comparable performace to it's brother uvloop. 
 
-There is a perfromance increase of about 5 times vs using the `WindowsSelectorEventLoopPolicy` and `WindowsProactorEventLoopPolicy` which have been known to trigger ssl problems in python 3.9. Winloop is a very good replacement for those ssl problem as well.
 
-
-## How to install Winloop on your Operating System
+## How to install Winloop on your Windows Operating System
 
 ```
 pip install winloop
 ```
 
-you can also clone the reposity and build the extension yourself by running the command below if you wish to use or build this library locally
+You can also clone the reposity and build the extension yourself by running the command below if you wish to use or build this library locally, Note that you will need Cython and The Visual C++ extensions 
+to compile this library on your own. 
 
 ```
 python setup.py build_ext --inplace 
 ```
 
-If you find any sneaky bugs with this library be sure to open up an issue to our github repo. Me and other contributors will be happy to help you figure out and diagnose your problems.
+## Issues Reporting
+
+If you find any bugs with this library be sure to open up an issue to our github repo. Me and other contributors will be happy try to help you figure out and diagnose your problems.
+
+## Making pull requests 
+We encourage anyone to make pull-requests to winloop from spelling mistakes to vulnerability patches. Every little bit helps keep this library maintained and alive.
+Make sure that you are able to compile the library with the steps shown above. We plan to implement a nightly workflow to verify one's pull request in the future.
+
+
+
 
 ```python
 try:
@@ -243,37 +253,37 @@ async def main():
 
 if __name__ == "__main__":
     if sys.platform in ('win32', 'cygwin', 'cli'):
-        from winloop import install
+        from winloop import run
     else:
         # if we're on apple or linux do this instead
-        from uvloop import install 
-    install()
-    asyncio.run(main())
+        from uvloop import run 
+    run(main())
   ```
   
   
- ## Possible Upcomming Features/Optimizations to Winloop / This is also our TODO list
-I have been looking deeply into some of the proposed Pulls and changes to `Uvloop` and I will be tuning in and listening to what's going on uvloop's end to see what we might have to change . This is a list of features I would like to implement from likely to least likely to be done as well as solved. If any of these feature have been added you will simply know by the fact that It won't be on this list anymore...
+ ## TODO-List
 
-- Drop All `DEF` Macros, I'm currently seeking help on replacements for macros where all the variables are known about at compile-time
-
-- Make a sucessful Github Workflow for uploading wheels to pypi any help and guidence would be appreciated 
+- Update Fastapi Example to a more recent version of fastapi
 
-- delete loop.c on install once the code has been compiled to a `.pyd` file since `loop.c` becomes 8 Microbytes (8MB) of waste at that point (yeah it's very big). Users don't need a file this big escpecailly for those who are diskspace sensetive like myself.
+- Contact uvicorn about this [issue](https://github.com/Vizonex/Winloop/issues/11) I have a funny feeling something is going on here...
 
-- Adding in the nessesary hooks for pyinstaller to compile this fast library to executable code even though hooks have been known to inflate the size of the `.exe` files. This is because calling hidden-imports for all the `__init__.py` modules might annoy some developers. (Luckily I'm aware of this issue because I've been doing this myself...)
+- Nightly Builds And Test Suite Workflows for anyone wanting to use newer unreleased versions.
 
-- Drop custom Socketpair function inside of `socketpair.h` in replacement for libvs's function until we can better understand how its need to be implemented so that we can make it go a bit deeper to be a bit more quick at creating sockets , the assert checks might be dropped as long as there's no problems with it. I'll be sure to reupload the dropped `socketpair.h` code of mine into a gist if anyone still wanted to go ahead and use it elsewhere although it may have many bugs of it's own which was my original reason for not using it when I discovered that libuv had it's own socketpair functions for windows...
+- Drop All `DEF` Macros, I'm currently seeking help on replacements for macros where all the variables are known about at compile-time
 
-- Easier Error Diagnosis to code even though I've found that most errors are not arising from winloop's own code and it is being triggered from elsewhere (This is a good thing but makes it harder to tell where other devs mess up) in fact, winloop actually passes more tests than python's asyncio event loop policies do. This might just be both a blessing and a curse for us...
+- Adding in the nessesary hooks for pyinstaller to compile this fast library to executable code even though hooks have been known to inflate the size of the `.exe` files. This is because calling hidden-imports for all the `__init__.py` modules might annoy some developers. (Luckily I'm aware of this issue because I've been doing this myself...)
 
-- Maybe Drop and then re-join the gil after the subprocess is first spawned in instead of joining before being killed off by the end user (This will need to be accompanied by some heavy unittesting no doubt)
+- write a workflow for compiling libuv on different versions of windows when distributing out pypi wheels.
 
-- Optimzing TCP Connections as well as sending data in `streams.pyx` with the uv bites are finally dropped in the try write portions of our library. Currently uv bites is just there as a protection measure by me, this will be dropped in the future since the try_write block has some subprocess checks as well as long as it doesn't have subprocess behaviors I'm alright with upgrading `streams.pyx` as long as it doesn't break. I did leave my plan uncommented for right now but the other half belonging to subprocesses looks rather steep/deep.
+- write a workflow for nightly builds if nessesary for verification of pull requests.
 
-- drop the `.lib` file for compiling libuv in replacement for libuv's C files directly once the current compiling problems and errors have been solved.
+- Sphinx Styled Documentation (Maybe I'm thinking about it...)
 
+- Update benchmarks (They are old) can't belive I maintained this project for over a year now...
 
 ## Videos
 - By me: https://www.youtube.com/watch?v=tz9RYJ6aBZ8  (I might make a tutorial on how to use and install winloop it for those who have reading problems)
 - My Presentation and Virtual Confrence: https://www.youtube.com/watch?v=Cbb6trkKWXY 
+
+## Contributing
+I put my heart and soul into this library ever since it began and any help is apperciated and means a lot to me. 

{winloop-0.1.1 → winloop-0.1.3}/README.md

@@ -1,30 +1,40 @@
 <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
-An Alternative library for uvloop compatability with windows because let's face it. Window's python asyncio is garabage escpecially when Windows Defender eats up half your ram. 
-I never really liked the fact that I couldn't make anything run faster escpecially when you have fiber internet connections in place and you've done all the optimizations you could possibly think of. It always felt disappointing when `libuv` is avalible on windows but doesn't have [compatability with uvloop at all.](https://github.com/MagicStack/uvloop/issues/14#issuecomment-575826367])
+An Alternative library for uvloop compatability with windows because let's face it. Window's python asyncio standard libaray is garabage escpecially when Windows Defender decides to eat half your ram. 
+I never really liked the fact that I couldn't make anything run faster escpecially when you have fiber internet connections in place and you've done all the optimizations you could possibly think of. It always felt disappointing when `libuv` is avalible for windows [but windows was never compatable with uvloop.](https://github.com/MagicStack/uvloop/issues/14#issuecomment-575826367])
 
-Because nobody was willing to step in after so many years of people waiting , I went ahead and downloaded the uvloop source code and modified the source code to be windows compatable by carefully removing and changing parts that were not made for windows, many hours of research went into making this library exist. 
+Because nobody was willing to step in after so many years of waiting, I went ahead and downloaded the source code for uvloop and started modifying the source code to be windows compatable by carefully removing and changing parts that were not made for windows. Many hours of research went into making this library exist. 
 
-The differences with __uvloop__ is that forking has been fully disabled and some smaller api calls had to be changed. Subprocesses instead release the gil instead of forking out although I might change that in the future if handling asynchronous subprocesses becomes a problem to handle...
+The differences with __uvloop__ is that forking has been fully disabled and some smaller api calls had to be changed, error handling has been carefully modified and subprocesses instead release the gil instead of forking out...
 
+There is a perfromance increase of about 5 times vs using the `WindowsSelectorEventLoopPolicy` and `WindowsProactorEventLoopPolicy` which have been known to trigger ssl problems in `python 3.9`. Winloop is a very good replacement for solving those ssl problem as well. This library also has comparable performace to it's brother uvloop. 
 
-There is a perfromance increase of about 5 times vs using the `WindowsSelectorEventLoopPolicy` and `WindowsProactorEventLoopPolicy` which have been known to trigger ssl problems in python 3.9. Winloop is a very good replacement for those ssl problem as well.
 
-
-## How to install Winloop on your Operating System
+## How to install Winloop on your Windows Operating System
 
 ```
 pip install winloop
 ```
 
-you can also clone the reposity and build the extension yourself by running the command below if you wish to use or build this library locally
+You can also clone the reposity and build the extension yourself by running the command below if you wish to use or build this library locally, Note that you will need Cython and The Visual C++ extensions 
+to compile this library on your own. 
 
 ```
 python setup.py build_ext --inplace 
 ```
 
-If you find any sneaky bugs with this library be sure to open up an issue to our github repo. Me and other contributors will be happy to help you figure out and diagnose your problems.
+## Issues Reporting
+
+If you find any bugs with this library be sure to open up an issue to our github repo. Me and other contributors will be happy try to help you figure out and diagnose your problems.
+
+## Making pull requests 
+We encourage anyone to make pull-requests to winloop from spelling mistakes to vulnerability patches. Every little bit helps keep this library maintained and alive.
+Make sure that you are able to compile the library with the steps shown above. We plan to implement a nightly workflow to verify one's pull request in the future.
+
+
+
 
 ```python
 try:
@@ -225,37 +235,37 @@ async def main():
 
 if __name__ == "__main__":
     if sys.platform in ('win32', 'cygwin', 'cli'):
-        from winloop import install
+        from winloop import run
     else:
         # if we're on apple or linux do this instead
-        from uvloop import install 
-    install()
-    asyncio.run(main())
+        from uvloop import run 
+    run(main())
   ```
   
   
- ## Possible Upcomming Features/Optimizations to Winloop / This is also our TODO list
-I have been looking deeply into some of the proposed Pulls and changes to `Uvloop` and I will be tuning in and listening to what's going on uvloop's end to see what we might have to change . This is a list of features I would like to implement from likely to least likely to be done as well as solved. If any of these feature have been added you will simply know by the fact that It won't be on this list anymore...
+ ## TODO-List
 
-- Drop All `DEF` Macros, I'm currently seeking help on replacements for macros where all the variables are known about at compile-time
-
-- Make a sucessful Github Workflow for uploading wheels to pypi any help and guidence would be appreciated 
+- Update Fastapi Example to a more recent version of fastapi
 
-- delete loop.c on install once the code has been compiled to a `.pyd` file since `loop.c` becomes 8 Microbytes (8MB) of waste at that point (yeah it's very big). Users don't need a file this big escpecailly for those who are diskspace sensetive like myself.
+- Contact uvicorn about this [issue](https://github.com/Vizonex/Winloop/issues/11) I have a funny feeling something is going on here...
 
-- Adding in the nessesary hooks for pyinstaller to compile this fast library to executable code even though hooks have been known to inflate the size of the `.exe` files. This is because calling hidden-imports for all the `__init__.py` modules might annoy some developers. (Luckily I'm aware of this issue because I've been doing this myself...)
+- Nightly Builds And Test Suite Workflows for anyone wanting to use newer unreleased versions.
 
-- Drop custom Socketpair function inside of `socketpair.h` in replacement for libvs's function until we can better understand how its need to be implemented so that we can make it go a bit deeper to be a bit more quick at creating sockets , the assert checks might be dropped as long as there's no problems with it. I'll be sure to reupload the dropped `socketpair.h` code of mine into a gist if anyone still wanted to go ahead and use it elsewhere although it may have many bugs of it's own which was my original reason for not using it when I discovered that libuv had it's own socketpair functions for windows...
+- Drop All `DEF` Macros, I'm currently seeking help on replacements for macros where all the variables are known about at compile-time
 
-- Easier Error Diagnosis to code even though I've found that most errors are not arising from winloop's own code and it is being triggered from elsewhere (This is a good thing but makes it harder to tell where other devs mess up) in fact, winloop actually passes more tests than python's asyncio event loop policies do. This might just be both a blessing and a curse for us...
+- Adding in the nessesary hooks for pyinstaller to compile this fast library to executable code even though hooks have been known to inflate the size of the `.exe` files. This is because calling hidden-imports for all the `__init__.py` modules might annoy some developers. (Luckily I'm aware of this issue because I've been doing this myself...)
 
-- Maybe Drop and then re-join the gil after the subprocess is first spawned in instead of joining before being killed off by the end user (This will need to be accompanied by some heavy unittesting no doubt)
+- write a workflow for compiling libuv on different versions of windows when distributing out pypi wheels.
 
-- Optimzing TCP Connections as well as sending data in `streams.pyx` with the uv bites are finally dropped in the try write portions of our library. Currently uv bites is just there as a protection measure by me, this will be dropped in the future since the try_write block has some subprocess checks as well as long as it doesn't have subprocess behaviors I'm alright with upgrading `streams.pyx` as long as it doesn't break. I did leave my plan uncommented for right now but the other half belonging to subprocesses looks rather steep/deep.
+- write a workflow for nightly builds if nessesary for verification of pull requests.
 
-- drop the `.lib` file for compiling libuv in replacement for libuv's C files directly once the current compiling problems and errors have been solved.
+- Sphinx Styled Documentation (Maybe I'm thinking about it...)
 
+- Update benchmarks (They are old) can't belive I maintained this project for over a year now...
 
 ## Videos
 - By me: https://www.youtube.com/watch?v=tz9RYJ6aBZ8  (I might make a tutorial on how to use and install winloop it for those who have reading problems)
 - My Presentation and Virtual Confrence: https://www.youtube.com/watch?v=Cbb6trkKWXY 
+
+## Contributing
+I put my heart and soul into this library ever since it began and any help is apperciated and means a lot to me. 

{winloop-0.1.1 → winloop-0.1.3}/setup.py

@@ -7,9 +7,18 @@ from Cython.Build import cythonize
 
 
 HERE = pathlib.Path("winloop")
+_ROOT = pathlib.Path(__file__).parent
 
-__version__ = "0.1.1"
 
+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')
 
 
 # This is a temporary test Solution and is not the official file yet but this is to display/show what 
@@ -54,7 +63,7 @@ def do_installation():
     setup(
         name="winloop",
         author="Vizonex",
-        version=__version__,
+        version=VERSION,
         description="""An alternative library for uvloop compatibility with Windows""",
         ext_modules=cythonize(ext),
         license="MIT",

winloop-0.1.3/tests/__init__.py

@@ -0,0 +1 @@
+# It's just here as a stub...

winloop-0.1.3/tests/__main__.py

@@ -0,0 +1,16 @@
+import os.path
+import sys
+import unittest
+import unittest.runner
+
+
+def suite():
+    test_loader = unittest.TestLoader()
+    test_suite = test_loader.discover(os.path.dirname(__file__))
+    return test_suite
+
+
+if __name__ == '__main__':
+    runner = unittest.runner.TextTestRunner()
+    result = runner.run(suite())
+    sys.exit(not result.wasSuccessful())

winloop-0.1.3/tests/test_aiodns.py

@@ -0,0 +1,41 @@
+# NOTE: I forked the aiodns Repository you will have to use that for now 
+# or wait for the pull request I recently made to go through: https://github.com/saghul/aiodns/pull/116
+
+try:
+    import aiodns
+except ImportError:
+    skip_tests = True
+else:
+    skip_tests = False
+
+import asyncio
+import sys
+import unittest
+import weakref
+
+from winloop import _testbase as tb
+
+
+class _TestAiodns:
+    def test_dns_query(self):
+        # This is not allowed to fail...
+        resolver = aiodns.DNSResolver(loop=self.loop)
+
+        async def test():
+            async def query(name, query_type):
+                return await resolver.query(name, query_type)
+            await query('google.com', 'A')
+            await query('httpbin.org', 'A')
+            await query('example.com', 'A')
+
+        self.loop.run_until_complete(test())
+
+
+@unittest.skipIf(skip_tests, "no aiodns module")
+class Test_UV_Aiodns(_TestAiodns, tb.UVTestCase):
+    pass
+
+
+@unittest.skip("aiodns needs a SelectorEventLoop on Windows. See more: https://github.com/saghul/aiodns/issues/86")
+class Test_AIO_Aiodns(_TestAiodns, tb.AIOTestCase):
+    pass

winloop-0.1.3/tests/test_aiohttp.py

@@ -0,0 +1,131 @@
+try:
+    import aiohttp
+    import aiohttp.web
+except ImportError:
+    skip_tests = True
+else:
+    skip_tests = False
+
+import asyncio
+import sys
+import unittest
+import weakref
+
+from winloop import _testbase as tb
+
+# TODO: Fix or patch DeprecationWarning
+
+class _TestAioHTTP:
+
+    def test_aiohttp_basic_1(self):
+
+        PAYLOAD = '<h1>It Works!</h1>' * 10000
+
+        async def on_request(request):
+            return aiohttp.web.Response(text=PAYLOAD)
+
+        asyncio.set_event_loop(self.loop)
+        app = aiohttp.web.Application()
+        app.router.add_get('/', on_request)
+
+        runner = aiohttp.web.AppRunner(app)
+        self.loop.run_until_complete(runner.setup())
+        site = aiohttp.web.TCPSite(runner, '0.0.0.0', '0')
+        self.loop.run_until_complete(site.start())
+        port = site._server.sockets[0].getsockname()[1]
+
+        async def test():
+            # Make sure we're using the correct event loop.
+            self.assertIs(asyncio.get_event_loop(), self.loop)
+
+            for addr in (('localhost', port),
+                         ('127.0.0.1', port)):
+                async with aiohttp.ClientSession() as client:
+                    async with client.get('http://{}:{}'.format(*addr)) as r:
+                        self.assertEqual(r.status, 200)
+                        result = await r.text()
+                        self.assertEqual(result, PAYLOAD)
+
+        self.loop.run_until_complete(test())
+        self.loop.run_until_complete(runner.cleanup())
+
+    def test_aiohttp_graceful_shutdown(self):
+        # NOTE: This Might Already be solved I haven't checked yet - Vizonex
+        if self.implementation == 'asyncio' and sys.version_info >= (3, 12, 0):
+            # In Python 3.12.0, asyncio.Server.wait_closed() waits for all
+            # existing connections to complete, before aiohttp sends
+            # on_shutdown signals.
+            # https://github.com/aio-libs/aiohttp/issues/7675#issuecomment-1752143748
+            # https://github.com/python/cpython/pull/98582
+            raise unittest.SkipTest('bug in aiohttp: #7675')
+
+        async def websocket_handler(request):
+            ws = aiohttp.web.WebSocketResponse()
+            await ws.prepare(request)
+            request.app['websockets'].add(ws)
+            try:
+                async for msg in ws:
+                    await ws.send_str(msg.data)
+            finally:
+                request.app['websockets'].discard(ws)
+            return ws
+
+        async def on_shutdown(app):
+            for ws in set(app['websockets']):
+                await ws.close(
+                    code=aiohttp.WSCloseCode.GOING_AWAY,
+                    message='Server shutdown')
+
+        asyncio.set_event_loop(self.loop)
+        app = aiohttp.web.Application()
+        app.router.add_get('/', websocket_handler)
+        app.on_shutdown.append(on_shutdown)
+        app['websockets'] = weakref.WeakSet()
+
+        runner = aiohttp.web.AppRunner(app)
+        self.loop.run_until_complete(runner.setup())
+        site = aiohttp.web.TCPSite(
+            runner,
+            '0.0.0.0',
+            0,
+            # https://github.com/aio-libs/aiohttp/pull/7188
+            shutdown_timeout=0.1,
+        )
+        self.loop.run_until_complete(site.start())
+        port = site._server.sockets[0].getsockname()[1]
+
+        async def client():
+            async with aiohttp.ClientSession() as client:
+                async with client.ws_connect(
+                        'http://127.0.0.1:{}'.format(port)) as ws:
+                    await ws.send_str("hello")
+                    async for msg in ws:
+                        assert msg.data == "hello"
+
+        client_task = asyncio.ensure_future(client())
+
+        async def stop():
+            await asyncio.sleep(0.1)
+            try:
+                await asyncio.wait_for(runner.cleanup(), timeout=0.5)
+            finally:
+                try:
+                    client_task.cancel()
+                    await client_task
+                except asyncio.CancelledError:
+                    pass
+
+        self.loop.run_until_complete(stop())
+
+
+@unittest.skipIf(skip_tests, "no aiohttp module")
+class Test_UV_AioHTTP(_TestAioHTTP, tb.UVTestCase):
+    pass
+
+
+@unittest.skipIf(skip_tests, "no aiohttp module")
+class Test_AIO_AioHTTP(_TestAioHTTP, tb.AIOTestCase):
+    pass
+
+if __name__ == "__main__":
+    unittest.main()

winloop-0.1.3/tests/test_aiomultiprocess.py

@@ -0,0 +1,60 @@
+try:
+    import aiomultiprocess, multiprocessing
+except ImportError:
+    skip_tests = True
+else:
+    skip_tests = False
+import unittest
+import winloop
+import random
+import asyncio
+import os
+from winloop import _testbase as tb
+
+
+async def test_func(sleep: float):
+    return await asyncio.sleep(sleep) 
+
+def my_map():
+    return [random.uniform(0.005, 1) for _ in range(7)]
+
+class _Test_Multiprocessing():
+    """Used for Testing aiomultiprocessing"""
+
+    def test_proccess_spawning(self):
+        
+        # See: https://github.com/Vizonex/Winloop/issues/11#issuecomment-1922659521
+        self.processes = set()
+        # There must be at least 2 pids setup for this to be correctly ran...
+        total_proccesses = 2
+        
+        async def test():
+            async with aiomultiprocess.Pool(total_proccesses) as pool:
+                self.processes.update(p.pid for p in pool.processes)
+                await pool.map(test_func, my_map())
+            await asyncio.sleep(0.005)
+            self.assertEqual(len(self.processes), total_proccesses)
+
+        self.loop.run_until_complete(test())
+        
+       
+
+
+@unittest.skipIf(skip_tests, "no aiomultiproccess module")
+class Test_UV_AioMultiprocess(_Test_Multiprocessing, tb.UVTestCase):
+    pass
+
+
+@unittest.skipIf(skip_tests, "no aiomultiproccess module")
+class Test_AIO_AioMultiprocess(_Test_Multiprocessing, tb.AIOTestCase):
+    pass
+
+
+if __name__ == "__main__":
+    # I have confirmed that multiproccessing is supported so no need to continue with trying... - Vizonex...
+    multiprocessing.freeze_support()
+    # aiomultiprocess.set_start_method("spawn")
+    winloop.install()
+    unittest.main()
+
+

winloop-0.1.3/tests/test_cython.py

@@ -0,0 +1,32 @@
+import asyncio
+from winloop._testbase import UVTestCase
+
+class TestCythonIntegration(UVTestCase):
+    def test_cython_coro_is_coroutine(self):
+        from winloop.loop import _test_coroutine_1
+        from asyncio.coroutines import _format_coroutine
+
+        coro = _test_coroutine_1()
+
+        coro_fmt = _format_coroutine(coro)
+        self.assertTrue(
+            coro_fmt.startswith("_test_coroutine_1() done")
+            or coro_fmt.startswith("_test_coroutine_1() running")
+        )
+        self.assertEqual(_test_coroutine_1.__qualname__, "_test_coroutine_1")
+        self.assertEqual(_test_coroutine_1.__name__, "_test_coroutine_1")
+        self.assertTrue(asyncio.iscoroutine(coro))
+        fut = asyncio.ensure_future(coro)
+        self.assertTrue(isinstance(fut, asyncio.Future))
+        self.assertTrue(isinstance(fut, asyncio.Task))
+        fut.cancel()
+
+        with self.assertRaises(asyncio.CancelledError):
+            self.loop.run_until_complete(fut)
+
+        try:
+            _format_coroutine(coro)  # This line checks against Cython segfault
+        except TypeError:
+            # TODO: Fix Cython to not reset __name__/__qualname__ to None
+            pass
+        coro.close()

winloop-0.1.3/tests/test_executors.py

@@ -0,0 +1,43 @@
+import asyncio
+import concurrent.futures
+import multiprocessing
+import unittest
+
+from winloop import _testbase as tb
+
+
+def fib(n):
+    if n < 2:
+        return 1
+    return fib(n - 2) + fib(n - 1)
+
+
+class _TestExecutors:
+    def run_pool_test(self, pool_factory):
+        async def run():
+            pool = pool_factory()
+            with pool:
+                coros = []
+                for i in range(0, 10):
+                    coros.append(self.loop.run_in_executor(pool, fib, i))
+                res = await asyncio.gather(*coros)
+            self.assertEqual(res, fib10)
+            await asyncio.sleep(0.01)
+
+        fib10 = [fib(i) for i in range(10)]
+        self.loop.run_until_complete(run())
+
+    # Proccess Pool Works just fine...
+    def test_executors_process_pool_01(self):
+        self.run_pool_test(concurrent.futures.ProcessPoolExecutor)
+
+    def test_executors_process_pool_02(self):
+        self.run_pool_test(concurrent.futures.ThreadPoolExecutor)
+
+
+class TestUVExecutors(_TestExecutors, tb.UVTestCase):
+    pass
+
+
+class TestAIOExecutors(_TestExecutors, tb.AIOTestCase):
+    pass