uvloop-0.8.0/ 0000775 0001750 0001750 00000000000 13047177422 013716 5 ustar travis travis 0000000 0000000 uvloop-0.8.0/tests/ 0000775 0001750 0001750 00000000000 13047177422 015060 5 ustar travis travis 0000000 0000000 uvloop-0.8.0/tests/test_unix.py 0000664 0001750 0001750 00000043462 13047176662 017472 0 ustar travis travis 0000000 0000000 import asyncio
import os
import socket
import tempfile
import unittest
from uvloop import _testbase as tb
class _TestUnix:
def test_create_unix_server_1(self):
CNT = 0 # number of clients that were successful
TOTAL_CNT = 100 # total number of clients that test will create
TIMEOUT = 5.0 # timeout for this test
async def handle_client(reader, writer):
nonlocal CNT
data = await reader.readexactly(4)
self.assertEqual(data, b'AAAA')
writer.write(b'OK')
data = await reader.readexactly(4)
self.assertEqual(data, b'BBBB')
writer.write(b'SPAM')
await writer.drain()
writer.close()
CNT += 1
async def test_client(addr):
sock = socket.socket(socket.AF_UNIX)
with sock:
sock.setblocking(False)
await self.loop.sock_connect(sock, addr)
await self.loop.sock_sendall(sock, b'AAAA')
buf = b''
while len(buf) != 2:
buf += await self.loop.sock_recv(sock, 1)
self.assertEqual(buf, b'OK')
await self.loop.sock_sendall(sock, b'BBBB')
buf = b''
while len(buf) != 4:
buf += await self.loop.sock_recv(sock, 1)
self.assertEqual(buf, b'SPAM')
async def start_server():
nonlocal CNT
CNT = 0
with tempfile.TemporaryDirectory() as td:
sock_name = os.path.join(td, 'sock')
srv = await asyncio.start_unix_server(
handle_client,
sock_name,
loop=self.loop)
try:
srv_socks = srv.sockets
self.assertTrue(srv_socks)
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(test_client(sock_name))
await asyncio.wait_for(
asyncio.gather(*tasks, loop=self.loop),
TIMEOUT, loop=self.loop)
finally:
self.loop.call_soon(srv.close)
await srv.wait_closed()
# Check that the server cleaned-up proxy-sockets
for srv_sock in srv_socks:
self.assertEqual(srv_sock.fileno(), -1)
# asyncio doesn't cleanup the sock file
self.assertTrue(os.path.exists(sock_name))
async def start_server_sock(start_server):
nonlocal CNT
CNT = 0
with tempfile.TemporaryDirectory() as td:
sock_name = os.path.join(td, 'sock')
sock = socket.socket(socket.AF_UNIX)
sock.bind(sock_name)
srv = await start_server(sock)
try:
srv_socks = srv.sockets
self.assertTrue(srv_socks)
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(test_client(sock_name))
await asyncio.wait_for(
asyncio.gather(*tasks, loop=self.loop),
TIMEOUT, loop=self.loop)
finally:
self.loop.call_soon(srv.close)
await srv.wait_closed()
# Check that the server cleaned-up proxy-sockets
for srv_sock in srv_socks:
self.assertEqual(srv_sock.fileno(), -1)
# asyncio doesn't cleanup the sock file
self.assertTrue(os.path.exists(sock_name))
with self.subTest(func='start_unix_server(host, port)'):
self.loop.run_until_complete(start_server())
self.assertEqual(CNT, TOTAL_CNT)
with self.subTest(func='start_unix_server(sock)'):
self.loop.run_until_complete(start_server_sock(
lambda sock: asyncio.start_unix_server(
handle_client,
None,
loop=self.loop,
sock=sock)))
self.assertEqual(CNT, TOTAL_CNT)
with self.subTest(func='start_server(sock)'):
self.loop.run_until_complete(start_server_sock(
lambda sock: asyncio.start_server(
handle_client,
None, None,
loop=self.loop,
sock=sock)))
self.assertEqual(CNT, TOTAL_CNT)
def test_create_unix_server_2(self):
with tempfile.TemporaryDirectory() as td:
sock_name = os.path.join(td, 'sock')
with open(sock_name, 'wt') as f:
f.write('x')
with self.assertRaisesRegex(
OSError, "Address '{}' is already in use".format(
sock_name)):
self.loop.run_until_complete(
self.loop.create_unix_server(object, sock_name))
def test_create_unix_connection_1(self):
CNT = 0
TOTAL_CNT = 100
def server():
data = yield tb.read(4)
self.assertEqual(data, b'AAAA')
yield tb.write(b'OK')
data = yield tb.read(4)
self.assertEqual(data, b'BBBB')
yield tb.write(b'SPAM')
async def client(addr):
reader, writer = await asyncio.open_unix_connection(
addr,
loop=self.loop)
writer.write(b'AAAA')
self.assertEqual(await reader.readexactly(2), b'OK')
writer.write(b'BBBB')
self.assertEqual(await reader.readexactly(4), b'SPAM')
nonlocal CNT
CNT += 1
writer.close()
async def client_2(addr):
sock = socket.socket(socket.AF_UNIX)
sock.connect(addr)
reader, writer = await asyncio.open_unix_connection(
sock=sock,
loop=self.loop)
writer.write(b'AAAA')
self.assertEqual(await reader.readexactly(2), b'OK')
writer.write(b'BBBB')
self.assertEqual(await reader.readexactly(4), b'SPAM')
nonlocal CNT
CNT += 1
writer.close()
async def client_3(addr):
sock = socket.socket(socket.AF_UNIX)
sock.connect(addr)
reader, writer = await asyncio.open_connection(
sock=sock,
loop=self.loop)
writer.write(b'AAAA')
self.assertEqual(await reader.readexactly(2), b'OK')
writer.write(b'BBBB')
self.assertEqual(await reader.readexactly(4), b'SPAM')
nonlocal CNT
CNT += 1
writer.close()
def run(coro):
nonlocal CNT
CNT = 0
srv = tb.tcp_server(server,
family=socket.AF_UNIX,
max_clients=TOTAL_CNT,
backlog=TOTAL_CNT)
srv.start()
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(coro(srv.addr))
self.loop.run_until_complete(
asyncio.gather(*tasks, loop=self.loop))
srv.join()
self.assertEqual(CNT, TOTAL_CNT)
run(client)
run(client_2)
run(client_3)
def test_create_unix_connection_2(self):
with tempfile.NamedTemporaryFile() as tmp:
path = tmp.name
async def client():
reader, writer = await asyncio.open_unix_connection(
path,
loop=self.loop)
async def runner():
with self.assertRaises(FileNotFoundError):
await client()
self.loop.run_until_complete(runner())
def test_create_unix_connection_3(self):
CNT = 0
TOTAL_CNT = 100
def server():
data = yield tb.read(4)
self.assertEqual(data, b'AAAA')
yield tb.close()
async def client(addr):
reader, writer = await asyncio.open_unix_connection(
addr,
loop=self.loop)
sock = writer._transport.get_extra_info('socket')
self.assertEqual(sock.family, socket.AF_UNIX)
writer.write(b'AAAA')
with self.assertRaises(asyncio.IncompleteReadError):
await reader.readexactly(10)
writer.close()
nonlocal CNT
CNT += 1
def run(coro):
nonlocal CNT
CNT = 0
srv = tb.tcp_server(server,
family=socket.AF_UNIX,
max_clients=TOTAL_CNT,
backlog=TOTAL_CNT)
srv.start()
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(coro(srv.addr))
self.loop.run_until_complete(
asyncio.gather(*tasks, loop=self.loop))
srv.join()
self.assertEqual(CNT, TOTAL_CNT)
run(client)
def test_create_unix_connection_4(self):
sock = socket.socket(socket.AF_UNIX)
sock.close()
async def client():
reader, writer = await asyncio.open_unix_connection(
sock=sock,
loop=self.loop)
async def runner():
with self.assertRaisesRegex(OSError, 'Bad file'):
await client()
self.loop.run_until_complete(runner())
def test_create_unix_connection_5(self):
s1, s2 = socket.socketpair(socket.AF_UNIX)
excs = []
class Proto(asyncio.Protocol):
def connection_lost(self, exc):
excs.append(exc)
proto = Proto()
async def client():
t, _ = await self.loop.create_unix_connection(
lambda: proto,
None,
sock=s2)
t.write(b'AAAAA')
s1.close()
t.write(b'AAAAA')
await asyncio.sleep(0.1, loop=self.loop)
self.loop.run_until_complete(client())
self.assertEqual(len(excs), 1)
self.assertIn(excs[0].__class__,
(BrokenPipeError, ConnectionResetError))
def test_transport_unclosed_warning(self):
async def test(sock):
return await self.loop.create_unix_connection(
asyncio.Protocol,
None,
sock=sock)
with self.assertWarnsRegex(ResourceWarning, 'unclosed'):
s1, s2 = socket.socketpair(socket.AF_UNIX)
with s1, s2:
self.loop.run_until_complete(test(s1))
self.loop.close()
class Test_UV_Unix(_TestUnix, tb.UVTestCase):
def test_transport_fromsock_get_extra_info(self):
# This tests is only for uvloop. asyncio should pass it
# too in Python 3.6.
async def test(sock):
t, _ = await self.loop.create_unix_connection(
asyncio.Protocol,
None,
sock=sock)
sock = t.get_extra_info('socket')
self.assertIs(t.get_extra_info('socket'), sock)
with self.assertRaisesRegex(RuntimeError, 'is used by transport'):
self.loop.add_writer(sock.fileno(), lambda: None)
with self.assertRaisesRegex(RuntimeError, 'is used by transport'):
self.loop.remove_writer(sock.fileno())
t.close()
s1, s2 = socket.socketpair(socket.AF_UNIX)
with s1, s2:
self.loop.run_until_complete(test(s1))
def test_create_unix_server_path_dgram(self):
sock = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
with sock:
coro = self.loop.create_unix_server(lambda: None, path=None,
sock=sock)
with self.assertRaisesRegex(ValueError,
'A UNIX Domain Stream.*was expected'):
self.loop.run_until_complete(coro)
@unittest.skipUnless(hasattr(socket, 'SOCK_NONBLOCK'),
'no socket.SOCK_NONBLOCK (linux only)')
def test_create_unix_server_path_stream_bittype(self):
sock = socket.socket(
socket.AF_UNIX, socket.SOCK_STREAM | socket.SOCK_NONBLOCK)
with tempfile.NamedTemporaryFile() as file:
fn = file.name
try:
with sock:
sock.bind(fn)
coro = self.loop.create_unix_server(lambda: None, path=None,
sock=sock)
srv = self.loop.run_until_complete(coro)
srv.close()
self.loop.run_until_complete(srv.wait_closed())
finally:
os.unlink(fn)
class Test_AIO_Unix(_TestUnix, tb.AIOTestCase):
pass
class _TestSSL(tb.SSLTestCase):
def test_create_unix_server_ssl_1(self):
CNT = 0 # number of clients that were successful
TOTAL_CNT = 25 # total number of clients that test will create
TIMEOUT = 5.0 # timeout for this test
A_DATA = b'A' * 1024 * 1024
B_DATA = b'B' * 1024 * 1024
sslctx = self._create_server_ssl_context(self.ONLYCERT, self.ONLYKEY)
client_sslctx = self._create_client_ssl_context()
clients = []
async def handle_client(reader, writer):
nonlocal CNT
data = await reader.readexactly(len(A_DATA))
self.assertEqual(data, A_DATA)
writer.write(b'OK')
data = await reader.readexactly(len(B_DATA))
self.assertEqual(data, B_DATA)
writer.writelines([b'SP', bytearray(b'A'), memoryview(b'M')])
await writer.drain()
writer.close()
CNT += 1
async def test_client(addr):
fut = asyncio.Future(loop=self.loop)
def prog():
try:
yield tb.starttls(client_sslctx)
yield tb.connect(addr)
yield tb.write(A_DATA)
data = yield tb.read(2)
self.assertEqual(data, b'OK')
yield tb.write(B_DATA)
data = yield tb.read(4)
self.assertEqual(data, b'SPAM')
yield tb.close()
except Exception as ex:
self.loop.call_soon_threadsafe(fut.set_exception, ex)
else:
self.loop.call_soon_threadsafe(fut.set_result, None)
client = tb.tcp_client(prog, family=socket.AF_UNIX)
client.start()
clients.append(client)
await fut
async def start_server():
with tempfile.TemporaryDirectory() as td:
sock_name = os.path.join(td, 'sock')
srv = await asyncio.start_unix_server(
handle_client,
sock_name,
ssl=sslctx,
loop=self.loop)
try:
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(test_client(sock_name))
await asyncio.wait_for(
asyncio.gather(*tasks, loop=self.loop),
TIMEOUT, loop=self.loop)
finally:
self.loop.call_soon(srv.close)
await srv.wait_closed()
try:
with self._silence_eof_received_warning():
self.loop.run_until_complete(start_server())
except asyncio.TimeoutError:
if os.environ.get('TRAVIS_OS_NAME') == 'osx':
# XXX: figure out why this fails on macOS on Travis
raise unittest.SkipTest('unexplained error on Travis macOS')
else:
raise
self.assertEqual(CNT, TOTAL_CNT)
for client in clients:
client.stop()
def test_create_unix_connection_ssl_1(self):
CNT = 0
TOTAL_CNT = 25
A_DATA = b'A' * 1024 * 1024
B_DATA = b'B' * 1024 * 1024
sslctx = self._create_server_ssl_context(self.ONLYCERT, self.ONLYKEY)
client_sslctx = self._create_client_ssl_context()
def server():
yield tb.starttls(
sslctx,
server_side=True)
data = yield tb.read(len(A_DATA))
self.assertEqual(data, A_DATA)
yield tb.write(b'OK')
data = yield tb.read(len(B_DATA))
self.assertEqual(data, B_DATA)
yield tb.write(b'SPAM')
yield tb.close()
async def client(addr):
reader, writer = await asyncio.open_unix_connection(
addr,
ssl=client_sslctx,
server_hostname='',
loop=self.loop)
writer.write(A_DATA)
self.assertEqual(await reader.readexactly(2), b'OK')
writer.write(B_DATA)
self.assertEqual(await reader.readexactly(4), b'SPAM')
nonlocal CNT
CNT += 1
writer.close()
def run(coro):
nonlocal CNT
CNT = 0
srv = tb.tcp_server(server,
family=socket.AF_UNIX,
max_clients=TOTAL_CNT,
backlog=TOTAL_CNT)
srv.start()
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(coro(srv.addr))
self.loop.run_until_complete(
asyncio.gather(*tasks, loop=self.loop))
srv.join()
self.assertEqual(CNT, TOTAL_CNT)
with self._silence_eof_received_warning():
run(client)
class Test_UV_UnixSSL(_TestSSL, tb.UVTestCase):
pass
class Test_AIO_UnixSSL(_TestSSL, tb.AIOTestCase):
pass
uvloop-0.8.0/tests/test_aiohttp.py 0000664 0001750 0001750 00000003443 13047176662 020152 0 ustar travis travis 0000000 0000000 try:
import aiohttp
import aiohttp.server
except ImportError:
skip_tests = True
else:
skip_tests = False
import asyncio
import unittest
from uvloop import _testbase as tb
class _TestAioHTTP:
def test_aiohttp_basic_1(self):
PAYLOAD = b'It Works!
' * 10000
class HttpRequestHandler(aiohttp.server.ServerHttpProtocol):
async def handle_request(self, message, payload):
response = aiohttp.Response(
self.writer, 200, http_version=message.version
)
response.add_header('Content-Type', 'text/html')
response.add_header('Content-Length', str(len(PAYLOAD)))
response.send_headers()
response.write(PAYLOAD)
await response.write_eof()
asyncio.set_event_loop(self.loop)
f = self.loop.create_server(
lambda: HttpRequestHandler(keepalive_timeout=1),
'0.0.0.0', '0')
srv = self.loop.run_until_complete(f)
port = srv.sockets[0].getsockname()[1]
async def test():
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)
self.assertEqual(len(await r.text()), len(PAYLOAD))
self.loop.run_until_complete(test())
srv.close()
self.loop.run_until_complete(srv.wait_closed())
@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
uvloop-0.8.0/tests/test_futures.py 0000664 0001750 0001750 00000036515 13047176662 020205 0 ustar travis travis 0000000 0000000 # LICENSE: PSF.
import asyncio
import concurrent.futures
import re
import sys
import threading
import unittest
import uvloop
from asyncio import test_utils
from uvloop import _testbase as tb
from unittest import mock
from test import support
# Most of the tests are copied from asyncio
def _fakefunc(f):
return f
def first_cb():
pass
def last_cb():
pass
class _TestFutures:
def create_future(self):
raise NotImplementedError
def test_future_initial_state(self):
f = self.create_future()
self.assertFalse(f.cancelled())
self.assertFalse(f.done())
f.cancel()
self.assertTrue(f.cancelled())
def test_future_cancel(self):
f = self.create_future()
self.assertTrue(f.cancel())
self.assertTrue(f.cancelled())
self.assertTrue(f.done())
self.assertRaises(asyncio.CancelledError, f.result)
self.assertRaises(asyncio.CancelledError, f.exception)
self.assertRaises(asyncio.InvalidStateError, f.set_result, None)
self.assertRaises(asyncio.InvalidStateError, f.set_exception, None)
self.assertFalse(f.cancel())
def test_future_result(self):
f = self.create_future()
self.assertRaises(asyncio.InvalidStateError, f.result)
f.set_result(42)
self.assertFalse(f.cancelled())
self.assertTrue(f.done())
self.assertEqual(f.result(), 42)
self.assertEqual(f.exception(), None)
self.assertRaises(asyncio.InvalidStateError, f.set_result, None)
self.assertRaises(asyncio.InvalidStateError, f.set_exception, None)
self.assertFalse(f.cancel())
def test_future_exception(self):
exc = RuntimeError()
f = self.create_future()
self.assertRaises(asyncio.InvalidStateError, f.exception)
if sys.version_info[:3] > (3, 5, 1):
# StopIteration cannot be raised into a Future - CPython issue26221
self.assertRaisesRegex(TypeError,
"StopIteration .* cannot be raised",
f.set_exception, StopIteration)
f.set_exception(exc)
self.assertFalse(f.cancelled())
self.assertTrue(f.done())
self.assertRaises(RuntimeError, f.result)
self.assertEqual(f.exception(), exc)
self.assertRaises(asyncio.InvalidStateError, f.set_result, None)
self.assertRaises(asyncio.InvalidStateError, f.set_exception, None)
self.assertFalse(f.cancel())
def test_future_exception_class(self):
f = self.create_future()
f.set_exception(RuntimeError)
self.assertIsInstance(f.exception(), RuntimeError)
def test_future_yield_from_twice(self):
f = self.create_future()
def fixture():
yield 'A'
x = yield from f
yield 'B', x
y = yield from f
yield 'C', y
g = fixture()
self.assertEqual(next(g), 'A') # yield 'A'.
self.assertEqual(next(g), f) # First yield from f.
f.set_result(42)
self.assertEqual(next(g), ('B', 42)) # yield 'B', x.
# The second "yield from f" does not yield f.
self.assertEqual(next(g), ('C', 42)) # yield 'C', y.
def test_future_repr(self):
self.loop.set_debug(True)
f_pending_debug = self.create_future()
frame = f_pending_debug._source_traceback[-1]
self.assertEqual(repr(f_pending_debug),
''
% (frame[0], frame[1]))
f_pending_debug.cancel()
self.loop.set_debug(False)
f_pending = self.create_future()
self.assertEqual(repr(f_pending), '')
f_pending.cancel()
f_cancelled = self.create_future()
f_cancelled.cancel()
self.assertEqual(repr(f_cancelled), '')
f_result = self.create_future()
f_result.set_result(4)
self.assertEqual(repr(f_result), '')
self.assertEqual(f_result.result(), 4)
exc = RuntimeError()
f_exception = self.create_future()
f_exception.set_exception(exc)
self.assertEqual(repr(f_exception),
'')
self.assertIs(f_exception.exception(), exc)
def func_repr(func):
filename, lineno = test_utils.get_function_source(func)
text = '%s() at %s:%s' % (func.__qualname__, filename, lineno)
return re.escape(text)
f_one_callbacks = self.create_future()
f_one_callbacks.add_done_callback(_fakefunc)
fake_repr = func_repr(_fakefunc)
self.assertRegex(repr(f_one_callbacks),
r'' % fake_repr)
f_one_callbacks.cancel()
self.assertEqual(repr(f_one_callbacks),
'')
f_two_callbacks = self.create_future()
f_two_callbacks.add_done_callback(first_cb)
f_two_callbacks.add_done_callback(last_cb)
first_repr = func_repr(first_cb)
last_repr = func_repr(last_cb)
self.assertRegex(repr(f_two_callbacks),
r''
% (first_repr, last_repr))
f_many_callbacks = self.create_future()
f_many_callbacks.add_done_callback(first_cb)
for i in range(8):
f_many_callbacks.add_done_callback(_fakefunc)
f_many_callbacks.add_done_callback(last_cb)
cb_regex = r'%s, <8 more>, %s' % (first_repr, last_repr)
self.assertRegex(repr(f_many_callbacks),
r'' % cb_regex)
f_many_callbacks.cancel()
self.assertEqual(repr(f_many_callbacks),
'')
def test_future_copy_state(self):
if sys.version_info[:3] < (3, 5, 1):
raise unittest.SkipTest()
from asyncio.futures import _copy_future_state
f = self.create_future()
f.set_result(10)
newf = self.create_future()
_copy_future_state(f, newf)
self.assertTrue(newf.done())
self.assertEqual(newf.result(), 10)
f_exception = self.create_future()
f_exception.set_exception(RuntimeError())
newf_exception = self.create_future()
_copy_future_state(f_exception, newf_exception)
self.assertTrue(newf_exception.done())
self.assertRaises(RuntimeError, newf_exception.result)
f_cancelled = self.create_future()
f_cancelled.cancel()
newf_cancelled = self.create_future()
_copy_future_state(f_cancelled, newf_cancelled)
self.assertTrue(newf_cancelled.cancelled())
@mock.patch('asyncio.base_events.logger')
def test_future_tb_logger_abandoned(self, m_log):
fut = self.create_future()
del fut
self.assertFalse(m_log.error.called)
@mock.patch('asyncio.base_events.logger')
def test_future_tb_logger_result_unretrieved(self, m_log):
fut = self.create_future()
fut.set_result(42)
del fut
self.assertFalse(m_log.error.called)
@mock.patch('asyncio.base_events.logger')
def test_future_tb_logger_result_retrieved(self, m_log):
fut = self.create_future()
fut.set_result(42)
fut.result()
del fut
self.assertFalse(m_log.error.called)
def test_future_wrap_future(self):
def run(arg):
return (arg, threading.get_ident())
ex = concurrent.futures.ThreadPoolExecutor(1)
f1 = ex.submit(run, 'oi')
f2 = asyncio.wrap_future(f1, loop=self.loop)
res, ident = self.loop.run_until_complete(f2)
self.assertIsInstance(f2, asyncio.Future)
self.assertEqual(res, 'oi')
self.assertNotEqual(ident, threading.get_ident())
def test_future_wrap_future_future(self):
f1 = self.create_future()
f2 = asyncio.wrap_future(f1)
self.assertIs(f1, f2)
def test_future_wrap_future_use_global_loop(self):
with mock.patch('asyncio.futures.events') as events:
events.get_event_loop = lambda: self.loop
def run(arg):
return (arg, threading.get_ident())
ex = concurrent.futures.ThreadPoolExecutor(1)
f1 = ex.submit(run, 'oi')
f2 = asyncio.wrap_future(f1)
self.assertIs(self.loop, f2._loop)
def test_future_wrap_future_cancel(self):
f1 = concurrent.futures.Future()
f2 = asyncio.wrap_future(f1, loop=self.loop)
f2.cancel()
test_utils.run_briefly(self.loop)
self.assertTrue(f1.cancelled())
self.assertTrue(f2.cancelled())
def test_future_wrap_future_cancel2(self):
f1 = concurrent.futures.Future()
f2 = asyncio.wrap_future(f1, loop=self.loop)
f1.set_result(42)
f2.cancel()
test_utils.run_briefly(self.loop)
self.assertFalse(f1.cancelled())
self.assertEqual(f1.result(), 42)
self.assertTrue(f2.cancelled())
def test_future_source_traceback(self):
self.loop.set_debug(True)
future = self.create_future()
lineno = sys._getframe().f_lineno - 1
self.assertIsInstance(future._source_traceback, list)
self.assertEqual(future._source_traceback[-2][:3],
(__file__,
lineno,
'test_future_source_traceback'))
def check_future_exception_never_retrieved(self, debug):
last_ctx = None
def handler(loop, context):
nonlocal last_ctx
last_ctx = context
self.loop.set_debug(debug)
self.loop.set_exception_handler(handler)
def memory_error():
try:
raise MemoryError()
except BaseException as exc:
return exc
exc = memory_error()
future = self.create_future()
if debug:
source_traceback = future._source_traceback
future.set_exception(exc)
future = None
support.gc_collect()
test_utils.run_briefly(self.loop)
self.assertIsNotNone(last_ctx)
self.assertIs(last_ctx['exception'], exc)
self.assertEqual(last_ctx['message'],
'Future exception was never retrieved')
if debug:
tb = last_ctx['source_traceback']
self.assertEqual(tb[-2].name,
'check_future_exception_never_retrieved')
def test_future_exception_never_retrieved(self):
self.check_future_exception_never_retrieved(False)
def test_future_exception_never_retrieved_debug(self):
self.check_future_exception_never_retrieved(True)
def test_future_wrap_future(self):
from uvloop.loop import _wrap_future
def run(arg):
return (arg, threading.get_ident())
ex = concurrent.futures.ThreadPoolExecutor(1)
f1 = ex.submit(run, 'oi')
f2 = _wrap_future(f1, loop=self.loop)
res, ident = self.loop.run_until_complete(f2)
self.assertIsInstance(f2, asyncio.Future)
self.assertEqual(res, 'oi')
self.assertNotEqual(ident, threading.get_ident())
def test_future_wrap_future_future(self):
from uvloop.loop import _wrap_future
f1 = self.create_future()
f2 = _wrap_future(f1)
self.assertIs(f1, f2)
def test_future_wrap_future_cancel(self):
from uvloop.loop import _wrap_future
f1 = concurrent.futures.Future()
f2 = _wrap_future(f1, loop=self.loop)
f2.cancel()
test_utils.run_briefly(self.loop)
self.assertTrue(f1.cancelled())
self.assertTrue(f2.cancelled())
def test_future_wrap_future_cancel2(self):
from uvloop.loop import _wrap_future
f1 = concurrent.futures.Future()
f2 = _wrap_future(f1, loop=self.loop)
f1.set_result(42)
f2.cancel()
test_utils.run_briefly(self.loop)
self.assertFalse(f1.cancelled())
self.assertEqual(f1.result(), 42)
self.assertTrue(f2.cancelled())
class _TestFuturesDoneCallbacks:
def run_briefly(self):
test_utils.run_briefly(self.loop)
def _make_callback(self, bag, thing):
# Create a callback function that appends thing to bag.
def bag_appender(future):
bag.append(thing)
return bag_appender
def _new_future(self):
raise NotImplementedError
def test_future_callbacks_invoked_on_set_result(self):
bag = []
f = self._new_future()
f.add_done_callback(self._make_callback(bag, 42))
f.add_done_callback(self._make_callback(bag, 17))
self.assertEqual(bag, [])
f.set_result('foo')
self.run_briefly()
self.assertEqual(bag, [42, 17])
self.assertEqual(f.result(), 'foo')
def test_future_callbacks_invoked_on_set_exception(self):
bag = []
f = self._new_future()
f.add_done_callback(self._make_callback(bag, 100))
self.assertEqual(bag, [])
exc = RuntimeError()
f.set_exception(exc)
self.run_briefly()
self.assertEqual(bag, [100])
self.assertEqual(f.exception(), exc)
def test_future_remove_done_callback(self):
bag = []
f = self._new_future()
cb1 = self._make_callback(bag, 1)
cb2 = self._make_callback(bag, 2)
cb3 = self._make_callback(bag, 3)
# Add one cb1 and one cb2.
f.add_done_callback(cb1)
f.add_done_callback(cb2)
# One instance of cb2 removed. Now there's only one cb1.
self.assertEqual(f.remove_done_callback(cb2), 1)
# Never had any cb3 in there.
self.assertEqual(f.remove_done_callback(cb3), 0)
# After this there will be 6 instances of cb1 and one of cb2.
f.add_done_callback(cb2)
for i in range(5):
f.add_done_callback(cb1)
# Remove all instances of cb1. One cb2 remains.
self.assertEqual(f.remove_done_callback(cb1), 6)
self.assertEqual(bag, [])
f.set_result('foo')
self.run_briefly()
self.assertEqual(bag, [2])
self.assertEqual(f.result(), 'foo')
###############################################################################
# Tests Matrix
###############################################################################
class Test_UV_UV_create_future(_TestFutures, tb.UVTestCase):
# Test uvloop.Loop.create_future
def create_future(self):
return self.loop.create_future()
class Test_UV_UV_Future(_TestFutures, tb.UVTestCase):
# Test that uvloop.Future can be instantiated directly
def create_future(self):
return uvloop.Future(loop=self.loop)
class Test_UV_AIO_Futures(_TestFutures, tb.UVTestCase):
def create_future(self):
return asyncio.Future(loop=self.loop)
class Test_AIO_Futures(_TestFutures, tb.AIOTestCase):
def create_future(self):
return asyncio.Future(loop=self.loop)
class Test_UV_UV_FuturesCallbacks(_TestFuturesDoneCallbacks, tb.UVTestCase):
def _new_future(self):
return self.loop.create_future()
class Test_UV_AIO_FuturesCallbacks(_TestFuturesDoneCallbacks, tb.UVTestCase):
def _new_future(self):
return asyncio.Future(loop=self.loop)
class Test_AIO_FuturesCallbacks(_TestFuturesDoneCallbacks, tb.AIOTestCase):
def _new_future(self):
return asyncio.Future(loop=self.loop)
uvloop-0.8.0/tests/test_testbase.py 0000664 0001750 0001750 00000002536 13047176662 020316 0 ustar travis travis 0000000 0000000 import unittest
from uvloop import _testbase as tb
class TestBaseTest(unittest.TestCase):
def test_duplicate_methods(self):
with self.assertRaisesRegex(RuntimeError, 'duplicate test Foo.test_a'):
class Foo(tb.BaseTestCase):
def test_a(self):
pass
def test_b(self):
pass
def test_a(self): # NOQA
pass
def test_duplicate_methods_parent_1(self):
class FooBase:
def test_a(self):
pass
with self.assertRaisesRegex(RuntimeError,
'duplicate test Foo.test_a.*'
'defined in FooBase'):
class Foo(FooBase, tb.BaseTestCase):
def test_b(self):
pass
def test_a(self):
pass
def test_duplicate_methods_parent_2(self):
class FooBase(tb.BaseTestCase):
def test_a(self):
pass
with self.assertRaisesRegex(RuntimeError,
'duplicate test Foo.test_a.*'
'defined in FooBase'):
class Foo(FooBase):
def test_b(self):
pass
def test_a(self):
pass
uvloop-0.8.0/tests/test_dns.py 0000664 0001750 0001750 00000013163 13047176662 017266 0 ustar travis travis 0000000 0000000 import socket
import unittest
from uvloop import _testbase as tb
class BaseTestDNS:
def _test_getaddrinfo(self, *args, **kwargs):
err = None
try:
a1 = socket.getaddrinfo(*args, **kwargs)
except socket.gaierror as ex:
err = ex
try:
a2 = self.loop.run_until_complete(
self.loop.getaddrinfo(*args, **kwargs))
except socket.gaierror as ex:
if err is not None:
self.assertEqual(ex.args, err.args)
else:
ex.__context__ = err
raise ex
except OSError as ex:
ex.__context__ = err
raise ex
else:
if err is not None:
raise err
self.assertEqual(a1, a2)
def _test_getnameinfo(self, *args, **kwargs):
err = None
try:
a1 = socket.getnameinfo(*args, **kwargs)
except Exception as ex:
err = ex
try:
a2 = self.loop.run_until_complete(
self.loop.getnameinfo(*args, **kwargs))
except Exception as ex:
if err is not None:
if ex.__class__ is not err.__class__:
print(ex, err)
self.assertIs(ex.__class__, err.__class__)
self.assertEqual(ex.args, err.args)
else:
raise
else:
if err is not None:
raise err
self.assertEqual(a1, a2)
def test_getaddrinfo_1(self):
self._test_getaddrinfo('example.com', 80)
self._test_getaddrinfo('example.com', 80, type=socket.SOCK_STREAM)
def test_getaddrinfo_2(self):
self._test_getaddrinfo('example.com', 80, flags=socket.AI_CANONNAME)
def test_getaddrinfo_3(self):
self._test_getaddrinfo('a' + '1' * 50 + '.wat', 800)
def test_getaddrinfo_4(self):
self._test_getaddrinfo('example.com', 80, family=-1)
self._test_getaddrinfo('example.com', 80, type=socket.SOCK_STREAM,
family=-1)
def test_getaddrinfo_5(self):
self._test_getaddrinfo('example.com', '80')
self._test_getaddrinfo('example.com', '80', type=socket.SOCK_STREAM)
def test_getaddrinfo_6(self):
self._test_getaddrinfo(b'example.com', b'80')
self._test_getaddrinfo(b'example.com', b'80', type=socket.SOCK_STREAM)
def test_getaddrinfo_7(self):
self._test_getaddrinfo(None, 0)
self._test_getaddrinfo(None, 0, type=socket.SOCK_STREAM)
def test_getaddrinfo_8(self):
self._test_getaddrinfo('', 0)
self._test_getaddrinfo('', 0, type=socket.SOCK_STREAM)
def test_getaddrinfo_9(self):
self._test_getaddrinfo(b'', 0)
self._test_getaddrinfo(b'', 0, type=socket.SOCK_STREAM)
def test_getaddrinfo_10(self):
self._test_getaddrinfo(None, None)
self._test_getaddrinfo(None, None, type=socket.SOCK_STREAM)
def test_getaddrinfo_11(self):
self._test_getaddrinfo(b'example.com', '80')
self._test_getaddrinfo(b'example.com', '80', type=socket.SOCK_STREAM)
def test_getaddrinfo_12(self):
self._test_getaddrinfo('127.0.0.1', '80')
self._test_getaddrinfo('127.0.0.1', '80', type=socket.SOCK_STREAM)
def test_getaddrinfo_13(self):
self._test_getaddrinfo(b'127.0.0.1', b'80')
self._test_getaddrinfo(b'127.0.0.1', b'80', type=socket.SOCK_STREAM)
def test_getaddrinfo_14(self):
self._test_getaddrinfo(b'127.0.0.1', b'http')
self._test_getaddrinfo(b'127.0.0.1', b'http', type=socket.SOCK_STREAM)
def test_getaddrinfo_15(self):
self._test_getaddrinfo('127.0.0.1', 'http')
self._test_getaddrinfo('127.0.0.1', 'http', type=socket.SOCK_STREAM)
def test_getaddrinfo_16(self):
self._test_getaddrinfo('localhost', 'http')
self._test_getaddrinfo('localhost', 'http', type=socket.SOCK_STREAM)
def test_getaddrinfo_17(self):
self._test_getaddrinfo(b'localhost', 'http')
self._test_getaddrinfo(b'localhost', 'http', type=socket.SOCK_STREAM)
def test_getaddrinfo_18(self):
self._test_getaddrinfo('localhost', b'http')
self._test_getaddrinfo('localhost', b'http', type=socket.SOCK_STREAM)
def test_getaddrinfo_19(self):
self._test_getaddrinfo('::1', 80)
self._test_getaddrinfo('::1', 80, type=socket.SOCK_STREAM)
def test_getaddrinfo_20(self):
self._test_getaddrinfo('127.0.0.1', 80)
self._test_getaddrinfo('127.0.0.1', 80, type=socket.SOCK_STREAM)
######
def test_getnameinfo_1(self):
self._test_getnameinfo(('127.0.0.1', 80), 0)
def test_getnameinfo_2(self):
self._test_getnameinfo(('127.0.0.1', 80, 1231231231213), 0)
def test_getnameinfo_3(self):
self._test_getnameinfo(('127.0.0.1', 80, 0, 0), 0)
def test_getnameinfo_4(self):
self._test_getnameinfo(('::1', 80), 0)
def test_getnameinfo_5(self):
self._test_getnameinfo(('localhost', 8080), 0)
class Test_UV_DNS(BaseTestDNS, tb.UVTestCase):
def test_getaddrinfo_close_loop(self):
# Test that we can close the loop with a running
# DNS query.
try:
# Check that we have internet connection
socket.getaddrinfo('example.com', 80)
except socket.error:
raise unittest.SkipTest
async def run():
fut = self.loop.getaddrinfo('example.com', 80)
fut.cancel()
self.loop.stop()
try:
self.loop.run_until_complete(run())
finally:
self.loop.close()
class Test_AIO_DNS(BaseTestDNS, tb.AIOTestCase):
pass
uvloop-0.8.0/tests/test_base.py 0000664 0001750 0001750 00000052226 13047176662 017417 0 ustar travis travis 0000000 0000000 import asyncio
import fcntl
import logging
import os
import threading
import time
import uvloop
import unittest
import weakref
from unittest import mock
from uvloop._testbase import UVTestCase, AIOTestCase
class _TestBase:
def test_close(self):
self.assertFalse(self.loop._closed)
self.assertFalse(self.loop.is_closed())
self.loop.close()
self.assertTrue(self.loop._closed)
self.assertTrue(self.loop.is_closed())
# it should be possible to call close() more than once
self.loop.close()
self.loop.close()
# operation blocked when the loop is closed
f = asyncio.Future(loop=self.loop)
self.assertRaises(RuntimeError, self.loop.run_forever)
self.assertRaises(RuntimeError, self.loop.run_until_complete, f)
def test_handle_weakref(self):
wd = weakref.WeakValueDictionary()
h = self.loop.call_soon(lambda: None)
wd['h'] = h # Would fail without __weakref__ slot.
def test_call_soon(self):
calls = []
def cb(inc):
calls.append(inc)
self.loop.stop()
self.loop.call_soon(cb, 10)
h = self.loop.call_soon(cb, 100)
self.assertIn('.cb', repr(h))
h.cancel()
self.assertIn('cancelled', repr(h))
self.loop.call_soon(cb, 1)
self.loop.run_forever()
self.assertEqual(calls, [10, 1])
def test_call_soon_base_exc(self):
def cb():
raise KeyboardInterrupt()
self.loop.call_soon(cb)
with self.assertRaises(KeyboardInterrupt):
self.loop.run_forever()
self.assertFalse(self.loop.is_closed())
def test_calls_debug_reporting(self):
def run_test(debug, meth, stack_adj):
context = None
def handler(loop, ctx):
nonlocal context
context = ctx
self.loop.set_debug(debug)
self.loop.set_exception_handler(handler)
def cb():
1 / 0
meth(cb)
self.assertIsNone(context)
self.loop.run_until_complete(asyncio.sleep(0.05, loop=self.loop))
self.assertIs(type(context['exception']), ZeroDivisionError)
self.assertTrue(context['message'].startswith(
'Exception in callback'))
if debug:
tb = context['source_traceback']
self.assertEqual(tb[-1 + stack_adj].name, 'run_test')
else:
self.assertFalse('source_traceback' in context)
del context
for debug in (True, False):
for meth_name, meth, stack_adj in (
('call_soon',
self.loop.call_soon, 0),
('call_later', # `-1` accounts for lambda
lambda *args: self.loop.call_later(0.01, *args), -1)
):
with self.subTest(debug=debug, meth_name=meth_name):
run_test(debug, meth, stack_adj)
def test_now_update(self):
async def run():
st = self.loop.time()
time.sleep(0.05)
return self.loop.time() - st
delta = self.loop.run_until_complete(run())
self.assertTrue(delta > 0.049 and delta < 0.6)
def test_call_later_1(self):
calls = []
def cb(inc=10, stop=False):
calls.append(inc)
self.assertTrue(self.loop.is_running())
if stop:
self.loop.call_soon(self.loop.stop)
self.loop.call_later(0.05, cb)
# canceled right away
h = self.loop.call_later(0.05, cb, 100, True)
self.assertIn('.cb', repr(h))
h.cancel()
self.assertIn('cancelled', repr(h))
self.loop.call_later(0.05, cb, 1, True)
self.loop.call_later(1000, cb, 1000) # shouldn't be called
started = time.monotonic()
self.loop.run_forever()
finished = time.monotonic()
self.assertEqual(calls, [10, 1])
self.assertFalse(self.loop.is_running())
self.assertLess(finished - started, 0.1)
self.assertGreater(finished - started, 0.04)
def test_call_later_2(self):
# Test that loop.call_later triggers an update of
# libuv cached time.
async def main():
await asyncio.sleep(0.001, loop=self.loop)
time.sleep(0.01)
await asyncio.sleep(0.01, loop=self.loop)
started = time.monotonic()
self.loop.run_until_complete(main())
delta = time.monotonic() - started
self.assertGreater(delta, 0.019)
def test_call_later_negative(self):
calls = []
def cb(arg):
calls.append(arg)
self.loop.stop()
self.loop.call_later(-1, cb, 'a')
self.loop.run_forever()
self.assertEqual(calls, ['a'])
def test_call_at(self):
if os.environ.get('TRAVIS_OS_NAME') == 'osx':
# Time seems to be really unpredictable on Travis' macOS.
raise unittest.SkipTest('time is not monotonic on Travis/macOS')
i = 0
def cb(inc):
nonlocal i
i += inc
self.loop.stop()
at = self.loop.time() + 0.05
self.loop.call_at(at, cb, 100).cancel()
self.loop.call_at(at, cb, 10)
started = time.monotonic()
self.loop.run_forever()
finished = time.monotonic()
self.assertEqual(i, 10)
self.assertLess(finished - started, 0.07)
self.assertGreater(finished - started, 0.045)
def test_check_thread(self):
def check_thread(loop, debug):
def cb():
pass
loop.set_debug(debug)
if debug:
msg = ("Non-thread-safe operation invoked on an "
"event loop other than the current one")
with self.assertRaisesRegex(RuntimeError, msg):
loop.call_soon(cb)
with self.assertRaisesRegex(RuntimeError, msg):
loop.call_later(60, cb)
with self.assertRaisesRegex(RuntimeError, msg):
loop.call_at(loop.time() + 60, cb)
else:
loop.call_soon(cb)
loop.call_later(60, cb)
loop.call_at(loop.time() + 60, cb)
def check_in_thread(loop, event, debug, create_loop, fut):
# wait until the event loop is running
event.wait()
try:
if create_loop:
loop2 = self.new_loop()
try:
asyncio.set_event_loop(loop2)
check_thread(loop, debug)
finally:
asyncio.set_event_loop(None)
loop2.close()
else:
check_thread(loop, debug)
except Exception as exc:
loop.call_soon_threadsafe(fut.set_exception, exc)
else:
loop.call_soon_threadsafe(fut.set_result, None)
def test_thread(loop, debug, create_loop=False):
event = threading.Event()
fut = asyncio.Future(loop=loop)
loop.call_soon(event.set)
args = (loop, event, debug, create_loop, fut)
thread = threading.Thread(target=check_in_thread, args=args)
thread.start()
loop.run_until_complete(fut)
thread.join()
# raise RuntimeError if the thread has no event loop
test_thread(self.loop, True)
# check disabled if debug mode is disabled
test_thread(self.loop, False)
# raise RuntimeError if the event loop of the thread is not the called
# event loop
test_thread(self.loop, True, create_loop=True)
# check disabled if debug mode is disabled
test_thread(self.loop, False, create_loop=True)
def test_run_once_in_executor_plain(self):
called = []
def cb(arg):
called.append(arg)
async def runner():
await self.loop.run_in_executor(None, cb, 'a')
self.loop.run_until_complete(runner())
self.assertEqual(called, ['a'])
def test_set_debug(self):
self.loop.set_debug(True)
self.assertTrue(self.loop.get_debug())
self.loop.set_debug(False)
self.assertFalse(self.loop.get_debug())
def test_run_until_complete_type_error(self):
self.assertRaises(
TypeError, self.loop.run_until_complete, 'blah')
def test_run_until_complete_loop(self):
task = asyncio.Future(loop=self.loop)
other_loop = self.new_loop()
self.addCleanup(other_loop.close)
self.assertRaises(
ValueError, other_loop.run_until_complete, task)
def test_run_until_complete_error(self):
async def foo():
raise ValueError('aaa')
with self.assertRaisesRegex(ValueError, 'aaa'):
self.loop.run_until_complete(foo())
def test_debug_slow_callbacks(self):
logger = logging.getLogger('asyncio')
self.loop.set_debug(True)
self.loop.slow_callback_duration = 0.2
self.loop.call_soon(lambda: time.sleep(0.3))
with mock.patch.object(logger, 'warning') as log:
self.loop.run_until_complete(asyncio.sleep(0, loop=self.loop))
self.assertEqual(log.call_count, 1)
# format message
msg = log.call_args[0][0] % log.call_args[0][1:]
self.assertIn('Executing 5:
self.fail(
'exception in preexec_fn did not kill the child process')
def test_process_executable_1(self):
async def test():
proc = await asyncio.create_subprocess_exec(
b'doesnotexist', b'-c', b'print("spam")',
executable=sys.executable,
stdout=subprocess.PIPE,
loop=self.loop)
out, err = await proc.communicate()
self.assertEqual(out, b'spam\n')
self.loop.run_until_complete(test())
def test_process_pid_1(self):
async def test():
prog = '''\
import os
print(os.getpid())
'''
cmd = sys.executable
proc = await asyncio.create_subprocess_exec(
cmd, b'-c', prog,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
loop=self.loop)
pid = proc.pid
expected_result = '{}\n'.format(pid).encode()
out, err = await proc.communicate()
self.assertEqual(out, expected_result)
self.loop.run_until_complete(test())
def test_process_send_signal_1(self):
async def test():
prog = '''\
import signal
def handler(signum, frame):
if signum == signal.SIGUSR1:
print('WORLD')
signal.signal(signal.SIGUSR1, handler)
a = input()
print(a)
a = input()
print(a)
exit(11)
'''
cmd = sys.executable
proc = await asyncio.create_subprocess_exec(
cmd, b'-c', prog,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
loop=self.loop)
proc.stdin.write(b'HELLO\n')
await proc.stdin.drain()
self.assertEqual(await proc.stdout.readline(), b'HELLO\n')
proc.send_signal(signal.SIGUSR1)
proc.stdin.write(b'!\n')
await proc.stdin.drain()
self.assertEqual(await proc.stdout.readline(), b'WORLD\n')
self.assertEqual(await proc.stdout.readline(), b'!\n')
self.assertEqual(await proc.wait(), 11)
self.loop.run_until_complete(test())
def test_process_streams_basic_1(self):
async def test():
prog = '''\
import sys
while True:
a = input()
if a == 'stop':
exit(20)
elif a == 'stderr':
print('OUCH', file=sys.stderr)
else:
print('>' + a + '<')
'''
cmd = sys.executable
proc = await asyncio.create_subprocess_exec(
cmd, b'-c', prog,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
loop=self.loop)
self.assertGreater(proc.pid, 0)
self.assertIs(proc.returncode, None)
transp = proc._transport
with self.assertRaises(NotImplementedError):
# stdin is WriteTransport
transp.get_pipe_transport(0).pause_reading()
with self.assertRaises((NotImplementedError, AttributeError)):
# stdout is ReadTransport
transp.get_pipe_transport(1).write(b'wat')
proc.stdin.write(b'foobar\n')
await proc.stdin.drain()
out = await proc.stdout.readline()
self.assertEqual(out, b'>foobar<\n')
proc.stdin.write(b'stderr\n')
await proc.stdin.drain()
out = await proc.stderr.readline()
self.assertEqual(out, b'OUCH\n')
proc.stdin.write(b'stop\n')
await proc.stdin.drain()
exitcode = await proc.wait()
self.assertEqual(exitcode, 20)
self.loop.run_until_complete(test())
def test_process_streams_stderr_to_stdout(self):
async def test():
prog = '''\
import sys
print('out', flush=True)
print('err', file=sys.stderr, flush=True)
'''
proc = await asyncio.create_subprocess_exec(
sys.executable, '-c', prog,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
loop=self.loop)
out, err = await proc.communicate()
self.assertIsNone(err)
self.assertEqual(out, b'out\nerr\n')
self.loop.run_until_complete(test())
def test_process_streams_devnull(self):
async def test():
prog = '''\
import sys
print('out', flush=True)
print('err', file=sys.stderr, flush=True)
'''
proc = await asyncio.create_subprocess_exec(
sys.executable, '-c', prog,
stdin=subprocess.DEVNULL,
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL,
loop=self.loop)
out, err = await proc.communicate()
self.assertIsNone(err)
self.assertIsNone(out)
self.loop.run_until_complete(test())
def test_process_streams_pass_fds(self):
async def test():
prog = '''\
import sys, os
assert sys.argv[1] == '--'
inherited = int(sys.argv[2])
non_inherited = int(sys.argv[3])
os.fstat(inherited)
try:
os.fstat(non_inherited)
except:
pass
else:
raise RuntimeError()
print("OK")
'''
with tempfile.TemporaryFile() as inherited, \
tempfile.TemporaryFile() as non_inherited:
proc = await asyncio.create_subprocess_exec(
sys.executable, '-c', prog, '--',
str(inherited.fileno()),
str(non_inherited.fileno()),
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
pass_fds=(inherited.fileno(),),
loop=self.loop)
out, err = await proc.communicate()
self.assertEqual(err, b'')
self.assertEqual(out, b'OK\n')
self.loop.run_until_complete(test())
class _AsyncioTests:
# Program blocking
PROGRAM_BLOCKED = [sys.executable, '-c', 'import time; time.sleep(3600)']
# Program copying input to output
PROGRAM_CAT = [
sys.executable, '-c',
';'.join(('import sys',
'data = sys.stdin.buffer.read()',
'sys.stdout.buffer.write(data)'))]
def test_stdin_not_inheritable(self):
# asyncio issue #209: stdin must not be inheritable, otherwise
# the Process.communicate() hangs
@asyncio.coroutine
def len_message(message):
code = 'import sys; data = sys.stdin.read(); print(len(data))'
proc = yield from asyncio.create_subprocess_exec(
sys.executable, '-c', code,
stdin=asyncio.subprocess.PIPE,
stdout=asyncio.subprocess.PIPE,
stderr=asyncio.subprocess.PIPE,
close_fds=False,
loop=self.loop)
stdout, stderr = yield from proc.communicate(message)
exitcode = yield from proc.wait()
return (stdout, exitcode)
output, exitcode = self.loop.run_until_complete(len_message(b'abc'))
self.assertEqual(output.rstrip(), b'3')
self.assertEqual(exitcode, 0)
def test_stdin_stdout(self):
args = self.PROGRAM_CAT
@asyncio.coroutine
def run(data):
proc = yield from asyncio.create_subprocess_exec(
*args,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
loop=self.loop)
# feed data
proc.stdin.write(data)
yield from proc.stdin.drain()
proc.stdin.close()
# get output and exitcode
data = yield from proc.stdout.read()
exitcode = yield from proc.wait()
return (exitcode, data)
task = run(b'some data')
task = asyncio.wait_for(task, 60.0, loop=self.loop)
exitcode, stdout = self.loop.run_until_complete(task)
self.assertEqual(exitcode, 0)
self.assertEqual(stdout, b'some data')
def test_communicate(self):
args = self.PROGRAM_CAT
@asyncio.coroutine
def run(data):
proc = yield from asyncio.create_subprocess_exec(
*args,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
loop=self.loop)
stdout, stderr = yield from proc.communicate(data)
return proc.returncode, stdout
task = run(b'some data')
task = asyncio.wait_for(task, 60.0, loop=self.loop)
exitcode, stdout = self.loop.run_until_complete(task)
self.assertEqual(exitcode, 0)
self.assertEqual(stdout, b'some data')
def test_start_new_session(self):
# start the new process in a new session
create = asyncio.create_subprocess_shell('exit 8',
start_new_session=True,
loop=self.loop)
proc = self.loop.run_until_complete(create)
exitcode = self.loop.run_until_complete(proc.wait())
self.assertEqual(exitcode, 8)
def test_shell(self):
create = asyncio.create_subprocess_shell('exit 7',
loop=self.loop)
proc = self.loop.run_until_complete(create)
exitcode = self.loop.run_until_complete(proc.wait())
self.assertEqual(exitcode, 7)
def test_kill(self):
args = self.PROGRAM_BLOCKED
create = asyncio.create_subprocess_exec(*args, loop=self.loop)
proc = self.loop.run_until_complete(create)
proc.kill()
returncode = self.loop.run_until_complete(proc.wait())
self.assertEqual(-signal.SIGKILL, returncode)
def test_terminate(self):
args = self.PROGRAM_BLOCKED
create = asyncio.create_subprocess_exec(*args, loop=self.loop)
proc = self.loop.run_until_complete(create)
proc.terminate()
returncode = self.loop.run_until_complete(proc.wait())
self.assertEqual(-signal.SIGTERM, returncode)
def test_send_signal(self):
code = 'import time; print("sleeping", flush=True); time.sleep(3600)'
args = [sys.executable, '-c', code]
create = asyncio.create_subprocess_exec(*args,
stdout=subprocess.PIPE,
loop=self.loop)
proc = self.loop.run_until_complete(create)
@asyncio.coroutine
def send_signal(proc):
# basic synchronization to wait until the program is sleeping
line = yield from proc.stdout.readline()
self.assertEqual(line, b'sleeping\n')
proc.send_signal(signal.SIGHUP)
returncode = (yield from proc.wait())
return returncode
returncode = self.loop.run_until_complete(send_signal(proc))
self.assertEqual(-signal.SIGHUP, returncode)
def test_cancel_process_wait(self):
# Issue #23140: cancel Process.wait()
@asyncio.coroutine
def cancel_wait():
proc = yield from asyncio.create_subprocess_exec(
*self.PROGRAM_BLOCKED,
loop=self.loop)
# Create an internal future waiting on the process exit
task = self.loop.create_task(proc.wait())
self.loop.call_soon(task.cancel)
try:
yield from task
except asyncio.CancelledError:
pass
# Cancel the future
task.cancel()
# Kill the process and wait until it is done
proc.kill()
yield from proc.wait()
self.loop.run_until_complete(cancel_wait())
def test_cancel_make_subprocess_transport_exec(self):
@asyncio.coroutine
def cancel_make_transport():
coro = asyncio.create_subprocess_exec(*self.PROGRAM_BLOCKED,
loop=self.loop)
task = self.loop.create_task(coro)
self.loop.call_soon(task.cancel)
try:
yield from task
except asyncio.CancelledError:
pass
# ignore the log:
# "Exception during subprocess creation, kill the subprocess"
with test_utils.disable_logger():
self.loop.run_until_complete(cancel_make_transport())
def test_cancel_post_init(self):
@asyncio.coroutine
def cancel_make_transport():
coro = self.loop.subprocess_exec(asyncio.SubprocessProtocol,
*self.PROGRAM_BLOCKED)
task = self.loop.create_task(coro)
self.loop.call_soon(task.cancel)
try:
yield from task
except asyncio.CancelledError:
pass
# ignore the log:
# "Exception during subprocess creation, kill the subprocess"
with test_utils.disable_logger():
self.loop.run_until_complete(cancel_make_transport())
test_utils.run_briefly(self.loop)
class Test_UV_Process(_TestProcess, tb.UVTestCase):
def test_process_lated_stdio_init(self):
class TestProto:
def __init__(self):
self.lost = 0
self.stages = []
def connection_made(self, transport):
self.stages.append(('CM', transport))
def pipe_data_received(self, fd, data):
if fd == 1:
self.stages.append(('STDOUT', data))
def pipe_connection_lost(self, fd, exc):
if fd == 1:
self.stages.append(('STDOUT', 'LOST'))
def process_exited(self):
self.stages.append('PROC_EXIT')
def connection_lost(self, exc):
self.stages.append(('CL', self.lost, exc))
self.lost += 1
async def run(**kwargs):
return await self.loop.subprocess_shell(
lambda: TestProto(),
'echo 1',
**kwargs)
with self.subTest('paused, stdin pipe'):
transport, proto = self.loop.run_until_complete(
run(stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
__uvloop_sleep_after_fork=True))
self.assertIsNot(transport, None)
self.assertEqual(transport.get_returncode(), 0)
self.assertEqual(
set(proto.stages),
{
('CM', transport),
'PROC_EXIT',
('STDOUT', b'1\n'),
('STDOUT', 'LOST'),
('CL', 0, None)
})
with self.subTest('paused, no stdin'):
transport, proto = self.loop.run_until_complete(
run(stdin=None,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
__uvloop_sleep_after_fork=True))
self.assertIsNot(transport, None)
self.assertEqual(transport.get_returncode(), 0)
self.assertEqual(
set(proto.stages),
{
('CM', transport),
'PROC_EXIT',
('STDOUT', b'1\n'),
('STDOUT', 'LOST'),
('CL', 0, None)
})
with self.subTest('no pause, no stdin'):
transport, proto = self.loop.run_until_complete(
run(stdin=None,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE))
self.loop.run_until_complete(transport._wait())
self.assertEqual(transport.get_returncode(), 0)
self.assertIsNot(transport, None)
self.assertEqual(
set(proto.stages),
{
('CM', transport),
'PROC_EXIT',
('STDOUT', b'1\n'),
('STDOUT', 'LOST'),
('CL', 0, None)
})
def test_process_streams_redirect(self):
# This won't work for asyncio implementation of subprocess
async def test():
prog = bR'''
import sys
print('out', flush=True)
print('err', file=sys.stderr, flush=True)
'''
proc = await asyncio.create_subprocess_exec(
sys.executable, '-c', prog,
loop=self.loop)
out, err = await proc.communicate()
self.assertIsNone(out)
self.assertIsNone(err)
with tempfile.NamedTemporaryFile('w') as stdout:
with tempfile.NamedTemporaryFile('w') as stderr:
with contextlib.redirect_stdout(stdout):
with contextlib.redirect_stderr(stderr):
self.loop.run_until_complete(test())
stdout.flush()
stderr.flush()
with open(stdout.name, 'rb') as so:
self.assertEqual(so.read(), b'out\n')
with open(stderr.name, 'rb') as se:
self.assertEqual(se.read(), b'err\n')
class Test_AIO_Process(_TestProcess, tb.AIOTestCase):
pass
class TestAsyncio_UV_Process(_AsyncioTests, tb.UVTestCase):
pass
class TestAsyncio_AIO_Process(_AsyncioTests, tb.AIOTestCase):
pass
uvloop-0.8.0/tests/certs/ 0000775 0001750 0001750 00000000000 13047177422 016200 5 ustar travis travis 0000000 0000000 uvloop-0.8.0/tests/certs/ssl_key.pem 0000664 0001750 0001750 00000001624 13047176662 020364 0 ustar travis travis 0000000 0000000 -----BEGIN PRIVATE KEY-----
MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBANtb0+YrKuxevGpm
LrjaUhZSgz6zFAmuGFmKmUbdjmfv9zSmmdsQIksK++jK0Be9LeZy20j6ahOfuVa0
ufEmPoP7Fy4hXegKZR9cCWcIe/A6H2xWF1IIJLRTLaU8ol/I7T+um5HD5AwAwNPP
USNU0Eegmvp+xxWu3NX2m1Veot85AgMBAAECgYA3ZdZ673X0oexFlq7AAmrutkHt
CL7LvwrpOiaBjhyTxTeSNWzvtQBkIU8DOI0bIazA4UreAFffwtvEuPmonDb3F+Iq
SMAu42XcGyVZEl+gHlTPU9XRX7nTOXVt+MlRRRxL6t9GkGfUAXI3XxJDXW3c0vBK
UL9xqD8cORXOfE06rQJBAP8mEX1ERkR64Ptsoe4281vjTlNfIbs7NMPkUnrn9N/Y
BLhjNIfQ3HFZG8BTMLfX7kCS9D593DW5tV4Z9BP/c6cCQQDcFzCcVArNh2JSywOQ
ZfTfRbJg/Z5Lt9Fkngv1meeGNPgIMLN8Sg679pAOOWmzdMO3V706rNPzSVMME7E5
oPIfAkEA8pDddarP5tCvTTgUpmTFbakm0KoTZm2+FzHcnA4jRh+XNTjTOv98Y6Ik
eO5d1ZnKXseWvkZncQgxfdnMqqpj5wJAcNq/RVne1DbYlwWchT2Si65MYmmJ8t+F
0mcsULqjOnEMwf5e+ptq5LzwbyrHZYq5FNk7ocufPv/ZQrcSSC+cFwJBAKvOJByS
x56qyGeZLOQlWS2JS3KJo59XuLFGqcbgN9Om9xFa41Yb4N9NvplFivsvZdw3m1Q/
SPIXQuT8RMPDVNQ=
-----END PRIVATE KEY-----
uvloop-0.8.0/tests/certs/ssl_cert.pem 0000664 0001750 0001750 00000001543 13047176662 020531 0 ustar travis travis 0000000 0000000 -----BEGIN CERTIFICATE-----
MIICVDCCAb2gAwIBAgIJANfHOBkZr8JOMA0GCSqGSIb3DQEBBQUAMF8xCzAJBgNV
BAYTAlhZMRcwFQYDVQQHEw5DYXN0bGUgQW50aHJheDEjMCEGA1UEChMaUHl0aG9u
IFNvZnR3YXJlIEZvdW5kYXRpb24xEjAQBgNVBAMTCWxvY2FsaG9zdDAeFw0xMDEw
MDgyMzAxNTZaFw0yMDEwMDUyMzAxNTZaMF8xCzAJBgNVBAYTAlhZMRcwFQYDVQQH
Ew5DYXN0bGUgQW50aHJheDEjMCEGA1UEChMaUHl0aG9uIFNvZnR3YXJlIEZvdW5k
YXRpb24xEjAQBgNVBAMTCWxvY2FsaG9zdDCBnzANBgkqhkiG9w0BAQEFAAOBjQAw
gYkCgYEA21vT5isq7F68amYuuNpSFlKDPrMUCa4YWYqZRt2OZ+/3NKaZ2xAiSwr7
6MrQF70t5nLbSPpqE5+5VrS58SY+g/sXLiFd6AplH1wJZwh78DofbFYXUggktFMt
pTyiX8jtP66bkcPkDADA089RI1TQR6Ca+n7HFa7c1fabVV6i3zkCAwEAAaMYMBYw
FAYDVR0RBA0wC4IJbG9jYWxob3N0MA0GCSqGSIb3DQEBBQUAA4GBAHPctQBEQ4wd
BJ6+JcpIraopLn8BGhbjNWj40mmRqWB/NAWF6M5ne7KpGAu7tLeG4hb1zLaldK8G
lxy2GPSRF6LFS48dpEj2HbMv2nvv6xxalDMJ9+DicWgAKTQ6bcX2j3GUkCR0g/T1
CRlNBAAlvhKzO7Clpf9l0YKBEfraJByX
-----END CERTIFICATE-----
uvloop-0.8.0/tests/test_executors.py 0000664 0001750 0001750 00000002041 13047176662 020514 0 ustar travis travis 0000000 0000000 import asyncio
import concurrent.futures
from uvloop 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, loop=self.loop)
self.assertEqual(res, fib10)
await asyncio.sleep(0.01, loop=self.loop)
fib10 = [fib(i) for i in range(10)]
self.loop.run_until_complete(run())
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
uvloop-0.8.0/tests/test_pipes.py 0000664 0001750 0001750 00000017422 13047176662 017624 0 ustar travis travis 0000000 0000000 import asyncio
import io
import os
from asyncio import test_utils
from uvloop import _testbase as tb
# All tests are copied from asyncio (mostly as-is)
class MyReadPipeProto(asyncio.Protocol):
done = None
def __init__(self, loop=None):
self.state = ['INITIAL']
self.nbytes = 0
self.transport = None
if loop is not None:
self.done = asyncio.Future(loop=loop)
def connection_made(self, transport):
self.transport = transport
assert self.state == ['INITIAL'], self.state
self.state.append('CONNECTED')
def data_received(self, data):
assert self.state == ['INITIAL', 'CONNECTED'], self.state
self.nbytes += len(data)
def eof_received(self):
assert self.state == ['INITIAL', 'CONNECTED'], self.state
self.state.append('EOF')
def connection_lost(self, exc):
if 'EOF' not in self.state:
self.state.append('EOF') # It is okay if EOF is missed.
assert self.state == ['INITIAL', 'CONNECTED', 'EOF'], self.state
self.state.append('CLOSED')
if self.done:
self.done.set_result(None)
class MyWritePipeProto(asyncio.BaseProtocol):
done = None
def __init__(self, loop=None):
self.state = 'INITIAL'
self.transport = None
if loop is not None:
self.done = asyncio.Future(loop=loop)
def connection_made(self, transport):
self.transport = transport
assert self.state == 'INITIAL', self.state
self.state = 'CONNECTED'
def connection_lost(self, exc):
assert self.state == 'CONNECTED', self.state
self.state = 'CLOSED'
if self.done:
self.done.set_result(None)
class _BasePipeTest:
def test_read_pipe(self):
proto = MyReadPipeProto(loop=self.loop)
rpipe, wpipe = os.pipe()
pipeobj = io.open(rpipe, 'rb', 1024)
@asyncio.coroutine
def connect():
t, p = yield from self.loop.connect_read_pipe(
lambda: proto, pipeobj)
self.assertIs(p, proto)
self.assertIs(t, proto.transport)
self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
self.assertEqual(0, proto.nbytes)
self.loop.run_until_complete(connect())
os.write(wpipe, b'1')
test_utils.run_until(self.loop, lambda: proto.nbytes >= 1)
self.assertEqual(1, proto.nbytes)
os.write(wpipe, b'2345')
test_utils.run_until(self.loop, lambda: proto.nbytes >= 5)
self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
self.assertEqual(5, proto.nbytes)
os.close(wpipe)
self.loop.run_until_complete(proto.done)
self.assertEqual(
['INITIAL', 'CONNECTED', 'EOF', 'CLOSED'], proto.state)
# extra info is available
self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
def test_read_pty_output(self):
proto = MyReadPipeProto(loop=self.loop)
master, slave = os.openpty()
master_read_obj = io.open(master, 'rb', 0)
@asyncio.coroutine
def connect():
t, p = yield from self.loop.connect_read_pipe(lambda: proto,
master_read_obj)
self.assertIs(p, proto)
self.assertIs(t, proto.transport)
self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
self.assertEqual(0, proto.nbytes)
self.loop.run_until_complete(connect())
os.write(slave, b'1')
test_utils.run_until(self.loop, lambda: proto.nbytes)
self.assertEqual(1, proto.nbytes)
os.write(slave, b'2345')
test_utils.run_until(self.loop, lambda: proto.nbytes >= 5)
self.assertEqual(['INITIAL', 'CONNECTED'], proto.state)
self.assertEqual(5, proto.nbytes)
# On Linux, transport raises EIO when slave is closed --
# ignore it.
self.loop.set_exception_handler(lambda loop, ctx: None)
os.close(slave)
self.loop.run_until_complete(proto.done)
self.assertEqual(
['INITIAL', 'CONNECTED', 'EOF', 'CLOSED'], proto.state)
# extra info is available
self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
def test_write_pipe(self):
rpipe, wpipe = os.pipe()
os.set_blocking(rpipe, False)
pipeobj = io.open(wpipe, 'wb', 1024)
proto = MyWritePipeProto(loop=self.loop)
connect = self.loop.connect_write_pipe(lambda: proto, pipeobj)
transport, p = self.loop.run_until_complete(connect)
self.assertIs(p, proto)
self.assertIs(transport, proto.transport)
self.assertEqual('CONNECTED', proto.state)
transport.write(b'1')
data = bytearray()
def reader(data):
try:
chunk = os.read(rpipe, 1024)
except BlockingIOError:
return len(data)
data += chunk
return len(data)
test_utils.run_until(self.loop, lambda: reader(data) >= 1)
self.assertEqual(b'1', data)
transport.write(b'2345')
test_utils.run_until(self.loop, lambda: reader(data) >= 5)
self.assertEqual(b'12345', data)
self.assertEqual('CONNECTED', proto.state)
os.close(rpipe)
# extra info is available
self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
# close connection
proto.transport.close()
self.loop.run_until_complete(proto.done)
self.assertEqual('CLOSED', proto.state)
def test_write_pipe_disconnect_on_close(self):
rsock, wsock = test_utils.socketpair()
rsock.setblocking(False)
pipeobj = io.open(wsock.detach(), 'wb', 1024)
proto = MyWritePipeProto(loop=self.loop)
connect = self.loop.connect_write_pipe(lambda: proto, pipeobj)
transport, p = self.loop.run_until_complete(connect)
self.assertIs(p, proto)
self.assertIs(transport, proto.transport)
self.assertEqual('CONNECTED', proto.state)
transport.write(b'1')
data = self.loop.run_until_complete(self.loop.sock_recv(rsock, 1024))
self.assertEqual(b'1', data)
rsock.close()
self.loop.run_until_complete(proto.done)
self.assertEqual('CLOSED', proto.state)
def test_write_pty(self):
master, slave = os.openpty()
os.set_blocking(master, False)
slave_write_obj = io.open(slave, 'wb', 0)
proto = MyWritePipeProto(loop=self.loop)
connect = self.loop.connect_write_pipe(lambda: proto, slave_write_obj)
transport, p = self.loop.run_until_complete(connect)
self.assertIs(p, proto)
self.assertIs(transport, proto.transport)
self.assertEqual('CONNECTED', proto.state)
transport.write(b'1')
data = bytearray()
def reader(data):
try:
chunk = os.read(master, 1024)
except BlockingIOError:
return len(data)
data += chunk
return len(data)
test_utils.run_until(self.loop, lambda: reader(data) >= 1,
timeout=10)
self.assertEqual(b'1', data)
transport.write(b'2345')
test_utils.run_until(self.loop, lambda: reader(data) >= 5,
timeout=10)
self.assertEqual(b'12345', data)
self.assertEqual('CONNECTED', proto.state)
os.close(master)
# extra info is available
self.assertIsNotNone(proto.transport.get_extra_info('pipe'))
# close connection
proto.transport.close()
self.loop.run_until_complete(proto.done)
self.assertEqual('CLOSED', proto.state)
class Test_UV_Pipes(_BasePipeTest, tb.UVTestCase):
pass
class Test_AIO_Pipes(_BasePipeTest, tb.AIOTestCase):
pass
uvloop-0.8.0/tests/test_sockets.py 0000664 0001750 0001750 00000010661 13047176662 020155 0 ustar travis travis 0000000 0000000 import asyncio
import select
import socket
import sys
import unittest
from uvloop import _testbase as tb
_SIZE = 1024 * 1024
class _TestSockets:
async def recv_all(self, sock, nbytes):
buf = b''
while len(buf) < nbytes:
buf += await self.loop.sock_recv(sock, nbytes - len(buf))
return buf
def test_socket_connect_recv_send(self):
if self.is_asyncio_loop() and sys.version_info[:3] == (3, 5, 2):
# See https://github.com/python/asyncio/pull/366 for details.
raise unittest.SkipTest()
def srv_gen():
yield tb.write(b'helo')
data = yield tb.read(4 * _SIZE)
self.assertEqual(data, b'ehlo' * _SIZE)
yield tb.write(b'O')
yield tb.write(b'K')
# We use @asyncio.coroutine & `yield from` to test
# the compatibility of Cython's 'async def' coroutines.
@asyncio.coroutine
def client(sock, addr):
yield from self.loop.sock_connect(sock, addr)
data = yield from self.recv_all(sock, 4)
self.assertEqual(data, b'helo')
yield from self.loop.sock_sendall(sock, b'ehlo' * _SIZE)
data = yield from self.recv_all(sock, 2)
self.assertEqual(data, b'OK')
with tb.tcp_server(srv_gen) as srv:
sock = socket.socket()
with sock:
sock.setblocking(False)
self.loop.run_until_complete(client(sock, srv.addr))
def test_socket_accept_recv_send(self):
async def server():
sock = socket.socket()
sock.setblocking(False)
with sock:
sock.bind(('127.0.0.1', 0))
sock.listen()
fut = self.loop.run_in_executor(None, client,
sock.getsockname())
client_sock, _ = await self.loop.sock_accept(sock)
with client_sock:
data = await self.recv_all(client_sock, _SIZE)
self.assertEqual(data, b'a' * _SIZE)
await fut
def client(addr):
sock = socket.socket()
with sock:
sock.connect(addr)
sock.sendall(b'a' * _SIZE)
self.loop.run_until_complete(server())
def test_socket_failed_connect(self):
sock = socket.socket()
with sock:
sock.bind(('127.0.0.1', 0))
addr = sock.getsockname()
async def run():
sock = socket.socket()
with sock:
sock.setblocking(False)
with self.assertRaises(ConnectionRefusedError):
await self.loop.sock_connect(sock, addr)
self.loop.run_until_complete(run())
def test_socket_blocking_error(self):
self.loop.set_debug(True)
sock = socket.socket()
with sock:
with self.assertRaisesRegex(ValueError, 'must be non-blocking'):
self.loop.run_until_complete(
self.loop.sock_recv(sock, 0))
with self.assertRaisesRegex(ValueError, 'must be non-blocking'):
self.loop.run_until_complete(
self.loop.sock_sendall(sock, b''))
with self.assertRaisesRegex(ValueError, 'must be non-blocking'):
self.loop.run_until_complete(
self.loop.sock_accept(sock))
with self.assertRaisesRegex(ValueError, 'must be non-blocking'):
self.loop.run_until_complete(
self.loop.sock_connect(sock, (b'', 0)))
class TestUVSockets(_TestSockets, tb.UVTestCase):
@unittest.skipUnless(hasattr(select, 'epoll'), 'Linux only test')
def test_socket_sync_remove(self):
# See https://github.com/MagicStack/uvloop/issues/61 for details
sock = socket.socket()
epoll = select.epoll.fromfd(self.loop._get_backend_id())
try:
cb = lambda: None
sock.bind(('127.0.0.1', 0))
sock.listen(0)
fd = sock.fileno()
self.loop.add_reader(fd, cb)
self.loop.run_until_complete(asyncio.sleep(0.01, loop=self.loop))
self.loop.remove_reader(fd)
with self.assertRaises(FileNotFoundError):
epoll.modify(fd, 0)
finally:
sock.close()
self.loop.close()
epoll.close()
class TestAIOSockets(_TestSockets, tb.AIOTestCase):
pass
uvloop-0.8.0/tests/test_tcp.py 0000664 0001750 0001750 00000076454 13047176662 017304 0 ustar travis travis 0000000 0000000 import asyncio
import gc
import socket
import unittest.mock
import uvloop
import ssl
import sys
import threading
from uvloop import _testbase as tb
class MyBaseProto(asyncio.Protocol):
connected = None
done = None
def __init__(self, loop=None):
self.transport = None
self.state = 'INITIAL'
self.nbytes = 0
if loop is not None:
self.connected = asyncio.Future(loop=loop)
self.done = asyncio.Future(loop=loop)
def connection_made(self, transport):
self.transport = transport
assert self.state == 'INITIAL', self.state
self.state = 'CONNECTED'
if self.connected:
self.connected.set_result(None)
def data_received(self, data):
assert self.state == 'CONNECTED', self.state
self.nbytes += len(data)
def eof_received(self):
assert self.state == 'CONNECTED', self.state
self.state = 'EOF'
def connection_lost(self, exc):
assert self.state in ('CONNECTED', 'EOF'), self.state
self.state = 'CLOSED'
if self.done:
self.done.set_result(None)
class _TestTCP:
def test_create_server_1(self):
if self.is_asyncio_loop() and sys.version_info[:3] == (3, 5, 2):
# See https://github.com/python/asyncio/pull/366 for details.
raise unittest.SkipTest()
CNT = 0 # number of clients that were successful
TOTAL_CNT = 25 # total number of clients that test will create
TIMEOUT = 5.0 # timeout for this test
A_DATA = b'A' * 1024 * 1024
B_DATA = b'B' * 1024 * 1024
async def handle_client(reader, writer):
nonlocal CNT
data = await reader.readexactly(len(A_DATA))
self.assertEqual(data, A_DATA)
writer.write(b'OK')
data = await reader.readexactly(len(B_DATA))
self.assertEqual(data, B_DATA)
writer.writelines([b'S', b'P'])
writer.write(bytearray(b'A'))
writer.write(memoryview(b'M'))
await writer.drain()
writer.close()
CNT += 1
async def test_client(addr):
sock = socket.socket()
with sock:
sock.setblocking(False)
await self.loop.sock_connect(sock, addr)
await self.loop.sock_sendall(sock, A_DATA)
buf = b''
while len(buf) != 2:
buf += await self.loop.sock_recv(sock, 1)
self.assertEqual(buf, b'OK')
await self.loop.sock_sendall(sock, B_DATA)
buf = b''
while len(buf) != 4:
buf += await self.loop.sock_recv(sock, 1)
self.assertEqual(buf, b'SPAM')
async def start_server():
nonlocal CNT
CNT = 0
addrs = ('127.0.0.1', 'localhost')
if not isinstance(self.loop, uvloop.Loop):
# Hack to let tests run on Python 3.5.0
# (asyncio doesn't support multiple hosts in 3.5.0)
addrs = '127.0.0.1'
srv = await asyncio.start_server(
handle_client,
addrs, 0,
family=socket.AF_INET,
loop=self.loop)
srv_socks = srv.sockets
self.assertTrue(srv_socks)
addr = srv_socks[0].getsockname()
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(test_client(addr))
await asyncio.wait_for(
asyncio.gather(*tasks, loop=self.loop),
TIMEOUT, loop=self.loop)
self.loop.call_soon(srv.close)
await srv.wait_closed()
# Check that the server cleaned-up proxy-sockets
for srv_sock in srv_socks:
self.assertEqual(srv_sock.fileno(), -1)
async def start_server_sock():
nonlocal CNT
CNT = 0
sock = socket.socket()
sock.bind(('127.0.0.1', 0))
addr = sock.getsockname()
srv = await asyncio.start_server(
handle_client,
None, None,
family=socket.AF_INET,
loop=self.loop,
sock=sock)
srv_socks = srv.sockets
self.assertTrue(srv_socks)
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(test_client(addr))
await asyncio.wait_for(
asyncio.gather(*tasks, loop=self.loop),
TIMEOUT, loop=self.loop)
srv.close()
await srv.wait_closed()
# Check that the server cleaned-up proxy-sockets
for srv_sock in srv_socks:
self.assertEqual(srv_sock.fileno(), -1)
self.loop.run_until_complete(start_server())
self.assertEqual(CNT, TOTAL_CNT)
self.loop.run_until_complete(start_server_sock())
self.assertEqual(CNT, TOTAL_CNT)
def test_create_server_2(self):
with self.assertRaisesRegex(ValueError, 'nor sock were specified'):
self.loop.run_until_complete(self.loop.create_server(object))
def test_create_server_3(self):
''' check ephemeral port can be used '''
async def start_server_ephemeral_ports():
for port_sentinel in [0, None]:
srv = await self.loop.create_server(
asyncio.Protocol,
'127.0.0.1', port_sentinel,
family=socket.AF_INET)
srv_socks = srv.sockets
self.assertTrue(srv_socks)
host, port = srv_socks[0].getsockname()
self.assertNotEqual(0, port)
self.loop.call_soon(srv.close)
await srv.wait_closed()
# Check that the server cleaned-up proxy-sockets
for srv_sock in srv_socks:
self.assertEqual(srv_sock.fileno(), -1)
self.loop.run_until_complete(start_server_ephemeral_ports())
def test_create_server_4(self):
sock = socket.socket()
sock.bind(('127.0.0.1', 0))
with sock:
addr = sock.getsockname()
with self.assertRaisesRegex(OSError,
"error while attempting.*\('127.*: "
"address already in use"):
self.loop.run_until_complete(
self.loop.create_server(object, *addr))
def test_create_server_5(self):
# Test that create_server sets the TCP_IPV6ONLY flag,
# so it can bind to ipv4 and ipv6 addresses
# simultaneously.
port = tb.find_free_port()
async def runner():
srv = await self.loop.create_server(
asyncio.Protocol,
None, port)
srv.close()
await srv.wait_closed()
self.loop.run_until_complete(runner())
def test_create_server_6(self):
if not hasattr(socket, 'SO_REUSEPORT'):
raise unittest.SkipTest(
'The system does not support SO_REUSEPORT')
if sys.version_info[:3] < (3, 5, 1):
raise unittest.SkipTest(
'asyncio in CPython 3.5.0 does not have the '
'reuse_port argument')
port = tb.find_free_port()
async def runner():
srv1 = await self.loop.create_server(
asyncio.Protocol,
None, port,
reuse_port=True)
srv2 = await self.loop.create_server(
asyncio.Protocol,
None, port,
reuse_port=True)
srv1.close()
srv2.close()
await srv1.wait_closed()
await srv2.wait_closed()
self.loop.run_until_complete(runner())
def test_create_connection_1(self):
CNT = 0
TOTAL_CNT = 100
def server():
data = yield tb.read(4)
self.assertEqual(data, b'AAAA')
yield tb.write(b'OK')
data = yield tb.read(4)
self.assertEqual(data, b'BBBB')
yield tb.write(b'SPAM')
async def client(addr):
reader, writer = await asyncio.open_connection(
*addr,
loop=self.loop)
writer.write(b'AAAA')
self.assertEqual(await reader.readexactly(2), b'OK')
re = r'(a bytes-like object)|(must be byte-ish)'
with self.assertRaisesRegex(TypeError, re):
writer.write('AAAA')
writer.write(b'BBBB')
self.assertEqual(await reader.readexactly(4), b'SPAM')
nonlocal CNT
CNT += 1
writer.close()
async def client_2(addr):
sock = socket.socket()
sock.connect(addr)
reader, writer = await asyncio.open_connection(
sock=sock,
loop=self.loop)
writer.write(b'AAAA')
self.assertEqual(await reader.readexactly(2), b'OK')
writer.write(b'BBBB')
self.assertEqual(await reader.readexactly(4), b'SPAM')
nonlocal CNT
CNT += 1
writer.close()
def run(coro):
nonlocal CNT
CNT = 0
srv = tb.tcp_server(server,
max_clients=TOTAL_CNT,
backlog=TOTAL_CNT)
srv.start()
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(coro(srv.addr))
self.loop.run_until_complete(
asyncio.gather(*tasks, loop=self.loop))
srv.join()
self.assertEqual(CNT, TOTAL_CNT)
run(client)
run(client_2)
def test_create_connection_2(self):
sock = socket.socket()
with sock:
sock.bind(('127.0.0.1', 0))
addr = sock.getsockname()
async def client():
reader, writer = await asyncio.open_connection(
*addr,
loop=self.loop)
async def runner():
with self.assertRaises(ConnectionRefusedError):
await client()
self.loop.run_until_complete(runner())
def test_create_connection_3(self):
CNT = 0
TOTAL_CNT = 100
def server():
data = yield tb.read(4)
self.assertEqual(data, b'AAAA')
yield tb.close()
async def client(addr):
reader, writer = await asyncio.open_connection(
*addr,
loop=self.loop)
writer.write(b'AAAA')
with self.assertRaises(asyncio.IncompleteReadError):
await reader.readexactly(10)
writer.close()
nonlocal CNT
CNT += 1
def run(coro):
nonlocal CNT
CNT = 0
srv = tb.tcp_server(server,
max_clients=TOTAL_CNT,
backlog=TOTAL_CNT)
srv.start()
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(coro(srv.addr))
self.loop.run_until_complete(
asyncio.gather(*tasks, loop=self.loop))
srv.join()
self.assertEqual(CNT, TOTAL_CNT)
run(client)
def test_create_connection_4(self):
sock = socket.socket()
sock.close()
async def client():
reader, writer = await asyncio.open_connection(
sock=sock,
loop=self.loop)
async def runner():
with self.assertRaisesRegex(OSError, 'Bad file'):
await client()
self.loop.run_until_complete(runner())
def test_transport_shutdown(self):
CNT = 0 # number of clients that were successful
TOTAL_CNT = 100 # total number of clients that test will create
TIMEOUT = 5.0 # timeout for this test
async def handle_client(reader, writer):
nonlocal CNT
data = await reader.readexactly(4)
self.assertEqual(data, b'AAAA')
writer.write(b'OK')
writer.write_eof()
writer.write_eof()
await writer.drain()
writer.close()
CNT += 1
async def test_client(addr):
reader, writer = await asyncio.open_connection(
*addr,
loop=self.loop)
writer.write(b'AAAA')
data = await reader.readexactly(2)
self.assertEqual(data, b'OK')
writer.close()
async def start_server():
nonlocal CNT
CNT = 0
srv = await asyncio.start_server(
handle_client,
'127.0.0.1', 0,
family=socket.AF_INET,
loop=self.loop)
srv_socks = srv.sockets
self.assertTrue(srv_socks)
addr = srv_socks[0].getsockname()
tasks = []
for _ in range(TOTAL_CNT):
tasks.append(test_client(addr))
await asyncio.wait_for(
asyncio.gather(*tasks, loop=self.loop),
TIMEOUT, loop=self.loop)
srv.close()
await srv.wait_closed()
self.loop.run_until_complete(start_server())
self.assertEqual(CNT, TOTAL_CNT)
def test_tcp_handle_exception_in_connection_made(self):
# Test that if connection_made raises an exception,
# 'create_connection' still returns.
# Silence error logging
self.loop.set_exception_handler(lambda *args: None)
fut = asyncio.Future(loop=self.loop)
connection_lost_called = asyncio.Future(loop=self.loop)
async def server(reader, writer):
try:
await reader.read()
finally:
writer.close()
class Proto(asyncio.Protocol):
def connection_made(self, tr):
1 / 0
def connection_lost(self, exc):
connection_lost_called.set_result(exc)
srv = self.loop.run_until_complete(asyncio.start_server(
server,
'127.0.0.1', 0,
family=socket.AF_INET,
loop=self.loop))
async def runner():
tr, pr = await asyncio.wait_for(
self.loop.create_connection(
Proto, *srv.sockets[0].getsockname()),
timeout=1.0, loop=self.loop)
fut.set_result(None)
tr.close()
self.loop.run_until_complete(runner())
srv.close()
self.loop.run_until_complete(srv.wait_closed())
self.loop.run_until_complete(fut)
self.assertIsNone(
self.loop.run_until_complete(connection_lost_called))
class Test_UV_TCP(_TestTCP, tb.UVTestCase):
def test_transport_get_extra_info(self):
# This tests is only for uvloop. asyncio should pass it
# too in Python 3.6.
fut = asyncio.Future(loop=self.loop)
async def handle_client(reader, writer):
with self.assertRaises(asyncio.IncompleteReadError):
data = await reader.readexactly(4)
writer.close()
# Previously, when we used socket.fromfd to create a socket
# for UVTransports (to make get_extra_info() work), a duplicate
# of the socket was created, preventing UVTransport from being
# properly closed.
# This test ensures that server handle will receive an EOF
# and finish the request.
fut.set_result(None)
async def test_client(addr):
t, p = await self.loop.create_connection(
lambda: asyncio.Protocol(), *addr)
if hasattr(t, 'get_protocol'):
p2 = asyncio.Protocol()
self.assertIs(t.get_protocol(), p)
t.set_protocol(p2)
self.assertIs(t.get_protocol(), p2)
t.set_protocol(p)
self.assertFalse(t._paused)
t.pause_reading()
self.assertTrue(t._paused)
t.resume_reading()
self.assertFalse(t._paused)
sock = t.get_extra_info('socket')
self.assertIs(sock, t.get_extra_info('socket'))
sockname = sock.getsockname()
peername = sock.getpeername()
with self.assertRaisesRegex(RuntimeError, 'is used by transport'):
self.loop.add_writer(sock.fileno(), lambda: None)
with self.assertRaisesRegex(RuntimeError, 'is used by transport'):
self.loop.remove_writer(sock.fileno())
with self.assertRaisesRegex(RuntimeError, 'is used by transport'):
self.loop.add_reader(sock.fileno(), lambda: None)
with self.assertRaisesRegex(RuntimeError, 'is used by transport'):
self.loop.remove_reader(sock.fileno())
self.assertTrue(isinstance(sock, socket.socket))
self.assertEqual(t.get_extra_info('sockname'),
sockname)
self.assertEqual(t.get_extra_info('peername'),
peername)
t.write(b'OK') # We want server to fail.
self.assertFalse(t._closing)
t.abort()
self.assertTrue(t._closing)
await fut
# Test that peername and sockname are available after
# the transport is closed.
self.assertEqual(t.get_extra_info('peername'),
peername)
self.assertEqual(t.get_extra_info('sockname'),
sockname)
async def start_server():
srv = await asyncio.start_server(
handle_client,
'127.0.0.1', 0,
family=socket.AF_INET,
loop=self.loop)
addr = srv.sockets[0].getsockname()
await test_client(addr)
srv.close()
await srv.wait_closed()
self.loop.run_until_complete(start_server())
def test_create_server_float_backlog(self):
# asyncio spits out a warning we cannot suppress
async def runner(bl):
await self.loop.create_server(
asyncio.Protocol,
None, 0, backlog=bl)
for bl in (1.1, '1'):
with self.subTest(backlog=bl):
with self.assertRaisesRegex(TypeError, 'integer'):
self.loop.run_until_complete(runner(bl))
def test_many_small_writes(self):
N = 10000
TOTAL = 0
fut = self.loop.create_future()
async def server(reader, writer):
nonlocal TOTAL
while True:
d = await reader.read(10000)
if not d:
break
TOTAL += len(d)
fut.set_result(True)
writer.close()
async def run():
srv = await asyncio.start_server(
server,
'127.0.0.1', 0,
family=socket.AF_INET,
loop=self.loop)
addr = srv.sockets[0].getsockname()
r, w = await asyncio.open_connection(*addr, loop=self.loop)
DATA = b'x' * 102400
# Test _StreamWriteContext with short sequences of writes
w.write(DATA)
await w.drain()
for _ in range(3):
w.write(DATA)
await w.drain()
for _ in range(10):
w.write(DATA)
await w.drain()
for _ in range(N):
w.write(DATA)
try:
w.write('a')
except TypeError:
pass
await w.drain()
for _ in range(N):
w.write(DATA)
await w.drain()
w.close()
await fut
srv.close()
await srv.wait_closed()
self.assertEqual(TOTAL, N * 2 * len(DATA) + 14 * len(DATA))
self.loop.run_until_complete(run())
def test_tcp_handle_unclosed_gc(self):
fut = self.loop.create_future()
async def server(reader, writer):
writer.transport.abort()
fut.set_result(True)
async def run():
addr = srv.sockets[0].getsockname()
await asyncio.open_connection(*addr, loop=self.loop)
await fut
srv.close()
await srv.wait_closed()
srv = self.loop.run_until_complete(asyncio.start_server(
server,
'127.0.0.1', 0,
family=socket.AF_INET,
loop=self.loop))
if self.loop.get_debug():
rx = r'unclosed resource = (3, 5, 1):
extra['reuse_port'] = True
coro = self.loop.create_datagram_endpoint(
lambda: MyDatagramProto(loop=self.loop),
family=socket.AF_INET,
remote_addr=None if lc is None else (host, port),
**extra)
transport, client = self.loop.run_until_complete(coro)
self.assertIsInstance(client, MyDatagramProto)
self.assertEqual('INITIALIZED', client.state)
self.assertIs(client.transport, transport)
transport.sendto(b'xxx', (host, port) if lc is None else None)
test_utils.run_until(self.loop, lambda: server.nbytes)
self.assertEqual(3, server.nbytes)
test_utils.run_until(self.loop, lambda: client.nbytes)
# received
self.assertEqual(8, client.nbytes)
# extra info is available
self.assertIsNotNone(transport.get_extra_info('sockname'))
# close connection
transport.close()
self.loop.run_until_complete(client.done)
self.assertEqual('CLOSED', client.state)
server.transport.close()
self.loop.run_until_complete(server.done)
def test_create_datagram_endpoint_sock(self):
sock = None
local_address = ('127.0.0.1', 0)
infos = self.loop.run_until_complete(
self.loop.getaddrinfo(
*local_address, type=socket.SOCK_DGRAM))
for family, type, proto, cname, address in infos:
try:
sock = socket.socket(family=family, type=type, proto=proto)
sock.setblocking(False)
sock.bind(address)
except:
pass
else:
break
else:
assert False, 'Can not create socket.'
with sock:
try:
f = self.loop.create_datagram_endpoint(
lambda: MyDatagramProto(loop=self.loop), sock=sock)
except TypeError as ex:
# asyncio in 3.5.0 doesn't have the 'sock' argument
if 'got an unexpected keyword argument' not in ex.args[0]:
raise
else:
tr, pr = self.loop.run_until_complete(f)
self.assertIsInstance(pr, MyDatagramProto)
tr.close()
self.loop.run_until_complete(pr.done)
class Test_UV_UDP(_TestUDP, tb.UVTestCase):
def test_create_datagram_endpoint_wrong_sock(self):
sock = socket.socket(socket.AF_INET)
with sock:
coro = self.loop.create_datagram_endpoint(lambda: None, sock=sock)
with self.assertRaisesRegex(ValueError,
'A UDP Socket was expected'):
self.loop.run_until_complete(coro)
class Test_AIO_UDP(_TestUDP, tb.AIOTestCase):
pass
uvloop-0.8.0/tests/test_cython.py 0000664 0001750 0001750 00000001675 13047176662 020013 0 ustar travis travis 0000000 0000000 import asyncio
from uvloop._testbase import UVTestCase
class TestCythonIntegration(UVTestCase):
def test_cython_coro_is_coroutine(self):
from uvloop.loop import _test_coroutine_1
from asyncio.coroutines import _format_coroutine
coro = _test_coroutine_1()
self.assertEqual(_format_coroutine(coro), '_test_coroutine_1()')
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, loop=self.loop)
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)
_format_coroutine(coro) # This line checks against Cython segfault
coro.close()
uvloop-0.8.0/tests/test_signals.py 0000664 0001750 0001750 00000016114 13047176662 020141 0 ustar travis travis 0000000 0000000 import asyncio
import signal
import subprocess
import sys
import time
from uvloop import _testbase as tb
DELAY = 0.1
class _TestSignal:
NEW_LOOP = None
@tb.silence_long_exec_warning()
def test_signals_sigint_pycode_stop(self):
async def runner():
PROG = R"""\
import asyncio
import uvloop
import time
from uvloop import _testbase as tb
async def worker():
print('READY', flush=True)
time.sleep(200)
@tb.silence_long_exec_warning()
def run():
loop = """ + self.NEW_LOOP + """
asyncio.set_event_loop(loop)
try:
loop.run_until_complete(worker())
finally:
loop.close()
run()
"""
proc = await asyncio.create_subprocess_exec(
sys.executable, b'-c', PROG,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
loop=self.loop)
await proc.stdout.readline()
time.sleep(DELAY)
proc.send_signal(signal.SIGINT)
out, err = await proc.communicate()
self.assertIn(b'KeyboardInterrupt', err)
self.assertEqual(out, b'')
self.loop.run_until_complete(runner())
@tb.silence_long_exec_warning()
def test_signals_sigint_pycode_continue(self):
async def runner():
PROG = R"""\
import asyncio
import uvloop
import time
from uvloop import _testbase as tb
async def worker():
print('READY', flush=True)
try:
time.sleep(200)
except KeyboardInterrupt:
print("oups")
await asyncio.sleep(0.5)
print('done')
@tb.silence_long_exec_warning()
def run():
loop = """ + self.NEW_LOOP + """
asyncio.set_event_loop(loop)
try:
loop.run_until_complete(worker())
finally:
loop.close()
run()
"""
proc = await asyncio.create_subprocess_exec(
sys.executable, b'-c', PROG,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
loop=self.loop)
await proc.stdout.readline()
time.sleep(DELAY)
proc.send_signal(signal.SIGINT)
out, err = await proc.communicate()
self.assertEqual(err, b'')
self.assertEqual(out, b'oups\ndone\n')
self.loop.run_until_complete(runner())
@tb.silence_long_exec_warning()
def test_signals_sigint_uvcode(self):
async def runner():
PROG = R"""\
import asyncio
import uvloop
srv = None
async def worker():
global srv
cb = lambda *args: None
srv = await asyncio.start_server(cb, '127.0.0.1', 0)
print('READY', flush=True)
loop = """ + self.NEW_LOOP + """
asyncio.set_event_loop(loop)
loop.create_task(worker())
try:
loop.run_forever()
finally:
srv.close()
loop.run_until_complete(srv.wait_closed())
loop.close()
"""
proc = await asyncio.create_subprocess_exec(
sys.executable, b'-c', PROG,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
loop=self.loop)
await proc.stdout.readline()
time.sleep(DELAY)
proc.send_signal(signal.SIGINT)
out, err = await proc.communicate()
self.assertIn(b'KeyboardInterrupt', err)
self.loop.run_until_complete(runner())
@tb.silence_long_exec_warning()
def test_signals_sigint_and_custom_handler(self):
async def runner():
PROG = R"""\
import asyncio
import signal
import uvloop
srv = None
async def worker():
global srv
cb = lambda *args: None
srv = await asyncio.start_server(cb, '127.0.0.1', 0)
print('READY', flush=True)
def handler_sig(say):
print(say, flush=True)
exit()
def handler_hup(say):
print(say, flush=True)
loop = """ + self.NEW_LOOP + """
loop.add_signal_handler(signal.SIGINT, handler_sig, '!s-int!')
loop.add_signal_handler(signal.SIGHUP, handler_hup, '!s-hup!')
asyncio.set_event_loop(loop)
loop.create_task(worker())
try:
loop.run_forever()
finally:
srv.close()
loop.run_until_complete(srv.wait_closed())
loop.close()
"""
proc = await asyncio.create_subprocess_exec(
sys.executable, b'-c', PROG,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
loop=self.loop)
await proc.stdout.readline()
time.sleep(DELAY)
proc.send_signal(signal.SIGHUP)
time.sleep(DELAY)
proc.send_signal(signal.SIGINT)
out, err = await proc.communicate()
self.assertEqual(err, b'')
self.assertIn(b'!s-hup!', out)
self.assertIn(b'!s-int!', out)
self.loop.run_until_complete(runner())
@tb.silence_long_exec_warning()
def test_signals_and_custom_handler_1(self):
async def runner():
PROG = R"""\
import asyncio
import signal
import uvloop
srv = None
async def worker():
global srv
cb = lambda *args: None
srv = await asyncio.start_server(cb, '127.0.0.1', 0)
print('READY', flush=True)
def handler1():
print("GOTIT", flush=True)
def handler2():
assert loop.remove_signal_handler(signal.SIGUSR1)
print("REMOVED", flush=True)
def handler_hup():
exit()
loop = """ + self.NEW_LOOP + """
asyncio.set_event_loop(loop)
loop.add_signal_handler(signal.SIGUSR1, handler1)
loop.add_signal_handler(signal.SIGUSR2, handler2)
loop.add_signal_handler(signal.SIGHUP, handler_hup)
loop.create_task(worker())
try:
loop.run_forever()
finally:
srv.close()
loop.run_until_complete(srv.wait_closed())
loop.close()
"""
proc = await asyncio.create_subprocess_exec(
sys.executable, b'-c', PROG,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
loop=self.loop)
await proc.stdout.readline()
time.sleep(DELAY)
proc.send_signal(signal.SIGUSR1)
time.sleep(DELAY)
proc.send_signal(signal.SIGUSR1)
time.sleep(DELAY)
proc.send_signal(signal.SIGUSR2)
time.sleep(DELAY)
proc.send_signal(signal.SIGUSR1)
time.sleep(DELAY)
proc.send_signal(signal.SIGUSR1)
time.sleep(DELAY)
proc.send_signal(signal.SIGHUP)
out, err = await proc.communicate()
self.assertEqual(err, b'')
self.assertEqual(b'GOTIT\nGOTIT\nREMOVED\n', out)
self.loop.run_until_complete(runner())
def test_signals_invalid_signal(self):
with self.assertRaisesRegex(RuntimeError,
'sig {} cannot be caught'.format(
signal.SIGKILL)):
self.loop.add_signal_handler(signal.SIGKILL, lambda *a: None)
def test_signals_coro_callback(self):
async def coro(): pass
with self.assertRaisesRegex(TypeError, 'coroutines cannot be used'):
self.loop.add_signal_handler(signal.SIGHUP, coro)
class Test_UV_Signals(_TestSignal, tb.UVTestCase):
NEW_LOOP = 'uvloop.new_event_loop()'
class Test_AIO_Signals(_TestSignal, tb.AIOTestCase):
NEW_LOOP = 'asyncio.new_event_loop()'
uvloop-0.8.0/tests/test_tasks.py 0000664 0001750 0001750 00000031425 13047176662 017630 0 ustar travis travis 0000000 0000000 # LICENSE: PSF.
import asyncio
from asyncio import test_utils
from uvloop import _testbase as tb
class Dummy:
def __repr__(self):
return ''
def __call__(self, *args):
pass
def format_coroutine(qualname, state, src, source_traceback, generator=False):
if generator:
state = '%s' % state
else:
state = '%s, defined' % state
if source_traceback is not None:
frame = source_traceback[-1]
return ('coro=<%s() %s at %s> created at %s:%s'
% (qualname, state, src, frame[0], frame[1]))
else:
return 'coro=<%s() %s at %s>' % (qualname, state, src)
class _TestTasks:
def test_task_repr(self):
self.loop.set_debug(False)
@asyncio.coroutine
def notmuch():
yield from []
return 'abc'
# test coroutine function
self.assertEqual(notmuch.__name__, 'notmuch')
self.assertEqual(notmuch.__qualname__,
'_TestTasks.test_task_repr..notmuch')
self.assertEqual(notmuch.__module__, __name__)
filename, lineno = test_utils.get_function_source(notmuch)
src = "%s:%s" % (filename, lineno)
# test coroutine object
gen = notmuch()
coro_qualname = '_TestTasks.test_task_repr..notmuch'
self.assertEqual(gen.__name__, 'notmuch')
self.assertEqual(gen.__qualname__, coro_qualname)
# test pending Task
t = asyncio.Task(gen, loop=self.loop)
t.add_done_callback(Dummy())
coro = format_coroutine(coro_qualname, 'running', src,
t._source_traceback, generator=True)
self.assertEqual(repr(t),
'()]>' % coro)
# test canceling Task
t.cancel() # Does not take immediate effect!
self.assertEqual(repr(t),
'()]>' % coro)
# test canceled Task
self.assertRaises(asyncio.CancelledError,
self.loop.run_until_complete, t)
coro = format_coroutine(coro_qualname, 'done', src,
t._source_traceback)
self.assertEqual(repr(t),
'' % coro)
# test finished Task
t = asyncio.Task(notmuch(), loop=self.loop)
self.loop.run_until_complete(t)
coro = format_coroutine(coro_qualname, 'done', src,
t._source_traceback)
self.assertEqual(repr(t),
"" % coro)
def test_task_basics(self):
@asyncio.coroutine
def outer():
a = yield from inner1()
b = yield from inner2()
return a + b
@asyncio.coroutine
def inner1():
return 42
@asyncio.coroutine
def inner2():
return 1000
t = outer()
self.assertEqual(self.loop.run_until_complete(t), 1042)
def test_task_cancel_yield(self):
@asyncio.coroutine
def task():
while True:
yield
return 12
t = self.create_task(task())
test_utils.run_briefly(self.loop) # start coro
t.cancel()
self.assertRaises(
asyncio.CancelledError, self.loop.run_until_complete, t)
self.assertTrue(t.done())
self.assertTrue(t.cancelled())
self.assertFalse(t.cancel())
def test_task_cancel_inner_future(self):
f = self.create_future()
@asyncio.coroutine
def task():
yield from f
return 12
t = self.create_task(task())
test_utils.run_briefly(self.loop) # start task
f.cancel()
with self.assertRaises(asyncio.CancelledError):
self.loop.run_until_complete(t)
self.assertTrue(f.cancelled())
self.assertTrue(t.cancelled())
def test_task_cancel_both_task_and_inner_future(self):
f = self.create_future()
@asyncio.coroutine
def task():
yield from f
return 12
t = self.create_task(task())
self.assertEqual(asyncio.Task.all_tasks(loop=self.loop), {t})
test_utils.run_briefly(self.loop)
f.cancel()
t.cancel()
with self.assertRaises(asyncio.CancelledError):
self.loop.run_until_complete(t)
self.assertTrue(t.done())
self.assertTrue(f.cancelled())
self.assertTrue(t.cancelled())
def test_task_cancel_task_catching(self):
fut1 = self.create_future()
fut2 = self.create_future()
@asyncio.coroutine
def task():
yield from fut1
try:
yield from fut2
except asyncio.CancelledError:
return 42
t = self.create_task(task())
test_utils.run_briefly(self.loop)
self.assertIs(t._fut_waiter, fut1) # White-box test.
fut1.set_result(None)
test_utils.run_briefly(self.loop)
self.assertIs(t._fut_waiter, fut2) # White-box test.
t.cancel()
self.assertTrue(fut2.cancelled())
res = self.loop.run_until_complete(t)
self.assertEqual(res, 42)
self.assertFalse(t.cancelled())
def test_task_cancel_task_ignoring(self):
fut1 = self.create_future()
fut2 = self.create_future()
fut3 = self.create_future()
@asyncio.coroutine
def task():
yield from fut1
try:
yield from fut2
except asyncio.CancelledError:
pass
res = yield from fut3
return res
t = self.create_task(task())
test_utils.run_briefly(self.loop)
self.assertIs(t._fut_waiter, fut1) # White-box test.
fut1.set_result(None)
test_utils.run_briefly(self.loop)
self.assertIs(t._fut_waiter, fut2) # White-box test.
t.cancel()
self.assertTrue(fut2.cancelled())
test_utils.run_briefly(self.loop)
self.assertIs(t._fut_waiter, fut3) # White-box test.
fut3.set_result(42)
res = self.loop.run_until_complete(t)
self.assertEqual(res, 42)
self.assertFalse(fut3.cancelled())
self.assertFalse(t.cancelled())
def test_task_cancel_current_task(self):
@asyncio.coroutine
def task():
t.cancel()
self.assertTrue(t._must_cancel) # White-box test.
# The sleep should be canceled immediately.
yield from asyncio.sleep(100, loop=self.loop)
return 12
t = self.create_task(task())
self.assertRaises(
asyncio.CancelledError, self.loop.run_until_complete, t)
self.assertTrue(t.done())
self.assertFalse(t._must_cancel) # White-box test.
self.assertFalse(t.cancel())
def test_task_step_with_baseexception(self):
@asyncio.coroutine
def notmutch():
raise BaseException()
task = self.create_task(notmutch())
self.assertRaises(BaseException, task._step)
self.assertTrue(task.done())
self.assertIsInstance(task.exception(), BaseException)
def test_task_step_result_future(self):
# If coroutine returns future, task waits on this future.
class Fut(asyncio.Future):
def __init__(self, *args, **kwds):
self.cb_added = False
super().__init__(*args, **kwds)
def add_done_callback(self, fn):
self.cb_added = True
super().add_done_callback(fn)
fut = Fut(loop=self.loop)
result = None
@asyncio.coroutine
def wait_for_future():
nonlocal result
result = yield from fut
t = self.create_task(wait_for_future())
test_utils.run_briefly(self.loop)
self.assertTrue(fut.cb_added)
res = object()
fut.set_result(res)
test_utils.run_briefly(self.loop)
self.assertIs(res, result)
self.assertTrue(t.done())
self.assertIsNone(t.result())
def test_task_step_result(self):
@asyncio.coroutine
def notmuch():
yield None
yield 1
return 'ko'
self.assertRaises(
RuntimeError, self.loop.run_until_complete, notmuch())
def test_task_yield_vs_yield_from(self):
fut = asyncio.Future(loop=self.loop)
@asyncio.coroutine
def wait_for_future():
yield fut
task = wait_for_future()
with self.assertRaises(RuntimeError):
self.loop.run_until_complete(task)
self.assertFalse(fut.done())
def test_task_current_task(self):
self.assertIsNone(asyncio.Task.current_task(loop=self.loop))
@asyncio.coroutine
def coro(loop):
self.assertTrue(asyncio.Task.current_task(loop=loop) is task)
task = self.create_task(coro(self.loop))
self.loop.run_until_complete(task)
self.assertIsNone(asyncio.Task.current_task(loop=self.loop))
def test_task_current_task_with_interleaving_tasks(self):
self.assertIsNone(asyncio.Task.current_task(loop=self.loop))
fut1 = self.create_future()
fut2 = self.create_future()
@asyncio.coroutine
def coro1(loop):
self.assertTrue(asyncio.Task.current_task(loop=loop) is task1)
yield from fut1
self.assertTrue(asyncio.Task.current_task(loop=loop) is task1)
fut2.set_result(True)
@asyncio.coroutine
def coro2(loop):
self.assertTrue(asyncio.Task.current_task(loop=loop) is task2)
fut1.set_result(True)
yield from fut2
self.assertTrue(asyncio.Task.current_task(loop=loop) is task2)
task1 = self.create_task(coro1(self.loop))
task2 = self.create_task(coro2(self.loop))
self.loop.run_until_complete(asyncio.wait((task1, task2),
loop=self.loop))
self.assertIsNone(asyncio.Task.current_task(loop=self.loop))
def test_task_yield_future_passes_cancel(self):
# Canceling outer() cancels inner() cancels waiter.
proof = 0
waiter = self.create_future()
@asyncio.coroutine
def inner():
nonlocal proof
try:
yield from waiter
except asyncio.CancelledError:
proof += 1
raise
else:
self.fail('got past sleep() in inner()')
@asyncio.coroutine
def outer():
nonlocal proof
try:
yield from inner()
except asyncio.CancelledError:
proof += 100 # Expect this path.
else:
proof += 10
f = asyncio.ensure_future(outer(), loop=self.loop)
test_utils.run_briefly(self.loop)
f.cancel()
self.loop.run_until_complete(f)
self.assertEqual(proof, 101)
self.assertTrue(waiter.cancelled())
def test_task_yield_wait_does_not_shield_cancel(self):
# Canceling outer() makes wait() return early, leaves inner()
# running.
proof = 0
waiter = self.create_future()
@asyncio.coroutine
def inner():
nonlocal proof
yield from waiter
proof += 1
@asyncio.coroutine
def outer():
nonlocal proof
d, p = yield from asyncio.wait([inner()], loop=self.loop)
proof += 100
f = asyncio.ensure_future(outer(), loop=self.loop)
test_utils.run_briefly(self.loop)
f.cancel()
self.assertRaises(
asyncio.CancelledError, self.loop.run_until_complete, f)
waiter.set_result(None)
test_utils.run_briefly(self.loop)
self.assertEqual(proof, 1)
###############################################################################
# Tests Matrix
###############################################################################
class Test_UV_UV_Tasks(_TestTasks, tb.UVTestCase):
def create_future(self):
return self.loop.create_future()
def create_task(self, coro):
return self.loop.create_task(coro)
class Test_UV_UV_Tasks_AIO_Future(_TestTasks, tb.UVTestCase):
def create_future(self):
return asyncio.Future(loop=self.loop)
def create_task(self, coro):
return self.loop.create_task(coro)
class Test_UV_AIO_Tasks(_TestTasks, tb.UVTestCase):
def create_future(self):
return asyncio.Future(loop=self.loop)
def create_task(self, coro):
return asyncio.Task(coro, loop=self.loop)
class Test_AIO_Tasks(_TestTasks, tb.AIOTestCase):
def create_future(self):
return asyncio.Future(loop=self.loop)
def create_task(self, coro):
return asyncio.Task(coro, loop=self.loop)
uvloop-0.8.0/Makefile 0000664 0001750 0001750 00000001726 13047176662 015371 0 ustar travis travis 0000000 0000000 .PHONY: _default clean clean-libuv distclean compile debug docs test release
PYTHON ?= python
_default: compile
clean:
rm -fr dist/ doc/_build/ *.egg-info build/ uvloop/loop.*.pyd
rm -fr build/lib.* build/temp.*
rm -fr uvloop/*.c uvloop/*.html uvloop/*.so
rm -fr uvloop/handles/*.html uvloop/includes/*.html
find . -name '__pycache__' | xargs rm -rf
clean-libuv:
(cd vendor/libuv; git clean -dfX)
distclean: clean clean-libuv
compile: clean
$(PYTHON) setup.py build_ext --inplace --cython-always
debug: clean
$(PYTHON) setup.py build_ext --inplace --debug \
--cython-always \
--cython-annotate \
--cython-directives="linetrace=True" \
--define UVLOOP_DEBUG,CYTHON_TRACE,CYTHON_TRACE_NOGIL
docs: compile
cd docs && $(PYTHON) -m sphinx -a -b html . _build/html
test:
PYTHONASYNCIODEBUG=1 $(PYTHON) -m unittest discover -s tests
$(PYTHON) -m unittest discover -s tests
release: distclean compile test
$(PYTHON) setup.py sdist bdist_wheel upload
uvloop-0.8.0/uvloop/ 0000775 0001750 0001750 00000000000 13047177422 015242 5 ustar travis travis 0000000 0000000 uvloop-0.8.0/uvloop/request.pyx 0000664 0001750 0001750 00000005011 13047176662 017476 0 ustar travis travis 0000000 0000000 cdef class UVRequest:
"""A base class for all libuv requests (uv_getaddrinfo_t, etc).
Important: it's a responsibility of the subclass to call the
"on_done" method in the request's callback.
If "on_done" isn't called, the request object will never die.
"""
def __cinit__(self, Loop loop, *_):
self.request = NULL
self.loop = loop
self.done = 0
Py_INCREF(self)
def __dealloc__(self):
if self.request is not NULL:
if self.done == 0:
raise RuntimeError(
'Unable to deallocate request for {!r} (not done)'
.format(self))
PyMem_RawFree(self.request)
self.request = NULL
cdef on_done(self):
self.done = 1
Py_DECREF(self)
cdef cancel(self):
# Most requests are implemented using a threadpool. It's only
# possible to cancel a request when it's still in a threadpool's
# queue. Once it's started to execute, we have to wait until
# it finishes and calls its callback (and callback *must* call
# UVRequest.on_done).
cdef int err
if self.done == 1:
return
if UVLOOP_DEBUG:
if self.request is NULL:
raise RuntimeError(
'{}.cancel: .request is NULL'.format(
self.__class__.__name__))
if self.request.data is NULL:
raise RuntimeError(
'{}.cancel: .request.data is NULL'.format(
self.__class__.__name__))
if self.request.data is not self:
raise RuntimeError(
'{}.cancel: .request.data is not UVRequest'.format(
self.__class__.__name__))
# We only can cancel pending requests. Let's try.
err = uv.uv_cancel(self.request)
if err < 0:
if err == uv.UV_EBUSY:
# Can't close the request -- it's executing (see the first
# comment). Loop will have to wait until the callback
# fires.
pass
elif err == uv.UV_EINVAL:
# From libuv docs:
#
# Only cancellation of uv_fs_t, uv_getaddrinfo_t,
# uv_getnameinfo_t and uv_work_t requests is currently
# supported.
return
else:
ex = convert_error(err)
self.loop._handle_exception(ex)
uvloop-0.8.0/uvloop/dns.pyx 0000664 0001750 0001750 00000023752 13047176662 016606 0 ustar travis travis 0000000 0000000 cdef __port_to_int(port, proto):
if port is None or port == '' or port == b'':
return 0
try:
return int(port)
except (ValueError, TypeError):
pass
if isinstance(port, bytes):
port = port.decode()
if isinstance(port, str) and proto is not None:
if proto == uv.IPPROTO_TCP:
return socket_getservbyname(port, 'tcp')
elif proto == uv.IPPROTO_UDP:
return socket_getservbyname(port, 'udp')
raise OSError('service/proto not found')
cdef __convert_sockaddr_to_pyaddr(const system.sockaddr* addr):
# Converts sockaddr structs into what Python socket
# module can understand:
# - for IPv4 a tuple of (host, port)
# - for IPv6 a tuple of (host, port, flowinfo, scope_id)
cdef:
char buf[128] # INET6_ADDRSTRLEN is usually 46
int err
system.sockaddr_in *addr4
system.sockaddr_in6 *addr6
if addr.sa_family == uv.AF_INET:
addr4 = addr
err = uv.uv_ip4_name(addr4, buf, sizeof(buf))
if err < 0:
raise convert_error(err)
return (
(buf).decode(),
system.ntohs(addr4.sin_port)
)
elif addr.sa_family == uv.AF_INET6:
addr6 = addr
err = uv.uv_ip6_name(addr6, buf, sizeof(buf))
if err < 0:
raise convert_error(err)
return (
(buf).decode(),
system.ntohs(addr6.sin6_port),
system.ntohl(addr6.sin6_flowinfo),
addr6.sin6_scope_id
)
raise RuntimeError("cannot convert sockaddr into Python object")
cdef __convert_pyaddr_to_sockaddr(int family, object addr,
system.sockaddr* res):
cdef:
int err
int addr_len
int scope_id = 0
int flowinfo = 0
if family == uv.AF_INET:
if not isinstance(addr, tuple):
raise TypeError('AF_INET address must be tuple')
if len(addr) != 2:
raise ValueError('AF_INET address must be tuple of (host, port)')
host, port = addr
if isinstance(host, str):
host = host.encode('idna')
if not isinstance(host, (bytes, bytearray)):
raise TypeError('host must be a string or bytes object')
port = __port_to_int(port, None)
err = uv.uv_ip4_addr(host, port, res)
if err < 0:
raise convert_error(err)
elif family == uv.AF_INET6:
if not isinstance(addr, tuple):
raise TypeError('AF_INET6 address must be tuple')
addr_len = len(addr)
if addr_len < 2 or addr_len > 4:
raise ValueError(
'AF_INET6 must be a tuple of 2-4 parameters: '
'(host, port, flowinfo?, scope_id?)')
host = addr[0]
if isinstance(host, str):
host = host.encode('idna')
port = __port_to_int(addr[1], None)
if addr_len > 2:
flowinfo = addr[2]
if addr_len > 3:
scope_id = addr[3]
err = uv.uv_ip6_addr(host, port, res)
if err < 0:
raise convert_error(err)
(res).sin6_flowinfo = flowinfo
(res).sin6_scope_id = scope_id
else:
raise ValueError(
'epected AF_INET or AF_INET6 family, got {}'.format(family))
cdef __static_getaddrinfo(object host, object port,
int family, int type,
int proto,
system.sockaddr *addr):
if proto not in {0, uv.IPPROTO_TCP, uv.IPPROTO_UDP}:
raise LookupError
if type == uv.SOCK_STREAM:
# Linux only:
# getaddrinfo() can raise when socket.type is a bit mask.
# So if socket.type is a bit mask of SOCK_STREAM, and say
# SOCK_NONBLOCK, we simply return None, which will trigger
# a call to getaddrinfo() letting it process this request.
proto = uv.IPPROTO_TCP
elif type == uv.SOCK_DGRAM:
proto = uv.IPPROTO_UDP
else:
raise LookupError
try:
port = __port_to_int(port, proto)
except:
raise LookupError
if family == uv.AF_UNSPEC:
afs = [uv.AF_INET, uv.AF_INET6]
else:
afs = [family]
for af in afs:
try:
__convert_pyaddr_to_sockaddr(af, (host, port), addr)
except:
continue
else:
return (af, type, proto)
raise LookupError
cdef __static_getaddrinfo_pyaddr(object host, object port,
int family, int type,
int proto, int flags):
cdef:
system.sockaddr_storage addr
try:
(af, type, proto) = __static_getaddrinfo(
host, port, family, type,
proto, &addr)
except LookupError:
return
try:
pyaddr = __convert_sockaddr_to_pyaddr(&addr)
except:
return
return af, type, proto, '', pyaddr
@cython.freelist(DEFAULT_FREELIST_SIZE)
cdef class AddrInfo:
cdef:
system.addrinfo *data
def __cinit__(self):
self.data = NULL
def __dealloc__(self):
if self.data is not NULL:
uv.uv_freeaddrinfo(self.data) # returns void
self.data = NULL
cdef void set_data(self, system.addrinfo *data):
self.data = data
cdef unpack(self):
cdef:
list result = []
system.addrinfo *ptr
if self.data is NULL:
raise RuntimeError('AddrInfo.data is NULL')
ptr = self.data
while ptr != NULL:
if ptr.ai_addr.sa_family in (uv.AF_INET, uv.AF_INET6):
result.append((
ptr.ai_family,
ptr.ai_socktype,
ptr.ai_protocol,
'' if ptr.ai_canonname is NULL else
(ptr.ai_canonname).decode(),
__convert_sockaddr_to_pyaddr(ptr.ai_addr)
))
ptr = ptr.ai_next
return result
@staticmethod
cdef int isinstance(object other):
return type(other) is AddrInfo
cdef class AddrInfoRequest(UVRequest):
cdef:
system.addrinfo hints
object callback
def __cinit__(self, Loop loop,
bytes host, bytes port,
int family, int type, int proto, int flags,
object callback):
cdef:
int err
char *chost
char *cport
if host is None:
chost = NULL
else:
chost = host
if port is None:
cport = NULL
else:
cport = port
if cport is NULL and chost is NULL:
self.on_done()
msg = system.gai_strerror(socket_EAI_NONAME).decode('utf-8')
ex = socket_gaierror(socket_EAI_NONAME, msg)
callback(ex)
return
memset(&self.hints, 0, sizeof(system.addrinfo))
self.hints.ai_flags = flags
self.hints.ai_family = family
self.hints.ai_socktype = type
self.hints.ai_protocol = proto
self.request = PyMem_RawMalloc(
sizeof(uv.uv_getaddrinfo_t))
if self.request is NULL:
self.on_done()
raise MemoryError()
self.callback = callback
self.request.data = self
err = uv.uv_getaddrinfo(loop.uvloop,
self.request,
__on_addrinfo_resolved,
chost,
cport,
&self.hints)
if err < 0:
self.on_done()
callback(convert_error(err))
cdef class NameInfoRequest(UVRequest):
cdef:
object callback
def __cinit__(self, Loop loop, callback):
self.request = PyMem_RawMalloc(
sizeof(uv.uv_getnameinfo_t))
if self.request is NULL:
self.on_done()
raise MemoryError()
self.callback = callback
self.request.data = self
cdef query(self, system.sockaddr *addr, int flags):
cdef int err
err = uv.uv_getnameinfo(self.loop.uvloop,
self.request,
__on_nameinfo_resolved,
addr,
flags)
if err < 0:
self.on_done()
self.callback(convert_error(err))
cdef void __on_addrinfo_resolved(uv.uv_getaddrinfo_t *resolver,
int status, system.addrinfo *res) with gil:
if resolver.data is NULL:
aio_logger.error(
'AddrInfoRequest callback called with NULL resolver.data')
return
cdef:
AddrInfoRequest request = resolver.data
Loop loop = request.loop
object callback = request.callback
AddrInfo ai
try:
if status < 0:
callback(convert_error(status))
else:
ai = AddrInfo()
ai.set_data(res)
callback(ai)
except Exception as ex:
loop._handle_exception(ex)
finally:
request.on_done()
cdef void __on_nameinfo_resolved(uv.uv_getnameinfo_t* req,
int status,
const char* hostname,
const char* service) with gil:
cdef:
NameInfoRequest request = req.data
Loop loop = request.loop
object callback = request.callback
try:
if status < 0:
callback(convert_error(status))
else:
callback(((hostname).decode(),
(service).decode()))
except Exception as ex:
loop._handle_exception(ex)
finally:
request.on_done()
uvloop-0.8.0/uvloop/chain_futs.pyx 0000664 0001750 0001750 00000006555 13047176662 020147 0 ustar travis travis 0000000 0000000 # LICENSE: PSF.
# Copied from asyncio 3.5.2. Remove this file when we don't need
# to support earlier versions.
cdef _set_concurrent_future_state(concurrent, source):
"""Copy state from a future to a concurrent.futures.Future."""
assert source.done()
if source.cancelled():
concurrent.cancel()
if not concurrent.set_running_or_notify_cancel():
return
exception = source.exception()
if exception is not None:
concurrent.set_exception(exception)
else:
result = source.result()
concurrent.set_result(result)
cdef _copy_future_state(source, dest):
"""Internal helper to copy state from another Future.
The other Future may be a concurrent.futures.Future.
"""
assert source.done()
if dest.cancelled():
return
assert not dest.done()
if source.cancelled():
dest.cancel()
else:
exception = source.exception()
if exception is not None:
dest.set_exception(exception)
else:
result = source.result()
dest.set_result(result)
cdef _chain_future(source, destination):
"""Chain two futures so that when one completes, so does the other.
The result (or exception) of source will be copied to destination.
If destination is cancelled, source gets cancelled too.
Compatible with both asyncio.Future and concurrent.futures.Future.
"""
if not isfuture(source) and not isinstance(source, cc_Future):
raise TypeError('A future is required for source argument')
if not isfuture(destination) and not isinstance(destination, cc_Future):
raise TypeError('A future is required for destination argument')
source_loop = None
dest_loop = None
if _is_uvloop_future(source):
source_loop = (source)._loop
elif isfuture(source):
source_loop = source._loop
if _is_uvloop_future(destination):
dest_loop = (destination)._loop
elif isfuture(destination):
dest_loop = destination._loop
def _set_state(future, other):
if isfuture(future):
_copy_future_state(other, future)
else:
_set_concurrent_future_state(future, other)
def _call_check_cancel(destination):
if destination.cancelled():
if source_loop is None or source_loop is dest_loop:
source.cancel()
else:
source_loop.call_soon_threadsafe(source.cancel)
def _call_set_state(source):
if dest_loop is None or dest_loop is source_loop:
_set_state(destination, source)
else:
dest_loop.call_soon_threadsafe(_set_state, destination, source)
destination.add_done_callback(_call_check_cancel)
source.add_done_callback(_call_set_state)
def _wrap_future(future, *, loop=None):
# Don't use this function -- it's here for tests purposes only
# and can be removed in future versions of uvloop.
if isfuture(future):
return future
assert isinstance(future, cc_Future), \
'concurrent.futures.Future is expected, got {!r}'.format(future)
if loop is None:
loop = aio_get_event_loop()
try:
create_future = loop.create_future
except AttributeError:
new_future = aio_Future(loop=loop)
else:
new_future = create_future()
_chain_future(future, new_future)
return new_future
uvloop-0.8.0/uvloop/__init__.py 0000664 0001750 0001750 00000001406 13047176662 017361 0 ustar travis travis 0000000 0000000 import asyncio
from asyncio.events import BaseDefaultEventLoopPolicy as __BasePolicy
from . import includes as __includes
from . import _patch
from .loop import Loop as __BaseLoop, Future
__all__ = ('new_event_loop', 'EventLoopPolicy')
class Loop(__BaseLoop, asyncio.AbstractEventLoop):
pass
def new_event_loop():
"""Return a new event loop."""
return Loop()
class EventLoopPolicy(__BasePolicy):
"""Event loop policy.
The preferred way to make your application use uvloop:
>>> import asyncio
>>> import uvloop
>>> asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
>>> asyncio.get_event_loop()
"""
def _loop_factory(self):
return new_event_loop()
uvloop-0.8.0/uvloop/future.pyx 0000664 0001750 0001750 00000035213 13047176662 017327 0 ustar travis travis 0000000 0000000 # LICENSE: PSF.
DEF _FUT_PENDING = 1
DEF _FUT_CANCELLED = 2
DEF _FUT_FINISHED = 3
cdef inline _future_get_blocking(fut):
try:
return fut._asyncio_future_blocking
except AttributeError:
return fut._blocking
cdef inline _future_set_blocking(fut, val):
try:
fut._asyncio_future_blocking
except AttributeError:
fut._blocking = val
else:
fut._asyncio_future_blocking = val
cdef class BaseFuture:
cdef:
int _state
readonly Loop _loop
readonly list _callbacks
readonly object _exception
readonly object _result
public bint _blocking
readonly object _source_traceback
readonly bint _log_traceback
def __init__(self, Loop loop):
if loop is None:
loop = aio_get_event_loop()
if not isinstance(loop, Loop):
raise TypeError('uvloop.Future supports only uvloop.Loop')
self._state = _FUT_PENDING
self._loop = loop
self._callbacks = []
self._result = None
self._exception = None
self._blocking = False
self._log_traceback = False
if loop._debug:
self._source_traceback = tb_extract_stack(sys_getframe(0))
else:
self._source_traceback = None
property _asyncio_future_blocking:
def __get__(self):
return self._blocking
def __set__(self, value):
self._blocking = value
cdef _schedule_callbacks(self):
cdef:
list callbacks
size_t cb_len = len(self._callbacks)
size_t i
if cb_len == 0:
return
callbacks = self._callbacks
self._callbacks = []
for i from 0 <= i < cb_len:
self._loop.call_soon(callbacks[i], self)
cdef _add_done_callback(self, fn):
if self._state != _FUT_PENDING:
self._loop.call_soon(fn, self)
else:
self._callbacks.append(fn)
cdef _done(self):
return self._state != _FUT_PENDING
cdef _cancel(self):
if self._done():
return False
self._state = _FUT_CANCELLED
self._schedule_callbacks()
return True
# _result would shadow the "_result" property
cdef _result_impl(self):
if self._state == _FUT_CANCELLED:
raise aio_CancelledError
if self._state != _FUT_FINISHED:
raise aio_InvalidStateError('Result is not ready.')
self._log_traceback = False
if self._exception is not None:
raise self._exception
return self._result
cdef _str_state(self):
if self._state == _FUT_PENDING:
return 'PENDING'
elif self._state == _FUT_CANCELLED:
return 'CANCELLED'
elif self._state == _FUT_FINISHED:
return 'FINISHED'
else:
raise RuntimeError('unknown Future state')
property _state:
def __get__(self):
return self._str_state()
def cancel(self):
"""Cancel the future and schedule callbacks.
If the future is already done or cancelled, return False. Otherwise,
change the future's state to cancelled, schedule the callbacks and
return True.
"""
return self._cancel()
def cancelled(self):
"""Return True if the future was cancelled."""
return self._state == _FUT_CANCELLED
def done(self):
"""Return True if the future is done.
Done means either that a result / exception are available, or that the
future was cancelled.
"""
return self._state != _FUT_PENDING
def result(self):
"""Return the result this future represents.
If the future has been cancelled, raises CancelledError. If the
future's result isn't yet available, raises InvalidStateError. If
the future is done and has an exception set, this exception is raised.
"""
return self._result_impl()
def exception(self):
"""Return the exception that was set on this future.
The exception (or None if no exception was set) is returned only if
the future is done. If the future has been cancelled, raises
CancelledError. If the future isn't done yet, raises
InvalidStateError.
"""
if self._state == _FUT_CANCELLED:
raise aio_CancelledError
if self._state != _FUT_FINISHED:
raise aio_InvalidStateError('Exception is not set.')
self._log_traceback = False
return self._exception
def add_done_callback(self, fn):
"""Add a callback to be run when the future becomes done.
The callback is called with a single argument - the future object. If
the future is already done when this is called, the callback is
scheduled with call_soon.
"""
self._add_done_callback(fn)
def remove_done_callback(self, fn):
"""Remove all instances of a callback from the "call when done" list.
Returns the number of callbacks removed.
"""
cdef:
size_t clen = len(self._callbacks)
size_t i
size_t ni = 0
object cb
for i from 0 <= i < clen:
cb = self._callbacks[i]
if cb != fn:
self._callbacks[ni] = cb
ni += 1
if ni != clen:
del self._callbacks[ni:]
return clen - ni
cpdef set_result(self, result):
"""Mark the future done and set its result.
If the future is already done when this method is called, raises
InvalidStateError.
"""
if self._state != _FUT_PENDING:
raise aio_InvalidStateError('{}: {!r}'.format(
self._str_state(), self))
self._result = result
self._state = _FUT_FINISHED
self._schedule_callbacks()
cpdef set_exception(self, exception):
"""Mark the future done and set an exception.
If the future is already done when this method is called, raises
InvalidStateError.
"""
if self._state != _FUT_PENDING:
raise aio_InvalidStateError('{}: {!r}'.format(
self._str_state(), self))
if isinstance(exception, type):
exception = exception()
if type(exception) is StopIteration:
raise TypeError("StopIteration interacts badly with generators "
"and cannot be raised into a Future")
self._exception = exception
self._state = _FUT_FINISHED
self._schedule_callbacks()
self._log_traceback = True
# Copy of __await__
def __iter__(self):
if self._state == _FUT_PENDING:
self._blocking = True
yield self # This tells Task to wait for completion.
if self._state == _FUT_PENDING:
raise AssertionError("yield from wasn't used with future")
return self._result_impl() # May raise too.
# Copy of __iter__
def __await__(self):
if self._state == _FUT_PENDING:
self._blocking = True
yield self # This tells Task to wait for completion.
if self._state == _FUT_PENDING:
raise AssertionError("yield from wasn't used with future")
return self._result_impl() # May raise too.
cdef class BaseTask(BaseFuture):
cdef:
readonly object _coro
readonly object _fut_waiter
readonly bint _must_cancel
public bint _log_destroy_pending
def __init__(self, coro not None, Loop loop):
BaseFuture.__init__(self, loop)
self._coro = coro
self._fut_waiter = None
self._must_cancel = False
self._log_destroy_pending = True
self.__class__._all_tasks.add(self)
self._loop._call_soon_handle(
new_MethodHandle1(
self._loop,
"Task._step",
self._fast_step,
self,
None))
def cancel(self):
if self.done():
return False
if self._fut_waiter is not None:
if self._fut_waiter.cancel():
# Leave self._fut_waiter; it may be a Task that
# catches and ignores the cancellation so we may have
# to cancel it again later.
return True
# It must be the case that self._step is already scheduled.
self._must_cancel = True
return True
cdef _raise_wrong_loop(self, fut):
ex = RuntimeError(
'Task {!r} got Future {!r} attached to a '
'different loop'.format(self, fut))
self._loop._call_soon_handle(
new_MethodHandle1(
self._loop,
"Task._step",
self._fast_step,
self,
ex))
cdef _raise_yield(self, fut):
ex = RuntimeError(
'yield was used instead of yield from '
'in task {!r} with {!r}'.format(self, fut))
self._loop._call_soon_handle(
new_MethodHandle1(
self._loop,
"Task._step",
self._fast_step,
self,
ex))
cdef _raise_generator(self, val):
ex = RuntimeError(
'yield was used instead of yield from for '
'generator in task {!r} with {}'.format(self, val))
self._loop._call_soon_handle(
new_MethodHandle1(
self._loop,
"Task._step",
self._fast_step,
self,
ex))
cdef _raise_else(self, val):
ex = RuntimeError('Task got bad yield: {!r}'.format(val))
self._loop._call_soon_handle(
new_MethodHandle1(
self._loop,
"Task._step",
self._fast_step,
self,
ex))
cdef _skip_oneloop(self):
self._loop._call_soon_handle(
new_MethodHandle1(
self._loop,
"Task._step",
self._fast_step,
self,
None))
cdef _fast_step(self, exc):
cdef:
BaseFuture nfut
object meth
object _current_tasks = self.__class__._current_tasks
if self._state != _FUT_PENDING:
raise AssertionError(
'_step(): already done: {!r}, {!r}'.format(self, exc))
if self._must_cancel:
if not isinstance(exc, aio_CancelledError):
exc = aio_CancelledError()
self._must_cancel = False
self._fut_waiter = None
# Let it fail early with an AttributeError if self._coro
# is not a coroutine/generator.
if exc is None:
meth = self._coro.send
else:
meth = self._coro.throw
_current_tasks[self._loop] = self
# Call either coro.throw(exc) or coro.send(None).
try:
if exc is None:
# We use the `send` method directly, because coroutines
# don't have `__iter__` and `__next__` methods.
result = meth(None)
else:
result = meth(exc)
except StopIteration as exc:
self.set_result(exc.value)
except aio_CancelledError as exc:
BaseFuture._cancel(self) # I.e., Future.cancel(self).
except Exception as exc:
self.set_exception(exc)
except BaseException as exc:
self.set_exception(exc)
raise
else:
result_type = type(result)
if result_type is uvloop_Future:
# Yielded Future must come from Future.__iter__().
nfut = result
if nfut._loop is not self._loop:
self._raise_wrong_loop(result)
elif nfut._blocking:
nfut._blocking = False
nfut._add_done_callback(self._wakeup)
self._fut_waiter = result
if self._must_cancel:
if self._fut_waiter.cancel():
self._must_cancel = False
else:
self._raise_yield(result)
elif result_type is aio_Future or isfuture(result):
# Yielded Future must come from Future.__iter__().
if result._loop is not self._loop:
self._raise_wrong_loop(result)
elif _future_get_blocking(result):
_future_set_blocking(result, False)
result.add_done_callback(self._wakeup)
self._fut_waiter = result
if self._must_cancel:
if self._fut_waiter.cancel():
self._must_cancel = False
else:
self._raise_yield(result)
elif result is None:
# Bare yield relinquishes control for one event loop iteration.
self._skip_oneloop()
elif inspect_isgenerator(result):
# Yielding a generator is just wrong.
self._raise_generator(result)
else:
# Yielding something else is an error.
self._raise_else(result)
finally:
_current_tasks.pop(self._loop)
cdef _fast_wakeup(self, future):
try:
if type(future) is uvloop_Future:
(future)._result_impl()
else:
future.result()
except Exception as exc:
# This may also be a cancellation.
self._fast_step(exc)
else:
# Don't pass the value of `future.result()` explicitly,
# as `Future.__iter__` and `Future.__await__` don't need it.
self._fast_step(None)
def _step(self, exc=None):
self._fast_step(exc)
self = None
def _wakeup(self, future):
self._fast_wakeup(future)
self = None
cdef uvloop_Future = None
cdef future_factory
cdef task_factory
if sys.version_info >= (3, 6):
# In Python 3.6 Task and Future are implemented in C and
# are already fast.
future_factory = aio_Future
task_factory = aio_Task
Future = aio_Future
else:
class Future(BaseFuture, aio_Future):
# Inherit asyncio.Future.__del__ and __repr__
pass
class Task(BaseTask, aio_Task):
# Inherit asyncio.Task.__del__ and __repr__ and a bunch
# of class methods.
pass
uvloop_Future = Future
future_factory = Future
task_factory = Task
cdef _is_uvloop_future(fut):
return uvloop_Future is not None and type(fut) == uvloop_Future
uvloop-0.8.0/uvloop/server.pxd 0000664 0001750 0001750 00000000354 13047176662 017274 0 ustar travis travis 0000000 0000000 cdef class Server:
cdef:
list _servers
list _waiters
int _active_count
Loop _loop
cdef _add_server(self, UVStreamServer srv)
cdef _wakeup(self)
cdef _attach(self)
cdef _detach(self)
uvloop-0.8.0/uvloop/_testbase.py 0000664 0001750 0001750 00000030125 13047176662 017573 0 ustar travis travis 0000000 0000000 """Test utilities. Don't use outside of the uvloop project."""
import asyncio
import asyncio.events
import collections
import contextlib
import gc
import inspect
import logging
import os
import re
import socket
import ssl
import tempfile
import threading
import unittest
import uvloop
class MockPattern(str):
def __eq__(self, other):
return bool(re.search(str(self), other, re.S))
class TestCaseDict(collections.UserDict):
def __init__(self, name):
super().__init__()
self.name = name
def __setitem__(self, key, value):
if key in self.data:
raise RuntimeError('duplicate test {}.{}'.format(
self.name, key))
super().__setitem__(key, value)
class BaseTestCaseMeta(type):
@classmethod
def __prepare__(mcls, name, bases):
return TestCaseDict(name)
def __new__(mcls, name, bases, dct):
for test_name in dct:
if not test_name.startswith('test_'):
continue
for base in bases:
if hasattr(base, test_name):
raise RuntimeError(
'duplicate test {}.{} (also defined in {} '
'parent class)'.format(
name, test_name, base.__name__))
return super().__new__(mcls, name, bases, dict(dct))
class BaseTestCase(unittest.TestCase, metaclass=BaseTestCaseMeta):
def new_loop(self):
raise NotImplementedError
def mock_pattern(self, str):
return MockPattern(str)
def is_asyncio_loop(self):
return type(self.loop).__module__.startswith('asyncio.')
def setUp(self):
self.loop = self.new_loop()
asyncio.set_event_loop(None)
self._check_unclosed_resources_in_debug = True
if hasattr(asyncio, '_get_running_loop'):
# Disable `_get_running_loop`.
self._get_running_loop = asyncio.events._get_running_loop
asyncio.events._get_running_loop = lambda: None
def tearDown(self):
self.loop.close()
if hasattr(asyncio, '_get_running_loop'):
asyncio.events._get_running_loop = self._get_running_loop
if not self._check_unclosed_resources_in_debug:
return
# GC to show any resource warnings as the test completes
gc.collect()
gc.collect()
gc.collect()
if getattr(self.loop, '_debug_cc', False):
gc.collect()
gc.collect()
gc.collect()
self.assertEqual(
self.loop._debug_uv_handles_total,
self.loop._debug_uv_handles_freed,
'not all uv_handle_t handles were freed')
self.assertEqual(
self.loop._debug_cb_handles_count, 0,
'not all callbacks (call_soon) are GCed')
self.assertEqual(
self.loop._debug_cb_timer_handles_count, 0,
'not all timer callbacks (call_later) are GCed')
self.assertEqual(
self.loop._debug_stream_write_ctx_cnt, 0,
'not all stream write contexts are GCed')
for h_name, h_cnt in self.loop._debug_handles_current.items():
with self.subTest('Alive handle after test',
handle_name=h_name):
self.assertEqual(
h_cnt, 0,
'alive {} after test'.format(h_name))
for h_name, h_cnt in self.loop._debug_handles_total.items():
with self.subTest('Total/closed handles',
handle_name=h_name):
self.assertEqual(
h_cnt, self.loop._debug_handles_closed[h_name],
'total != closed for {}'.format(h_name))
asyncio.set_event_loop(None)
self.loop = None
def skip_unclosed_handles_check(self):
self._check_unclosed_resources_in_debug = False
def _cert_fullname(name):
fullname = os.path.join(
os.path.dirname(os.path.dirname(__file__)),
'tests', 'certs', name)
assert os.path.isfile(fullname)
return fullname
@contextlib.contextmanager
def silence_long_exec_warning():
class Filter(logging.Filter):
def filter(self, record):
return not (record.msg.startswith('Executing') and
record.msg.endswith('seconds'))
logger = logging.getLogger('asyncio')
filter = Filter()
logger.addFilter(filter)
try:
yield
finally:
logger.removeFilter(filter)
def find_free_port(start_from=50000):
for port in range(start_from, start_from + 500):
sock = socket.socket()
with sock:
try:
sock.bind(('', port))
except socket.error:
continue
else:
return port
raise RuntimeError('could not find a free port')
class SSLTestCase:
ONLYCERT = _cert_fullname('ssl_cert.pem')
ONLYKEY = _cert_fullname('ssl_key.pem')
def _create_server_ssl_context(self, certfile, keyfile=None):
sslcontext = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
sslcontext.options |= ssl.OP_NO_SSLv2
sslcontext.load_cert_chain(certfile, keyfile)
return sslcontext
def _create_client_ssl_context(self):
sslcontext = ssl.create_default_context()
sslcontext.check_hostname = False
sslcontext.verify_mode = ssl.CERT_NONE
return sslcontext
@contextlib.contextmanager
def _silence_eof_received_warning(self):
# TODO This warning has to be fixed in asyncio.
logger = logging.getLogger('asyncio')
filter = logging.Filter('has no effect when using ssl')
logger.addFilter(filter)
try:
yield
finally:
logger.removeFilter(filter)
class UVTestCase(BaseTestCase):
def new_loop(self):
return uvloop.new_event_loop()
class AIOTestCase(BaseTestCase):
def setUp(self):
super().setUp()
watcher = asyncio.SafeChildWatcher()
watcher.attach_loop(self.loop)
asyncio.set_child_watcher(watcher)
def tearDown(self):
asyncio.set_child_watcher(None)
super().tearDown()
def new_loop(self):
return asyncio.new_event_loop()
###############################################################################
# Socket Testing Utilities
###############################################################################
def tcp_server(server_prog, *,
family=socket.AF_INET,
addr=None,
timeout=5,
backlog=1,
max_clients=10):
if addr is None:
if family == socket.AF_UNIX:
with tempfile.NamedTemporaryFile() as tmp:
addr = tmp.name
else:
addr = ('127.0.0.1', 0)
if not inspect.isgeneratorfunction(server_prog):
raise TypeError('server_prog: a generator function was expected')
sock = socket.socket(family, socket.SOCK_STREAM)
if timeout is None:
raise RuntimeError('timeout is required')
if timeout <= 0:
raise RuntimeError('only blocking sockets are supported')
sock.settimeout(timeout)
try:
sock.bind(addr)
sock.listen(backlog)
except OSError as ex:
sock.close()
raise ex
srv = Server(sock, server_prog, timeout, max_clients)
return srv
def tcp_client(client_prog,
family=socket.AF_INET,
timeout=10):
if not inspect.isgeneratorfunction(client_prog):
raise TypeError('client_prog: a generator function was expected')
sock = socket.socket(family, socket.SOCK_STREAM)
if timeout is None:
raise RuntimeError('timeout is required')
if timeout <= 0:
raise RuntimeError('only blocking sockets are supported')
sock.settimeout(timeout)
srv = Client(sock, client_prog, timeout)
return srv
class _Runner:
def _iterate(self, prog, sock):
last_val = None
while self._active:
try:
command = prog.send(last_val)
except StopIteration:
return
if not isinstance(command, _Command):
raise TypeError(
'client_prog yielded invalid command {!r}'.format(command))
command_res = command._run(sock)
assert isinstance(command_res, tuple) and len(command_res) == 2
last_val = command_res[1]
sock = command_res[0]
def stop(self):
self._active = False
self.join()
def __enter__(self):
self.start()
return self
def __exit__(self, *exc):
self.stop()
class Client(_Runner, threading.Thread):
def __init__(self, sock, prog, timeout):
threading.Thread.__init__(self, None, None, 'test-client')
self.daemon = True
self._timeout = timeout
self._sock = sock
self._active = True
self._prog = prog
def run(self):
prog = self._prog()
sock = self._sock
self._iterate(prog, sock)
class Server(_Runner, threading.Thread):
def __init__(self, sock, prog, timeout, max_clients):
threading.Thread.__init__(self, None, None, 'test-server')
self.daemon = True
self._clients = 0
self._finished_clients = 0
self._max_clients = max_clients
self._timeout = timeout
self._sock = sock
self._active = True
self._prog = prog
def run(self):
with self._sock:
while self._active:
if self._clients >= self._max_clients:
return
try:
conn, addr = self._sock.accept()
except socket.timeout:
if not self._active:
return
else:
raise
self._clients += 1
conn.settimeout(self._timeout)
try:
with conn:
self._handle_client(conn)
except Exception:
self._active = False
raise
def _handle_client(self, sock):
prog = self._prog()
self._iterate(prog, sock)
@property
def addr(self):
return self._sock.getsockname()
class _Command:
def _run(self, sock):
raise NotImplementedError
class write(_Command):
def __init__(self, data:bytes):
self._data = data
def _run(self, sock):
sock.sendall(self._data)
return sock, None
class connect(_Command):
def __init__(self, addr):
self._addr = addr
def _run(self, sock):
sock.connect(self._addr)
return sock, None
class close(_Command):
def _run(self, sock):
sock.close()
return sock, None
class read(_Command):
def __init__(self, nbytes):
self._nbytes = nbytes
self._nbytes_recv = 0
self._data = []
def _run(self, sock):
while self._nbytes_recv != self._nbytes:
try:
data = sock.recv(self._nbytes)
except InterruptedError:
# for Python < 3.5
continue
if data == b'':
raise ConnectionAbortedError
self._nbytes_recv += len(data)
self._data.append(data)
data = b''.join(self._data)
return sock, data
class starttls(_Command):
def __init__(self, ssl_context, *,
server_side=False,
server_hostname=None,
do_handshake_on_connect=True):
assert isinstance(ssl_context, ssl.SSLContext)
self._ctx = ssl_context
self._server_side = server_side
self._server_hostname = server_hostname
self._do_handshake_on_connect = do_handshake_on_connect
def _run(self, sock):
ssl_sock = self._ctx.wrap_socket(
sock, server_side=self._server_side,
server_hostname=self._server_hostname,
do_handshake_on_connect=self._do_handshake_on_connect)
if self._server_side:
ssl_sock.do_handshake()
return ssl_sock, None
uvloop-0.8.0/uvloop/_noop.py 0000664 0001750 0001750 00000000116 13047176662 016731 0 ustar travis travis 0000000 0000000 def noop():
"""Empty function to invoke CPython ceval loop."""
return
uvloop-0.8.0/uvloop/server.pyx 0000664 0001750 0001750 00000003142 13047176662 017317 0 ustar travis travis 0000000 0000000 cdef class Server:
def __cinit__(self, Loop loop):
self._loop = loop
self._servers = []
self._waiters = []
self._active_count = 0
cdef _add_server(self, UVStreamServer srv):
self._servers.append(srv)
cdef _wakeup(self):
cdef list waiters
waiters = self._waiters
self._waiters = None
for waiter in waiters:
if not waiter.done():
waiter.set_result(waiter)
cdef _attach(self):
assert self._servers is not None
self._active_count += 1
cdef _detach(self):
assert self._active_count > 0
self._active_count -= 1
if self._active_count == 0 and self._servers is None:
self._wakeup()
# Public API
def __repr__(self):
return '<%s sockets=%r>' % (self.__class__.__name__, self.sockets)
async def wait_closed(self):
if self._servers is None or self._waiters is None:
return
waiter = self._loop._new_future()
self._waiters.append(waiter)
await waiter
def close(self):
if self._servers is None:
return
cdef list servers = self._servers
self._servers = None
for server in servers:
(server)._close()
if self._active_count == 0:
self._wakeup()
property sockets:
def __get__(self):
cdef list sockets = []
for server in self._servers:
sockets.append(
(server)._get_socket()
)
return sockets
uvloop-0.8.0/uvloop/errors.pyx 0000664 0001750 0001750 00000005326 13047176662 017333 0 ustar travis travis 0000000 0000000 cdef str __strerr(int errno):
return strerror(errno).decode()
cdef __convert_python_error(int uverr):
# XXX Won't work for Windows:
# From libuv docs:
# Implementation detail: on Unix error codes are the
# negated errno (or -errno), while on Windows they
# are defined by libuv to arbitrary negative numbers.
cdef int oserr = -uverr
exc = OSError
if uverr in (uv.UV_EACCES, uv.UV_EPERM):
exc = PermissionError
elif uverr in (uv.UV_EAGAIN, uv.UV_EALREADY):
exc = BlockingIOError
elif uverr in (uv.UV_EPIPE, uv.UV_ESHUTDOWN):
exc = BrokenPipeError
elif uverr == uv.UV_ECONNABORTED:
exc = ConnectionAbortedError
elif uverr == uv.UV_ECONNREFUSED:
exc = ConnectionRefusedError
elif uverr == uv.UV_ECONNRESET:
exc = ConnectionResetError
elif uverr == uv.UV_EEXIST:
exc = FileExistsError
elif uverr == uv.UV_ENOENT:
exc = FileNotFoundError
elif uverr == uv.UV_EINTR:
exc = InterruptedError
elif uverr == uv.UV_EISDIR:
exc = IsADirectoryError
elif uverr == uv.UV_ESRCH:
exc = ProcessLookupError
elif uverr == uv.UV_ETIMEDOUT:
exc = TimeoutError
return exc(oserr, __strerr(oserr))
cdef int __convert_socket_error(int uverr):
cdef int sock_err = 0
if uverr == uv.UV_EAI_ADDRFAMILY:
sock_err = socket_EAI_ADDRFAMILY
elif uverr == uv.UV_EAI_AGAIN:
sock_err = socket_EAI_AGAIN
elif uverr == uv.UV_EAI_BADFLAGS:
sock_err = socket_EAI_BADFLAGS
elif uverr == uv.UV_EAI_BADHINTS:
sock_err = socket_EAI_BADHINTS
elif uverr == uv.UV_EAI_CANCELED:
sock_err = socket_EAI_CANCELED
elif uverr == uv.UV_EAI_FAIL:
sock_err = socket_EAI_FAIL
elif uverr == uv.UV_EAI_FAMILY:
sock_err = socket_EAI_FAMILY
elif uverr == uv.UV_EAI_MEMORY:
sock_err = socket_EAI_MEMORY
elif uverr == uv.UV_EAI_NODATA:
sock_err = socket_EAI_NODATA
elif uverr == uv.UV_EAI_NONAME:
sock_err = socket_EAI_NONAME
elif uverr == uv.UV_EAI_OVERFLOW:
sock_err = socket_EAI_OVERFLOW
elif uverr == uv.UV_EAI_PROTOCOL:
sock_err = socket_EAI_PROTOCOL
elif uverr == uv.UV_EAI_SERVICE:
sock_err = socket_EAI_SERVICE
elif uverr == uv.UV_EAI_SOCKTYPE:
sock_err = socket_EAI_SOCKTYPE
return sock_err
cdef convert_error(int uverr):
cdef int sock_err
if uverr == uv.UV_ECANCELED:
return aio_CancelledError()
sock_err = __convert_socket_error(uverr)
if sock_err:
msg = system.gai_strerror(sock_err).decode('utf-8')
return socket_gaierror(sock_err, msg)
return __convert_python_error(uverr)
uvloop-0.8.0/uvloop/_patch.py 0000664 0001750 0001750 00000003765 13047176662 017072 0 ustar travis travis 0000000 0000000 import asyncio
import sys
def _format_coroutine(coro):
if asyncio.iscoroutine(coro) \
and not hasattr(coro, 'cr_code') \
and not hasattr(coro, 'gi_code'):
# Most likely a Cython coroutine
coro_name = '{}()'.format(coro.__qualname__ or coro.__name__)
running = False
try:
running = coro.cr_running
except AttributeError:
try:
running = coro.gi_running
except AttributeError:
pass
if running:
return '{} running'.format(coro_name)
else:
return coro_name
return _old_format_coroutine(coro)
async def _wait_for_data(self, func_name):
"""Wait until feed_data() or feed_eof() is called.
If stream was paused, automatically resume it.
"""
if self._waiter is not None:
raise RuntimeError('%s() called while another coroutine is '
'already waiting for incoming data' % func_name)
assert not self._eof, '_wait_for_data after EOF'
# Waiting for data while paused will make deadlock, so prevent it.
if self._paused:
self._paused = False
self._transport.resume_reading()
try:
create_future = self._loop.create_future
except AttributeError:
self._waiter = asyncio.Future(loop=self._loop)
else:
self._waiter = create_future()
try:
await self._waiter
finally:
self._waiter = None
if sys.version_info < (3, 5, 3):
# This is needed to support Cython 'async def' coroutines.
from asyncio import coroutines
_old_format_coroutine = coroutines._format_coroutine
coroutines._format_coroutine = _format_coroutine
if sys.version_info < (3, 5, 2):
# Fix a possible deadlock, improve performance.
from asyncio import streams
_old_wait_for_data = streams.StreamReader._wait_for_data
_wait_for_data.__module__ = _old_wait_for_data.__module__
streams.StreamReader._wait_for_data = _wait_for_data
uvloop-0.8.0/uvloop/request.pxd 0000664 0001750 0001750 00000000217 13047176662 017454 0 ustar travis travis 0000000 0000000 cdef class UVRequest:
cdef:
uv.uv_req_t *request
bint done
Loop loop
cdef on_done(self)
cdef cancel(self)
uvloop-0.8.0/uvloop/cbhandles.pyx 0000664 0001750 0001750 00000020351 13047176662 017735 0 ustar travis travis 0000000 0000000 @cython.no_gc_clear
@cython.freelist(DEFAULT_FREELIST_SIZE)
cdef class Handle:
def __cinit__(self):
self.cancelled = 0
self.cb_type = 0
self._source_traceback = None
cdef inline _set_loop(self, Loop loop):
self.loop = loop
if UVLOOP_DEBUG:
loop._debug_cb_handles_total += 1
loop._debug_cb_handles_count += 1
if loop._debug:
self._source_traceback = tb_extract_stack(sys_getframe(0))
def __dealloc__(self):
if UVLOOP_DEBUG and self.loop is not None:
self.loop._debug_cb_handles_count -= 1
if self.loop is None:
raise RuntimeError('Handle.loop is None in Handle.__dealloc__')
def __init__(self):
raise TypeError(
'{} is not supposed to be instantiated from Python'.format(
self.__class__.__name__))
cdef inline _run(self):
cdef:
int cb_type
object callback
if self.cancelled:
return
cb_type = self.cb_type
Py_INCREF(self) # Since _run is a cdef and there's no BoundMethod,
# we guard 'self' manually (since the callback
# might cause GC of the handle.)
try:
if cb_type == 1:
callback = self.arg1
args = self.arg2
if args is None:
callback()
else:
callback(*args)
elif cb_type == 2:
(self.callback)(self.arg1)
elif cb_type == 3:
(self.callback)(self.arg1, self.arg2)
elif cb_type == 4:
(self.callback)(self.arg1, self.arg2, self.arg3)
elif cb_type == 5:
(self.callback)(
self.arg1, self.arg2, self.arg3, self.arg4)
else:
raise RuntimeError('invalid Handle.cb_type: {}'.format(
cb_type))
except Exception as ex:
if cb_type == 1:
msg = 'Exception in callback {}'.format(callback)
else:
msg = 'Exception in callback {}'.format(self.meth_name)
context = {
'message': msg,
'exception': ex,
'handle': self,
}
if self._source_traceback is not None:
context['source_traceback'] = self._source_traceback
self.loop.call_exception_handler(context)
finally:
Py_DECREF(self)
cdef _cancel(self):
self.cancelled = 1
self.callback = NULL
self.arg2 = self.arg3 = self.arg4 = None
# Public API
def __repr__(self):
info = [self.__class__.__name__]
if self.cancelled:
info.append('cancelled')
if self.cb_type == 1:
func = self.arg1
if hasattr(func, '__qualname__'):
cb_name = getattr(func, '__qualname__')
elif hasattr(func, '__name__'):
cb_name = getattr(func, '__name__')
else:
cb_name = repr(func)
info.append(cb_name)
else:
info.append(self.meth_name)
if self._source_traceback is not None:
frame = self._source_traceback[-1]
info.append('created at {}:{}'.format(frame[0], frame[1]))
return '<' + ' '.join(info) + '>'
def cancel(self):
self._cancel()
@cython.no_gc_clear
@cython.freelist(DEFAULT_FREELIST_SIZE)
cdef class TimerHandle:
def __cinit__(self, Loop loop, object callback, object args,
uint64_t delay):
self.loop = loop
self.callback = callback
self.args = args
self.closed = 0
if loop._debug:
self._source_traceback = tb_extract_stack(sys_getframe(0))
self.timer = UVTimer.new(
loop, self._run, self, delay)
self.timer.start()
# Only add to loop._timers when `self.timer` is successfully created
loop._timers.add(self)
if UVLOOP_DEBUG:
self.loop._debug_cb_timer_handles_total += 1
self.loop._debug_cb_timer_handles_count += 1
def __dealloc__(self):
if UVLOOP_DEBUG:
self.loop._debug_cb_timer_handles_count -= 1
if self.closed == 0:
raise RuntimeError('active TimerHandle is deallacating')
cdef _cancel(self):
if self.closed == 1:
return
self.closed = 1
self.callback = None
self.args = None
try:
self.loop._timers.remove(self)
finally:
self.timer._close()
self.timer = None # let it die asap
cdef _run(self):
if self.closed == 1:
return
callback = self.callback
args = self.args
self._cancel()
Py_INCREF(self) # Since _run is a cdef and there's no BoundMethod,
# we guard 'self' manually.
if self.loop._debug:
started = time_monotonic()
try:
if args is not None:
callback(*args)
else:
callback()
except Exception as ex:
context = {
'message': 'Exception in callback {}'.format(callback),
'exception': ex,
'handle': self,
}
if self._source_traceback is not None:
context['source_traceback'] = self._source_traceback
self.loop.call_exception_handler(context)
else:
if self.loop._debug:
delta = time_monotonic() - started
if delta > self.loop.slow_callback_duration:
aio_logger.warning(
'Executing %r took %.3f seconds',
self, delta)
finally:
Py_DECREF(self)
# Public API
def __repr__(self):
info = [self.__class__.__name__]
if self.closed:
info.append('cancelled')
func = self.callback
if hasattr(func, '__qualname__'):
cb_name = getattr(func, '__qualname__')
elif hasattr(func, '__name__'):
cb_name = getattr(func, '__name__')
else:
cb_name = repr(func)
info.append(cb_name)
if self._source_traceback is not None:
frame = self._source_traceback[-1]
info.append('created at {}:{}'.format(frame[0], frame[1]))
return '<' + ' '.join(info) + '>'
def cancel(self):
self._cancel()
cdef new_Handle(Loop loop, object callback, object args):
cdef Handle handle
handle = Handle.__new__(Handle)
handle._set_loop(loop)
handle.cb_type = 1
handle.arg1 = callback
handle.arg2 = args
return handle
cdef new_MethodHandle(Loop loop, str name, method_t callback, object ctx):
cdef Handle handle
handle = Handle.__new__(Handle)
handle._set_loop(loop)
handle.cb_type = 2
handle.meth_name = name
handle.callback = callback
handle.arg1 = ctx
return handle
cdef new_MethodHandle1(Loop loop, str name, method1_t callback,
object ctx, object arg):
cdef Handle handle
handle = Handle.__new__(Handle)
handle._set_loop(loop)
handle.cb_type = 3
handle.meth_name = name
handle.callback = callback
handle.arg1 = ctx
handle.arg2 = arg
return handle
cdef new_MethodHandle2(Loop loop, str name, method2_t callback, object ctx,
object arg1, object arg2):
cdef Handle handle
handle = Handle.__new__(Handle)
handle._set_loop(loop)
handle.cb_type = 4
handle.meth_name = name
handle.callback = callback
handle.arg1 = ctx
handle.arg2 = arg1
handle.arg3 = arg2
return handle
cdef new_MethodHandle3(Loop loop, str name, method3_t callback, object ctx,
object arg1, object arg2, object arg3):
cdef Handle handle
handle = Handle.__new__(Handle)
handle._set_loop(loop)
handle.cb_type = 5
handle.meth_name = name
handle.callback = callback
handle.arg1 = ctx
handle.arg2 = arg1
handle.arg3 = arg2
handle.arg4 = arg3
return handle
uvloop-0.8.0/uvloop/loop.c 0000664 0001750 0001750 00025132642 13047177422 016376 0 ustar travis travis 0000000 0000000 /* Generated by Cython 0.25.2 */
/* BEGIN: Cython Metadata
{
"distutils": {
"depends": [],
"extra_compile_args": [
"-O2"
]
},
"module_name": "uvloop.loop"
}
END: Cython Metadata */
#define PY_SSIZE_T_CLEAN
#include "Python.h"
#ifndef Py_PYTHON_H
#error Python headers needed to compile C extensions, please install development version of Python.
#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000)
#error Cython requires Python 2.6+ or Python 3.2+.
#else
#define CYTHON_ABI "0_25_2"
#include
#ifndef offsetof
#define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
#endif
#if !defined(WIN32) && !defined(MS_WINDOWS)
#ifndef __stdcall
#define __stdcall
#endif
#ifndef __cdecl
#define __cdecl
#endif
#ifndef __fastcall
#define __fastcall
#endif
#endif
#ifndef DL_IMPORT
#define DL_IMPORT(t) t
#endif
#ifndef DL_EXPORT
#define DL_EXPORT(t) t
#endif
#ifndef HAVE_LONG_LONG
#if PY_VERSION_HEX >= 0x03030000 || (PY_MAJOR_VERSION == 2 && PY_VERSION_HEX >= 0x02070000)
#define HAVE_LONG_LONG
#endif
#endif
#ifndef PY_LONG_LONG
#define PY_LONG_LONG LONG_LONG
#endif
#ifndef Py_HUGE_VAL
#define Py_HUGE_VAL HUGE_VAL
#endif
#ifdef PYPY_VERSION
#define CYTHON_COMPILING_IN_PYPY 1
#define CYTHON_COMPILING_IN_PYSTON 0
#define CYTHON_COMPILING_IN_CPYTHON 0
#undef CYTHON_USE_TYPE_SLOTS
#define CYTHON_USE_TYPE_SLOTS 0
#undef CYTHON_USE_ASYNC_SLOTS
#define CYTHON_USE_ASYNC_SLOTS 0
#undef CYTHON_USE_PYLIST_INTERNALS
#define CYTHON_USE_PYLIST_INTERNALS 0
#undef CYTHON_USE_UNICODE_INTERNALS
#define CYTHON_USE_UNICODE_INTERNALS 0
#undef CYTHON_USE_UNICODE_WRITER
#define CYTHON_USE_UNICODE_WRITER 0
#undef CYTHON_USE_PYLONG_INTERNALS
#define CYTHON_USE_PYLONG_INTERNALS 0
#undef CYTHON_AVOID_BORROWED_REFS
#define CYTHON_AVOID_BORROWED_REFS 1
#undef CYTHON_ASSUME_SAFE_MACROS
#define CYTHON_ASSUME_SAFE_MACROS 0
#undef CYTHON_UNPACK_METHODS
#define CYTHON_UNPACK_METHODS 0
#undef CYTHON_FAST_THREAD_STATE
#define CYTHON_FAST_THREAD_STATE 0
#undef CYTHON_FAST_PYCALL
#define CYTHON_FAST_PYCALL 0
#elif defined(PYSTON_VERSION)
#define CYTHON_COMPILING_IN_PYPY 0
#define CYTHON_COMPILING_IN_PYSTON 1
#define CYTHON_COMPILING_IN_CPYTHON 0
#ifndef CYTHON_USE_TYPE_SLOTS
#define CYTHON_USE_TYPE_SLOTS 1
#endif
#undef CYTHON_USE_ASYNC_SLOTS
#define CYTHON_USE_ASYNC_SLOTS 0
#undef CYTHON_USE_PYLIST_INTERNALS
#define CYTHON_USE_PYLIST_INTERNALS 0
#ifndef CYTHON_USE_UNICODE_INTERNALS
#define CYTHON_USE_UNICODE_INTERNALS 1
#endif
#undef CYTHON_USE_UNICODE_WRITER
#define CYTHON_USE_UNICODE_WRITER 0
#undef CYTHON_USE_PYLONG_INTERNALS
#define CYTHON_USE_PYLONG_INTERNALS 0
#ifndef CYTHON_AVOID_BORROWED_REFS
#define CYTHON_AVOID_BORROWED_REFS 0
#endif
#ifndef CYTHON_ASSUME_SAFE_MACROS
#define CYTHON_ASSUME_SAFE_MACROS 1
#endif
#ifndef CYTHON_UNPACK_METHODS
#define CYTHON_UNPACK_METHODS 1
#endif
#undef CYTHON_FAST_THREAD_STATE
#define CYTHON_FAST_THREAD_STATE 0
#undef CYTHON_FAST_PYCALL
#define CYTHON_FAST_PYCALL 0
#else
#define CYTHON_COMPILING_IN_PYPY 0
#define CYTHON_COMPILING_IN_PYSTON 0
#define CYTHON_COMPILING_IN_CPYTHON 1
#ifndef CYTHON_USE_TYPE_SLOTS
#define CYTHON_USE_TYPE_SLOTS 1
#endif
#if PY_MAJOR_VERSION < 3
#undef CYTHON_USE_ASYNC_SLOTS
#define CYTHON_USE_ASYNC_SLOTS 0
#elif !defined(CYTHON_USE_ASYNC_SLOTS)
#define CYTHON_USE_ASYNC_SLOTS 1
#endif
#if PY_VERSION_HEX < 0x02070000
#undef CYTHON_USE_PYLONG_INTERNALS
#define CYTHON_USE_PYLONG_INTERNALS 0
#elif !defined(CYTHON_USE_PYLONG_INTERNALS)
#define CYTHON_USE_PYLONG_INTERNALS 1
#endif
#ifndef CYTHON_USE_PYLIST_INTERNALS
#define CYTHON_USE_PYLIST_INTERNALS 1
#endif
#ifndef CYTHON_USE_UNICODE_INTERNALS
#define CYTHON_USE_UNICODE_INTERNALS 1
#endif
#if PY_VERSION_HEX < 0x030300F0
#undef CYTHON_USE_UNICODE_WRITER
#define CYTHON_USE_UNICODE_WRITER 0
#elif !defined(CYTHON_USE_UNICODE_WRITER)
#define CYTHON_USE_UNICODE_WRITER 1
#endif
#ifndef CYTHON_AVOID_BORROWED_REFS
#define CYTHON_AVOID_BORROWED_REFS 0
#endif
#ifndef CYTHON_ASSUME_SAFE_MACROS
#define CYTHON_ASSUME_SAFE_MACROS 1
#endif
#ifndef CYTHON_UNPACK_METHODS
#define CYTHON_UNPACK_METHODS 1
#endif
#ifndef CYTHON_FAST_THREAD_STATE
#define CYTHON_FAST_THREAD_STATE 1
#endif
#ifndef CYTHON_FAST_PYCALL
#define CYTHON_FAST_PYCALL 1
#endif
#endif
#if !defined(CYTHON_FAST_PYCCALL)
#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
#endif
#if CYTHON_USE_PYLONG_INTERNALS
#include "longintrepr.h"
#undef SHIFT
#undef BASE
#undef MASK
#endif
#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
#define Py_OptimizeFlag 0
#endif
#define __PYX_BUILD_PY_SSIZE_T "n"
#define CYTHON_FORMAT_SSIZE_T "z"
#if PY_MAJOR_VERSION < 3
#define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
#define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
#define __Pyx_DefaultClassType PyClass_Type
#else
#define __Pyx_BUILTIN_MODULE_NAME "builtins"
#define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
#define __Pyx_DefaultClassType PyType_Type
#endif
#ifndef Py_TPFLAGS_CHECKTYPES
#define Py_TPFLAGS_CHECKTYPES 0
#endif
#ifndef Py_TPFLAGS_HAVE_INDEX
#define Py_TPFLAGS_HAVE_INDEX 0
#endif
#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
#define Py_TPFLAGS_HAVE_NEWBUFFER 0
#endif
#ifndef Py_TPFLAGS_HAVE_FINALIZE
#define Py_TPFLAGS_HAVE_FINALIZE 0
#endif
#ifndef METH_FASTCALL
#define METH_FASTCALL 0x80
typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject **args,
Py_ssize_t nargs, PyObject *kwnames);
#else
#define __Pyx_PyCFunctionFast _PyCFunctionFast
#endif
#if CYTHON_FAST_PYCCALL
#define __Pyx_PyFastCFunction_Check(func)\
((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST)))))
#else
#define __Pyx_PyFastCFunction_Check(func) 0
#endif
#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
#define CYTHON_PEP393_ENABLED 1
#define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\
0 : _PyUnicode_Ready((PyObject *)(op)))
#define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u)
#define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
#define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u)
#define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u)
#define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u)
#define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i)
#define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch)
#define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
#else
#define CYTHON_PEP393_ENABLED 0
#define PyUnicode_1BYTE_KIND 1
#define PyUnicode_2BYTE_KIND 2
#define PyUnicode_4BYTE_KIND 4
#define __Pyx_PyUnicode_READY(op) (0)
#define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u)
#define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
#define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
#define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE))
#define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u))
#define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
#define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
#define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u))
#endif
#if CYTHON_COMPILING_IN_PYPY
#define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b)
#define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b)
#else
#define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b)
#define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
#define PyUnicode_Contains(u, s) PySequence_Contains(u, s)
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
#define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type)
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
#define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt)
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
#define PyObject_Malloc(s) PyMem_Malloc(s)
#define PyObject_Free(p) PyMem_Free(p)
#define PyObject_Realloc(p) PyMem_Realloc(p)
#endif
#if CYTHON_COMPILING_IN_PYSTON
#define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co)
#define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
#else
#define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0)
#define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno)
#endif
#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
#if PY_MAJOR_VERSION >= 3
#define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b)
#else
#define __Pyx_PyString_Format(a, b) PyString_Format(a, b)
#endif
#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII)
#define PyObject_ASCII(o) PyObject_Repr(o)
#endif
#if PY_MAJOR_VERSION >= 3
#define PyBaseString_Type PyUnicode_Type
#define PyStringObject PyUnicodeObject
#define PyString_Type PyUnicode_Type
#define PyString_Check PyUnicode_Check
#define PyString_CheckExact PyUnicode_CheckExact
#endif
#if PY_MAJOR_VERSION >= 3
#define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)
#define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)
#else
#define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
#define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
#endif
#ifndef PySet_CheckExact
#define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type)
#endif
#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)
#if PY_MAJOR_VERSION >= 3
#define PyIntObject PyLongObject
#define PyInt_Type PyLong_Type
#define PyInt_Check(op) PyLong_Check(op)
#define PyInt_CheckExact(op) PyLong_CheckExact(op)
#define PyInt_FromString PyLong_FromString
#define PyInt_FromUnicode PyLong_FromUnicode
#define PyInt_FromLong PyLong_FromLong
#define PyInt_FromSize_t PyLong_FromSize_t
#define PyInt_FromSsize_t PyLong_FromSsize_t
#define PyInt_AsLong PyLong_AsLong
#define PyInt_AS_LONG PyLong_AS_LONG
#define PyInt_AsSsize_t PyLong_AsSsize_t
#define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask
#define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
#define PyNumber_Int PyNumber_Long
#endif
#if PY_MAJOR_VERSION >= 3
#define PyBoolObject PyLongObject
#endif
#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY
#ifndef PyUnicode_InternFromString
#define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
#endif
#endif
#if PY_VERSION_HEX < 0x030200A4
typedef long Py_hash_t;
#define __Pyx_PyInt_FromHash_t PyInt_FromLong
#define __Pyx_PyInt_AsHash_t PyInt_AsLong
#else
#define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
#define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t
#endif
#if PY_MAJOR_VERSION >= 3
#define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func))
#else
#define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
#endif
#if CYTHON_USE_ASYNC_SLOTS
#if PY_VERSION_HEX >= 0x030500B1
#define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
#define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async)
#else
typedef struct {
unaryfunc am_await;
unaryfunc am_aiter;
unaryfunc am_anext;
} __Pyx_PyAsyncMethodsStruct;
#define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved))
#endif
#else
#define __Pyx_PyType_AsAsync(obj) NULL
#endif
#ifndef CYTHON_RESTRICT
#if defined(__GNUC__)
#define CYTHON_RESTRICT __restrict__
#elif defined(_MSC_VER) && _MSC_VER >= 1400
#define CYTHON_RESTRICT __restrict
#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
#define CYTHON_RESTRICT restrict
#else
#define CYTHON_RESTRICT
#endif
#endif
#ifndef CYTHON_UNUSED
# if defined(__GNUC__)
# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
# define CYTHON_UNUSED __attribute__ ((__unused__))
# else
# define CYTHON_UNUSED
# endif
# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))
# define CYTHON_UNUSED __attribute__ ((__unused__))
# else
# define CYTHON_UNUSED
# endif
#endif
#ifndef CYTHON_MAYBE_UNUSED_VAR
# if defined(__cplusplus)
template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
# else
# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
# endif
#endif
#ifndef CYTHON_NCP_UNUSED
# if CYTHON_COMPILING_IN_CPYTHON
# define CYTHON_NCP_UNUSED
# else
# define CYTHON_NCP_UNUSED CYTHON_UNUSED
# endif
#endif
#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
#ifndef CYTHON_INLINE
#if defined(__clang__)
#define CYTHON_INLINE __inline__ __attribute__ ((__unused__))
#elif defined(__GNUC__)
#define CYTHON_INLINE __inline__
#elif defined(_MSC_VER)
#define CYTHON_INLINE __inline
#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
#define CYTHON_INLINE inline
#else
#define CYTHON_INLINE
#endif
#endif
#if defined(WIN32) || defined(MS_WINDOWS)
#define _USE_MATH_DEFINES
#endif
#include
#ifdef NAN
#define __PYX_NAN() ((float) NAN)
#else
static CYTHON_INLINE float __PYX_NAN() {
float value;
memset(&value, 0xFF, sizeof(value));
return value;
}
#endif
#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL)
#define __Pyx_truncl trunc
#else
#define __Pyx_truncl truncl
#endif
#define __PYX_ERR(f_index, lineno, Ln_error) \
{ \
__pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \
}
#if PY_MAJOR_VERSION >= 3
#define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y)
#define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y)
#else
#define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y)
#define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y)
#endif
#ifndef __PYX_EXTERN_C
#ifdef __cplusplus
#define __PYX_EXTERN_C extern "C"
#else
#define __PYX_EXTERN_C extern
#endif
#endif
#define __PYX_HAVE__uvloop__loop
#define __PYX_HAVE_API__uvloop__loop
#include
#include
#include "arpa/inet.h"
#include "sys/socket.h"
#include "unistd.h"
#include "pthread.h"
#include "includes/compat.h"
#include "uv.h"
#include "includes/debug.h"
#include
#include
#include
#include "pythread.h"
#ifdef _OPENMP
#include
#endif /* _OPENMP */
#ifdef PYREX_WITHOUT_ASSERTIONS
#define CYTHON_WITHOUT_ASSERTIONS
#endif
typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding;
const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry;
#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0
#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0
#define __PYX_DEFAULT_STRING_ENCODING ""
#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString
#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
#define __Pyx_uchar_cast(c) ((unsigned char)c)
#define __Pyx_long_cast(x) ((long)x)
#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\
(sizeof(type) < sizeof(Py_ssize_t)) ||\
(sizeof(type) > sizeof(Py_ssize_t) &&\
likely(v < (type)PY_SSIZE_T_MAX ||\
v == (type)PY_SSIZE_T_MAX) &&\
(!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\
v == (type)PY_SSIZE_T_MIN))) ||\
(sizeof(type) == sizeof(Py_ssize_t) &&\
(is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\
v == (type)PY_SSIZE_T_MAX))) )
#if defined (__cplusplus) && __cplusplus >= 201103L
#include
#define __Pyx_sst_abs(value) std::abs(value)
#elif SIZEOF_INT >= SIZEOF_SIZE_T
#define __Pyx_sst_abs(value) abs(value)
#elif SIZEOF_LONG >= SIZEOF_SIZE_T
#define __Pyx_sst_abs(value) labs(value)
#elif defined (_MSC_VER) && defined (_M_X64)
#define __Pyx_sst_abs(value) _abs64(value)
#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
#define __Pyx_sst_abs(value) llabs(value)
#elif defined (__GNUC__)
#define __Pyx_sst_abs(value) __builtin_llabs(value)
#else
#define __Pyx_sst_abs(value) ((value<0) ? -value : value)
#endif
static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*);
static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
#define __Pyx_PyBytes_FromString PyBytes_FromString
#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
#if PY_MAJOR_VERSION < 3
#define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString
#define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
#else
#define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString
#define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize
#endif
#define __Pyx_PyObject_AsSString(s) ((signed char*) __Pyx_PyObject_AsString(s))
#define __Pyx_PyObject_AsUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s))
#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s)
#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s)
#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s)
#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s)
#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
#if PY_MAJOR_VERSION < 3
static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u)
{
const Py_UNICODE *u_end = u;
while (*u_end++) ;
return (size_t)(u_end - u - 1);
}
#else
#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen
#endif
#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode
#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False))
static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);
static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
#if CYTHON_ASSUME_SAFE_MACROS
#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
#else
#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
#endif
#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))
#if PY_MAJOR_VERSION >= 3
#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))
#else
#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
#endif
#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
static int __Pyx_sys_getdefaultencoding_not_ascii;
static int __Pyx_init_sys_getdefaultencoding_params(void) {
PyObject* sys;
PyObject* default_encoding = NULL;
PyObject* ascii_chars_u = NULL;
PyObject* ascii_chars_b = NULL;
const char* default_encoding_c;
sys = PyImport_ImportModule("sys");
if (!sys) goto bad;
default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL);
Py_DECREF(sys);
if (!default_encoding) goto bad;
default_encoding_c = PyBytes_AsString(default_encoding);
if (!default_encoding_c) goto bad;
if (strcmp(default_encoding_c, "ascii") == 0) {
__Pyx_sys_getdefaultencoding_not_ascii = 0;
} else {
char ascii_chars[128];
int c;
for (c = 0; c < 128; c++) {
ascii_chars[c] = c;
}
__Pyx_sys_getdefaultencoding_not_ascii = 1;
ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
if (!ascii_chars_u) goto bad;
ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL);
if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) {
PyErr_Format(
PyExc_ValueError,
"This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.",
default_encoding_c);
goto bad;
}
Py_DECREF(ascii_chars_u);
Py_DECREF(ascii_chars_b);
}
Py_DECREF(default_encoding);
return 0;
bad:
Py_XDECREF(default_encoding);
Py_XDECREF(ascii_chars_u);
Py_XDECREF(ascii_chars_b);
return -1;
}
#endif
#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3
#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)
#else
#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
static char* __PYX_DEFAULT_STRING_ENCODING;
static int __Pyx_init_sys_getdefaultencoding_params(void) {
PyObject* sys;
PyObject* default_encoding = NULL;
char* default_encoding_c;
sys = PyImport_ImportModule("sys");
if (!sys) goto bad;
default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL);
Py_DECREF(sys);
if (!default_encoding) goto bad;
default_encoding_c = PyBytes_AsString(default_encoding);
if (!default_encoding_c) goto bad;
__PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c));
if (!__PYX_DEFAULT_STRING_ENCODING) goto bad;
strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);
Py_DECREF(default_encoding);
return 0;
bad:
Py_XDECREF(default_encoding);
return -1;
}
#endif
#endif
/* Test for GCC > 2.95 */
#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
#define likely(x) __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0)
#else /* !__GNUC__ or GCC < 2.95 */
#define likely(x) (x)
#define unlikely(x) (x)
#endif /* __GNUC__ */
static PyObject *__pyx_m;
static PyObject *__pyx_d;
static PyObject *__pyx_b;
static PyObject *__pyx_empty_tuple;
static PyObject *__pyx_empty_bytes;
static PyObject *__pyx_empty_unicode;
static int __pyx_lineno;
static int __pyx_clineno = 0;
static const char * __pyx_cfilenm= __FILE__;
static const char *__pyx_filename;
static const char *__pyx_f[] = {
"uvloop/errors.pyx",
"uvloop/loop.pyx",
"uvloop/handles/handle.pyx",
"uvloop/handles/basetransport.pyx",
"uvloop/handles/tcp.pyx",
"uvloop/handles/process.pyx",
"uvloop/future.pyx",
"uvloop/loop.pxd",
"uvloop/cbhandles.pyx",
"uvloop/handles/async_.pyx",
"uvloop/handles/idle.pyx",
"uvloop/handles/check.pyx",
"uvloop/handles/timer.pyx",
"uvloop/handles/poll.pyx",
"uvloop/handles/basetransport.pxd",
"uvloop/handles/stream.pyx",
"uvloop/handles/streamserver.pyx",
"uvloop/handles/pipe.pyx",
"uvloop/request.pyx",
"uvloop/dns.pyx",
"uvloop/handles/udp.pyx",
"uvloop/server.pyx",
"uvloop/chain_futs.pyx",
"type.pxd",
"bool.pxd",
"complex.pxd",
"uvloop/includes/stdlib.pxi",
};
/*--- Type declarations ---*/
struct __pyx_obj_6uvloop_4loop_Loop;
struct __pyx_obj_6uvloop_4loop_Handle;
struct __pyx_obj_6uvloop_4loop_TimerHandle;
struct __pyx_obj_6uvloop_4loop_UVHandle;
struct __pyx_obj_6uvloop_4loop_UVSocketHandle;
struct __pyx_obj_6uvloop_4loop_UVAsync;
struct __pyx_obj_6uvloop_4loop_UVIdle;
struct __pyx_obj_6uvloop_4loop_UVCheck;
struct __pyx_obj_6uvloop_4loop_UVTimer;
struct __pyx_obj_6uvloop_4loop_UVPoll;
struct __pyx_obj_6uvloop_4loop_UVBaseTransport;
struct __pyx_obj_6uvloop_4loop_UVStream;
struct __pyx_obj_6uvloop_4loop_UVStreamServer;
struct __pyx_obj_6uvloop_4loop_TCPServer;
struct __pyx_obj_6uvloop_4loop_TCPTransport;
struct __pyx_obj_6uvloop_4loop_UnixServer;
struct __pyx_obj_6uvloop_4loop_UnixTransport;
struct __pyx_obj_6uvloop_4loop_ReadUnixTransport;
struct __pyx_obj_6uvloop_4loop_WriteUnixTransport;
struct __pyx_obj_6uvloop_4loop_UVProcess;
struct __pyx_obj_6uvloop_4loop_UVProcessTransport;
struct __pyx_obj_6uvloop_4loop_UVRequest;
struct __pyx_obj_6uvloop_4loop_UDPTransport;
struct __pyx_obj_6uvloop_4loop_Server;
struct __pyx_obj_6uvloop_4loop__StreamWriteContext;
struct __pyx_obj_6uvloop_4loop__TCPConnectRequest;
struct __pyx_obj_6uvloop_4loop__PipeConnectRequest;
struct __pyx_obj_6uvloop_4loop_AddrInfo;
struct __pyx_obj_6uvloop_4loop_AddrInfoRequest;
struct __pyx_obj_6uvloop_4loop_NameInfoRequest;
struct __pyx_obj_6uvloop_4loop__UDPSendContext;
struct __pyx_obj_6uvloop_4loop_BaseFuture;
struct __pyx_obj_6uvloop_4loop_BaseTask;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2__sock_connect;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_4_getnameinfo;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_5_create_server;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_create_connection;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_7_genexpr;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_genexpr;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_9_create_unix_server;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_10_create_unix_connection;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_11_sock_sendall;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_12_sock_connect;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_13_connect_accepted_socket;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_14___subprocess_run;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_15_connect_read_pipe;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_16_connect_write_pipe;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_create_datagram_endpoint;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_18_genexpr;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_19_shutdown_asyncgens;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_20_wait_closed;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_21___iter__;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_22___await__;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_23___pyx_f_6uvloop_4loop__chain_future;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_24__test_coroutine_1;
struct __pyx_opt_args_6uvloop_4loop_8UVHandle__fatal_error;
struct __pyx_opt_args_6uvloop_4loop_15UVBaseTransport__set_write_buffer_limits;
struct __pyx_opt_args_6uvloop_4loop_15UVBaseTransport__fatal_error;
struct __pyx_opt_args_6uvloop_4loop_9TCPServer_bind;
struct __pyx_opt_args_6uvloop_4loop_12TCPTransport_bind;
struct __pyx_opt_args_6uvloop_4loop_6UVPoll__fatal_error;
struct __pyx_opt_args_6uvloop_4loop_14UVStreamServer__fatal_error;
/* "uvloop/loop.pxd":26
* cdef class UVBaseTransport(UVSocketHandle)
*
* ctypedef object (*method_t)(object) # <<<<<<<<<<<<<<
* ctypedef object (*method1_t)(object, object)
* ctypedef object (*method2_t)(object, object, object)
*/
typedef PyObject *(*__pyx_t_6uvloop_4loop_method_t)(PyObject *);
/* "uvloop/loop.pxd":27
*
* ctypedef object (*method_t)(object)
* ctypedef object (*method1_t)(object, object) # <<<<<<<<<<<<<<
* ctypedef object (*method2_t)(object, object, object)
* ctypedef object (*method3_t)(object, object, object, object)
*/
typedef PyObject *(*__pyx_t_6uvloop_4loop_method1_t)(PyObject *, PyObject *);
/* "uvloop/loop.pxd":28
* ctypedef object (*method_t)(object)
* ctypedef object (*method1_t)(object, object)
* ctypedef object (*method2_t)(object, object, object) # <<<<<<<<<<<<<<
* ctypedef object (*method3_t)(object, object, object, object)
*
*/
typedef PyObject *(*__pyx_t_6uvloop_4loop_method2_t)(PyObject *, PyObject *, PyObject *);
/* "uvloop/loop.pxd":29
* ctypedef object (*method1_t)(object, object)
* ctypedef object (*method2_t)(object, object, object)
* ctypedef object (*method3_t)(object, object, object, object) # <<<<<<<<<<<<<<
*
*
*/
typedef PyObject *(*__pyx_t_6uvloop_4loop_method3_t)(PyObject *, PyObject *, PyObject *, PyObject *);
/* "uvloop/handles/handle.pxd":19
*
* cdef _error(self, exc, throw)
* cdef _fatal_error(self, exc, throw, reason=?) # <<<<<<<<<<<<<<
*
* cdef _warn_unclosed(self)
*/
struct __pyx_opt_args_6uvloop_4loop_8UVHandle__fatal_error {
int __pyx_n;
PyObject *reason;
};
/* "uvloop/handles/basetransport.pxd":24
* # All "inline" methods are final
*
* cdef inline _set_write_buffer_limits(self, int high=*, int low=*) # <<<<<<<<<<<<<<
* cdef inline _maybe_pause_protocol(self)
* cdef inline _maybe_resume_protocol(self)
*/
struct __pyx_opt_args_6uvloop_4loop_15UVBaseTransport__set_write_buffer_limits {
int __pyx_n;
int high;
int low;
};
/* "uvloop/handles/basetransport.pxd":36
*
* # Overloads of UVHandle methods:
* cdef _fatal_error(self, exc, throw, reason=?) # <<<<<<<<<<<<<<
* cdef _close(self)
*
*/
struct __pyx_opt_args_6uvloop_4loop_15UVBaseTransport__fatal_error {
int __pyx_n;
PyObject *reason;
};
/* "uvloop/handles/tcp.pxd":2
* cdef class TCPServer(UVStreamServer):
* cdef bind(self, system.sockaddr* addr, unsigned int flags=*) # <<<<<<<<<<<<<<
*
* @staticmethod
*/
struct __pyx_opt_args_6uvloop_4loop_9TCPServer_bind {
int __pyx_n;
unsigned int flags;
};
/* "uvloop/handles/tcp.pxd":16
* system.sockaddr_storage __sockname
*
* cdef bind(self, system.sockaddr* addr, unsigned int flags=*) # <<<<<<<<<<<<<<
* cdef connect(self, system.sockaddr* addr)
*
*/
struct __pyx_opt_args_6uvloop_4loop_12TCPTransport_bind {
int __pyx_n;
unsigned int flags;
};
/* "uvloop/handles/poll.pyx":168
* UVHandle._close(self)
*
* cdef _fatal_error(self, exc, throw, reason=None): # <<<<<<<<<<<<<<
* try:
* if self.reading_handle is not None:
*/
struct __pyx_opt_args_6uvloop_4loop_6UVPoll__fatal_error {
int __pyx_n;
PyObject *reason;
};
/* "uvloop/handles/streamserver.pyx":70
* client._accept(self)
*
* cdef _fatal_error(self, exc, throw, reason=None): # <<<<<<<<<<<<<<
* # Overload UVHandle._fatal_error
*
*/
struct __pyx_opt_args_6uvloop_4loop_14UVStreamServer__fatal_error {
int __pyx_n;
PyObject *reason;
};
/* "uvloop/loop.pxd":32
*
*
* cdef class Loop: # <<<<<<<<<<<<<<
* cdef:
* uv.uv_loop_t *uvloop
*/
struct __pyx_obj_6uvloop_4loop_Loop {
PyObject_HEAD
struct __pyx_vtabstruct_6uvloop_4loop_Loop *__pyx_vtab;
uv_loop_t *uvloop;
int _coroutine_wrapper_set;
PyObject *slow_callback_duration;
int _closed;
int _debug;
int _running;
int _stopping;
long _thread_id;
int _thread_is_main;
PyObject *_task_factory;
PyObject *_exception_handler;
PyObject *_default_executor;
PyObject *_ready;
PyObject *_queued_streams;
Py_ssize_t _ready_len;
PyObject *_transports;
PyObject *_signal_handlers;
PyObject *_ssock;
PyObject *_csock;
PyObject *_timers;
PyObject *_polls;
struct __pyx_obj_6uvloop_4loop_UVProcess *active_process_handler;
struct __pyx_obj_6uvloop_4loop_UVAsync *handler_async;
struct __pyx_obj_6uvloop_4loop_UVIdle *handler_idle;
struct __pyx_obj_6uvloop_4loop_UVCheck *handler_check__exec_writes;
PyObject *_last_error;
PyObject *__weakref__;
PyObject *_asyncgens;
int _asyncgens_shutdown_called;
char _recv_buffer[0x3E800];
int _recv_buffer_in_use;
int _debug_cc;
PyObject *_debug_handles_total;
PyObject *_debug_handles_closed;
PyObject *_debug_handles_current;
uint64_t _debug_uv_handles_total;
uint64_t _debug_uv_handles_freed;
uint64_t _debug_cb_handles_total;
uint64_t _debug_cb_handles_count;
uint64_t _debug_cb_timer_handles_total;
uint64_t _debug_cb_timer_handles_count;
uint64_t _debug_stream_shutdown_errors_total;
uint64_t _debug_stream_listen_errors_total;
uint64_t _debug_stream_read_cb_total;
uint64_t _debug_stream_read_cb_errors_total;
uint64_t _debug_stream_read_eof_total;
uint64_t _debug_stream_read_eof_cb_errors_total;
uint64_t _debug_stream_read_errors_total;
uint64_t _debug_stream_write_tries;
uint64_t _debug_stream_write_errors_total;
uint64_t _debug_stream_write_ctx_total;
uint64_t _debug_stream_write_ctx_cnt;
uint64_t _debug_stream_write_cb_errors_total;
uint64_t _poll_read_events_total;
uint64_t _poll_read_cb_errors_total;
uint64_t _poll_write_events_total;
uint64_t _poll_write_cb_errors_total;
uint64_t _sock_try_write_total;
uint64_t _debug_exception_handler_cnt;
};
/* "uvloop/cbhandles.pxd":1
* cdef class Handle: # <<<<<<<<<<<<<<
* cdef:
* Loop loop
*/
struct __pyx_obj_6uvloop_4loop_Handle {
PyObject_HEAD
struct __pyx_vtabstruct_6uvloop_4loop_Handle *__pyx_vtab;
struct __pyx_obj_6uvloop_4loop_Loop *loop;
int cancelled;
PyObject *meth_name;
int cb_type;
void *callback;
PyObject *arg1;
PyObject *arg2;
PyObject *arg3;
PyObject *arg4;
PyObject *__weakref__;
PyObject *_source_traceback;
};
/* "uvloop/cbhandles.pxd":20
*
*
* cdef class TimerHandle: # <<<<<<<<<<<<<<
* cdef:
* object callback, args
*/
struct __pyx_obj_6uvloop_4loop_TimerHandle {
PyObject_HEAD
struct __pyx_vtabstruct_6uvloop_4loop_TimerHandle *__pyx_vtab;
PyObject *callback;
PyObject *args;
int closed;
struct __pyx_obj_6uvloop_4loop_UVTimer *timer;
struct __pyx_obj_6uvloop_4loop_Loop *loop;
PyObject *__weakref__;
PyObject *_source_traceback;
};
/* "uvloop/loop.pxd":17
*
*
* cdef class UVHandle # <<<<<<<<<<<<<<
* cdef class UVSocketHandle(UVHandle)
*
*/
struct __pyx_obj_6uvloop_4loop_UVHandle {
PyObject_HEAD
struct __pyx_vtabstruct_6uvloop_4loop_UVHandle *__pyx_vtab;
uv_handle_t *_handle;
int _closed;
int _inited;
struct __pyx_obj_6uvloop_4loop_Loop *_loop;
PyObject *_source_traceback;
};
/* "uvloop/loop.pxd":18
*
* cdef class UVHandle
* cdef class UVSocketHandle(UVHandle) # <<<<<<<<<<<<<<
*
* cdef class UVAsync(UVHandle)
*/
struct __pyx_obj_6uvloop_4loop_UVSocketHandle {
struct __pyx_obj_6uvloop_4loop_UVHandle __pyx_base;
PyObject *_fileobj;
PyObject *__pyx___cached_socket;
};
/* "uvloop/loop.pxd":20
* cdef class UVSocketHandle(UVHandle)
*
* cdef class UVAsync(UVHandle) # <<<<<<<<<<<<<<
* cdef class UVTimer(UVHandle)
* cdef class UVIdle(UVHandle)
*/
struct __pyx_obj_6uvloop_4loop_UVAsync {
struct __pyx_obj_6uvloop_4loop_UVHandle __pyx_base;
__pyx_t_6uvloop_4loop_method_t callback;
PyObject *ctx;
};
/* "uvloop/loop.pxd":22
* cdef class UVAsync(UVHandle)
* cdef class UVTimer(UVHandle)
* cdef class UVIdle(UVHandle) # <<<<<<<<<<<<<<
*
* cdef class UVBaseTransport(UVSocketHandle)
*/
struct __pyx_obj_6uvloop_4loop_UVIdle {
struct __pyx_obj_6uvloop_4loop_UVHandle __pyx_base;
struct __pyx_obj_6uvloop_4loop_Handle *h;
int running;
};
/* "uvloop/handles/check.pxd":1
* cdef class UVCheck(UVHandle): # <<<<<<<<<<<<<<
* cdef:
* Handle h
*/
struct __pyx_obj_6uvloop_4loop_UVCheck {
struct __pyx_obj_6uvloop_4loop_UVHandle __pyx_base;
struct __pyx_obj_6uvloop_4loop_Handle *h;
int running;
};
/* "uvloop/loop.pxd":21
*
* cdef class UVAsync(UVHandle)
* cdef class UVTimer(UVHandle) # <<<<<<<<<<<<<<
* cdef class UVIdle(UVHandle)
*
*/
struct __pyx_obj_6uvloop_4loop_UVTimer {
struct __pyx_obj_6uvloop_4loop_UVHandle __pyx_base;
__pyx_t_6uvloop_4loop_method_t callback;
PyObject *ctx;
int running;
uint64_t timeout;
};
/* "uvloop/handles/poll.pxd":1
* cdef class UVPoll(UVHandle): # <<<<<<<<<<<<<<
* cdef:
* int fd
*/
struct __pyx_obj_6uvloop_4loop_UVPoll {
struct __pyx_obj_6uvloop_4loop_UVHandle __pyx_base;
int fd;
struct __pyx_obj_6uvloop_4loop_Handle *reading_handle;
struct __pyx_obj_6uvloop_4loop_Handle *writing_handle;
};
/* "uvloop/loop.pxd":24
* cdef class UVIdle(UVHandle)
*
* cdef class UVBaseTransport(UVSocketHandle) # <<<<<<<<<<<<<<
*
* ctypedef object (*method_t)(object)
*/
struct __pyx_obj_6uvloop_4loop_UVBaseTransport {
struct __pyx_obj_6uvloop_4loop_UVSocketHandle __pyx_base;
int _closing;
int _protocol_connected;
int _protocol_paused;
PyObject *_protocol_data_received;
size_t _high_water;
size_t _low_water;
PyObject *_protocol;
struct __pyx_obj_6uvloop_4loop_Server *_server;
PyObject *_waiter;
PyObject *_extra_info;
uint32_t _conn_lost;
PyObject *__weakref__;
};
/* "uvloop/handles/stream.pxd":1
* cdef class UVStream(UVBaseTransport): # <<<<<<<<<<<<<<
* cdef:
* uv.uv_shutdown_t _shutdown_req
*/
struct __pyx_obj_6uvloop_4loop_UVStream {
struct __pyx_obj_6uvloop_4loop_UVBaseTransport __pyx_base;
uv_shutdown_t _shutdown_req;
int __pyx___shutting_down;
int __pyx___reading;
int __pyx___read_error_close;
int _eof;
PyObject *_buffer;
size_t _buffer_size;
};
/* "uvloop/handles/streamserver.pxd":1
* cdef class UVStreamServer(UVSocketHandle): # <<<<<<<<<<<<<<
* cdef:
* object ssl
*/
struct __pyx_obj_6uvloop_4loop_UVStreamServer {
struct __pyx_obj_6uvloop_4loop_UVSocketHandle __pyx_base;
PyObject *ssl;
PyObject *protocol_factory;
int opened;
struct __pyx_obj_6uvloop_4loop_Server *_server;
};
/* "uvloop/handles/tcp.pxd":1
* cdef class TCPServer(UVStreamServer): # <<<<<<<<<<<<<<
* cdef bind(self, system.sockaddr* addr, unsigned int flags=*)
*
*/
struct __pyx_obj_6uvloop_4loop_TCPServer {
struct __pyx_obj_6uvloop_4loop_UVStreamServer __pyx_base;
};
/* "uvloop/handles/tcp.pxd":9
*
*
* cdef class TCPTransport(UVStream): # <<<<<<<<<<<<<<
* cdef:
* bint __peername_set
*/
struct __pyx_obj_6uvloop_4loop_TCPTransport {
struct __pyx_obj_6uvloop_4loop_UVStream __pyx_base;
int __pyx___peername_set;
int __pyx___sockname_set;
struct sockaddr_storage __pyx___peername;
struct sockaddr_storage __pyx___sockname;
};
/* "uvloop/handles/pipe.pxd":1
* cdef class UnixServer(UVStreamServer): # <<<<<<<<<<<<<<
*
* cdef bind(self, str path)
*/
struct __pyx_obj_6uvloop_4loop_UnixServer {
struct __pyx_obj_6uvloop_4loop_UVStreamServer __pyx_base;
};
/* "uvloop/handles/pipe.pxd":10
*
*
* cdef class UnixTransport(UVStream): # <<<<<<<<<<<<<<
*
* @staticmethod
*/
struct __pyx_obj_6uvloop_4loop_UnixTransport {
struct __pyx_obj_6uvloop_4loop_UVStream __pyx_base;
};
/* "uvloop/handles/pipe.pxd":19
*
*
* cdef class ReadUnixTransport(UVStream): # <<<<<<<<<<<<<<
*
* @staticmethod
*/
struct __pyx_obj_6uvloop_4loop_ReadUnixTransport {
struct __pyx_obj_6uvloop_4loop_UVStream __pyx_base;
};
/* "uvloop/handles/pipe.pxd":26
*
*
* cdef class WriteUnixTransport(UVStream): # <<<<<<<<<<<<<<
*
* @staticmethod
*/
struct __pyx_obj_6uvloop_4loop_WriteUnixTransport {
struct __pyx_obj_6uvloop_4loop_UVStream __pyx_base;
};
/* "uvloop/handles/process.pxd":1
* cdef class UVProcess(UVHandle): # <<<<<<<<<<<<<<
* cdef:
* object _returncode
*/
struct __pyx_obj_6uvloop_4loop_UVProcess {
struct __pyx_obj_6uvloop_4loop_UVHandle __pyx_base;
PyObject *_returncode;
PyObject *_pid;
PyObject *_errpipe_read;
PyObject *_errpipe_write;
PyObject *_preexec_fn;
int _restore_signals;
PyObject *_fds_to_close;
uv_process_options_t options;
uv_stdio_container_t iocnt[3];
PyObject *__pyx___env;
char **uv_opt_env;
PyObject *__pyx___args;
char **uv_opt_args;
char *uv_opt_file;
PyObject *__pyx___cwd;
};
/* "uvloop/handles/process.pxd":43
*
*
* cdef class UVProcessTransport(UVProcess): # <<<<<<<<<<<<<<
* cdef:
* list _exit_waiters
*/
struct __pyx_obj_6uvloop_4loop_UVProcessTransport {
struct __pyx_obj_6uvloop_4loop_UVProcess __pyx_base;
PyObject *_exit_waiters;
PyObject *_init_futs;
int _stdio_ready;
PyObject *_pending_calls;
PyObject *_protocol;
int _finished;
struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *_stdin;
struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *_stdout;
struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *_stderr;
PyObject *stdin_proto;
PyObject *stdout_proto;
PyObject *stderr_proto;
};
/* "uvloop/request.pxd":1
* cdef class UVRequest: # <<<<<<<<<<<<<<
* cdef:
* uv.uv_req_t *request
*/
struct __pyx_obj_6uvloop_4loop_UVRequest {
PyObject_HEAD
struct __pyx_vtabstruct_6uvloop_4loop_UVRequest *__pyx_vtab;
uv_req_t *request;
int done;
struct __pyx_obj_6uvloop_4loop_Loop *loop;
};
/* "uvloop/handles/udp.pxd":1
* cdef class UDPTransport(UVBaseTransport): # <<<<<<<<<<<<<<
* cdef:
* bint __receiving
*/
struct __pyx_obj_6uvloop_4loop_UDPTransport {
struct __pyx_obj_6uvloop_4loop_UVBaseTransport __pyx_base;
int __pyx___receiving;
int _family;
int _address_set;
struct sockaddr_storage _address;
PyObject *_cached_py_address;
};
/* "uvloop/server.pxd":1
* cdef class Server: # <<<<<<<<<<<<<<
* cdef:
* list _servers
*/
struct __pyx_obj_6uvloop_4loop_Server {
PyObject_HEAD
struct __pyx_vtabstruct_6uvloop_4loop_Server *__pyx_vtab;
PyObject *_servers;
PyObject *_waiters;
int _active_count;
struct __pyx_obj_6uvloop_4loop_Loop *_loop;
};
/* "uvloop/handles/stream.pyx":5
* @cython.no_gc_clear
* @cython.freelist(DEFAULT_FREELIST_SIZE)
* cdef class _StreamWriteContext: # <<<<<<<<<<<<<<
* # used to hold additional write request information for uv_write
*
*/
struct __pyx_obj_6uvloop_4loop__StreamWriteContext {
PyObject_HEAD
struct __pyx_vtabstruct_6uvloop_4loop__StreamWriteContext *__pyx_vtab;
uv_write_t req;
PyObject *buffers;
uv_buf_t uv_bufs_sml[4];
Py_buffer py_bufs_sml[4];
int py_bufs_sml_inuse;
uv_buf_t *uv_bufs;
Py_buffer *py_bufs;
size_t py_bufs_len;
uv_buf_t *uv_bufs_start;
size_t uv_bufs_len;
struct __pyx_obj_6uvloop_4loop_UVStream *stream;
int closed;
};
/* "uvloop/handles/tcp.pyx":171
*
*
* cdef class _TCPConnectRequest(UVRequest): # <<<<<<<<<<<<<<
* cdef:
* TCPTransport transport
*/
struct __pyx_obj_6uvloop_4loop__TCPConnectRequest {
struct __pyx_obj_6uvloop_4loop_UVRequest __pyx_base;
struct __pyx_obj_6uvloop_4loop_TCPTransport *transport;
};
/* "uvloop/handles/pipe.pyx":176
*
*
* cdef class _PipeConnectRequest(UVRequest): # <<<<<<<<<<<<<<
* cdef:
* UnixTransport transport
*/
struct __pyx_obj_6uvloop_4loop__PipeConnectRequest {
struct __pyx_obj_6uvloop_4loop_UVRequest __pyx_base;
struct __pyx_obj_6uvloop_4loop_UnixTransport *transport;
};
/* "uvloop/dns.pyx":185
*
* @cython.freelist(DEFAULT_FREELIST_SIZE)
* cdef class AddrInfo: # <<<<<<<<<<<<<<
* cdef:
* system.addrinfo *data
*/
struct __pyx_obj_6uvloop_4loop_AddrInfo {
PyObject_HEAD
struct __pyx_vtabstruct_6uvloop_4loop_AddrInfo *__pyx_vtab;
struct addrinfo *data;
};
/* "uvloop/dns.pyx":229
*
*
* cdef class AddrInfoRequest(UVRequest): # <<<<<<<<<<<<<<
* cdef:
* system.addrinfo hints
*/
struct __pyx_obj_6uvloop_4loop_AddrInfoRequest {
struct __pyx_obj_6uvloop_4loop_UVRequest __pyx_base;
struct addrinfo hints;
PyObject *callback;
};
/* "uvloop/dns.pyx":288
*
*
* cdef class NameInfoRequest(UVRequest): # <<<<<<<<<<<<<<
* cdef:
* object callback
*/
struct __pyx_obj_6uvloop_4loop_NameInfoRequest {
struct __pyx_obj_6uvloop_4loop_UVRequest __pyx_base;
PyObject *callback;
};
/* "uvloop/handles/udp.pyx":3
* @cython.no_gc_clear
* @cython.freelist(DEFAULT_FREELIST_SIZE)
* cdef class _UDPSendContext: # <<<<<<<<<<<<<<
* # used to hold additional write request information for uv_write
*
*/
struct __pyx_obj_6uvloop_4loop__UDPSendContext {
PyObject_HEAD
struct __pyx_vtabstruct_6uvloop_4loop__UDPSendContext *__pyx_vtab;
uv_udp_send_t req;
uv_buf_t uv_buf;
Py_buffer py_buf;
struct __pyx_obj_6uvloop_4loop_UDPTransport *udp;
int closed;
struct sockaddr_storage addr;
};
/* "uvloop/future.pyx":24
*
*
* cdef class BaseFuture: # <<<<<<<<<<<<<<
* cdef:
* int _state
*/
struct __pyx_obj_6uvloop_4loop_BaseFuture {
PyObject_HEAD
struct __pyx_vtabstruct_6uvloop_4loop_BaseFuture *__pyx_vtab;
int _state;
struct __pyx_obj_6uvloop_4loop_Loop *_loop;
PyObject *_callbacks;
PyObject *_exception;
PyObject *_result;
int _blocking;
PyObject *_source_traceback;
int _log_traceback;
};
/* "uvloop/future.pyx":249
*
*
* cdef class BaseTask(BaseFuture): # <<<<<<<<<<<<<<
* cdef:
* readonly object _coro
*/
struct __pyx_obj_6uvloop_4loop_BaseTask {
struct __pyx_obj_6uvloop_4loop_BaseFuture __pyx_base;
PyObject *_coro;
PyObject *_fut_waiter;
int _must_cancel;
int _log_destroy_pending;
};
/* "uvloop/loop.pyx":625
* return result
*
* cdef _getaddrinfo(self, object host, object port, # <<<<<<<<<<<<<<
* int family, int type,
* int proto, int flags,
*/
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo {
PyObject_HEAD
PyObject *__pyx_v_fut;
int __pyx_v_unpack;
};
/* "uvloop/loop.pyx":665
* return fut
*
* cdef _getnameinfo(self, system.sockaddr *addr, int flags): # <<<<<<<<<<<<<<
* cdef NameInfoRequest nr
* fut = self._new_future()
*/
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo {
PyObject_HEAD
PyObject *__pyx_v_fut;
};
/* "uvloop/loop.pyx":766
* self._remove_reader(fd)
*
* cdef _sock_connect(self, fut, sock, address): # <<<<<<<<<<<<<<
* cdef:
* Handle handle
*/
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2__sock_connect {
PyObject_HEAD
PyObject *__pyx_v_fd;
struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
};
/* "uvloop/loop.pyx":1167
* return self._task_factory
*
* def run_until_complete(self, future): # <<<<<<<<<<<<<<
* """Run until the Future is done.
*
*/
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete {
PyObject_HEAD
struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
};
/* "uvloop/loop.pyx":1217
* return self._getaddrinfo(host, port, family, type, proto, flags, 1)
*
* async def getnameinfo(self, sockaddr, int flags=0): # <<<<<<<<<<<<<<
* cdef:
* AddrInfo ai_cnt
*/
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_4_getnameinfo {
PyObject_HEAD
struct addrinfo *__pyx_v_ai;
struct __pyx_obj_6uvloop_4loop_AddrInfo *__pyx_v_ai_cnt;
int __pyx_v_flags;
PyObject *__pyx_v_flowinfo;
PyObject *__pyx_v_scope_id;
struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
struct sockaddr_in6 *__pyx_v_sin6;
Py_ssize_t __pyx_v_sl;
PyObject *__pyx_v_sockaddr;
};
/* "uvloop/loop.pyx":1271
* return await self._getnameinfo(ai.ai_addr, flags)
*
* async def create_server(self, protocol_factory, host=None, port=None, # <<<<<<<<<<<<<<
* *,
* int family=uv.AF_UNSPEC,
*/
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_5_create_server {
PyObject_HEAD
struct addrinfo *__pyx_v_addrinfo;
PyObject *__pyx_v_backlog;
int __pyx_v_completed;
int __pyx_v_family;
PyObject *__pyx_v_fileno;
int __pyx_v_flags;
PyObject *__pyx_v_fs;
PyObject *__pyx_v_host;
PyObject *__pyx_v_hosts;
PyObject *__pyx_v_info;
PyObject *__pyx_v_infos;
PyObject *__pyx_v_port;
PyObject *__pyx_v_protocol_factory;
PyObject *__pyx_v_reuse_address;
PyObject *__pyx_v_reuse_port;
struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server;
PyObject *__pyx_v_sock;
PyObject *__pyx_v_ssl;
struct __pyx_obj_6uvloop_4loop_TCPServer *__pyx_v_tcp;
};
/* "uvloop/loop.pyx":1399
* return server
*
* async def create_connection(self, protocol_factory, host=None, port=None, *, # <<<<<<<<<<<<<<
* ssl=None, family=0, proto=0, flags=0, sock=None,
* local_addr=None, server_hostname=None):
*/
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_create_connection {
PyObject_HEAD
struct __pyx_obj_6uvloop_4loop_AddrInfo *__pyx_v_ai_local;
struct __pyx_obj_6uvloop_4loop_AddrInfo *__pyx_v_ai_remote;
PyObject *__pyx_v_app_protocol;
PyObject *__pyx_v_exc;
PyObject *__pyx_v_exceptions;
PyObject *__pyx_v_f1;
PyObject *__pyx_v_f2;
PyObject *__pyx_v_family;
PyObject *__pyx_v_fileno;
PyObject *__pyx_v_flags;
PyObject *__pyx_v_fs;
PyObject *__pyx_v_genexpr;
PyObject *__pyx_v_host;
struct addrinfo *__pyx_v_lai;
struct sockaddr_storage __pyx_v_lai_addr_static;
struct addrinfo *__pyx_v_lai_iter;
struct addrinfo __pyx_v_lai_static;
PyObject *__pyx_v_local_addr;
PyObject *__pyx_v_model;
PyObject *__pyx_v_port;
PyObject *__pyx_v_proto;
PyObject *__pyx_v_protocol;
PyObject *__pyx_v_protocol_factory;
struct addrinfo *__pyx_v_rai;
struct sockaddr_storage __pyx_v_rai_addr_static;
struct addrinfo *__pyx_v_rai_iter;
struct addrinfo __pyx_v_rai_static;
struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
PyObject *__pyx_v_server_hostname;
PyObject *__pyx_v_sock;
PyObject *__pyx_v_ssl;
PyObject *__pyx_v_ssl_waiter;
PyObject *__pyx_v_sslcontext;
struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_tr;
PyObject *__pyx_v_waiter;
PyObject *__pyx_t_0;
PyObject *__pyx_t_1;
PyObject *__pyx_t_2;
};
/* "uvloop/loop.pyx":1567
* # If they all have the same str(), raise one.
* model = str(exceptions[0])
* if all(str(exc) == model for exc in exceptions): # <<<<<<<<<<<<<<
* raise exceptions[0]
* # Raise a combined exception so the user can see all
*/
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_7_genexpr {
PyObject_HEAD
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_create_connection *__pyx_outer_scope;
PyObject *__pyx_v_exc;
};
/* "uvloop/loop.pyx":1572
* # the various error messages.
* raise OSError('Multiple exceptions: {}'.format(
* ', '.join(str(exc) for exc in exceptions))) # <<<<<<<<<<<<<<
* else:
* if sock is None:
*/
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_genexpr {
PyObject_HEAD
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_create_connection *__pyx_outer_scope;
PyObject *__pyx_v_exc;
};
/* "uvloop/loop.pyx":1627
* return tr, protocol
*
* async def create_unix_server(self, protocol_factory, str path=None, # <<<<<<<<<<<<<<
* *, backlog=100, sock=None, ssl=None):
* """A coroutine which creates a UNIX Domain Socket server.
*/
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_9_create_unix_server {
PyObject_HEAD
PyObject *__pyx_v_backlog;
PyObject *__pyx_v_exc;
PyObject *__pyx_v_fileno;
PyObject *__pyx_v_msg;
PyObject *__pyx_v_path;
struct __pyx_obj_6uvloop_4loop_UnixServer *__pyx_v_pipe;
PyObject *__pyx_v_protocol_factory;
struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server;
PyObject *__pyx_v_sock;
PyObject *__pyx_v_ssl;
};
/* "uvloop/loop.pyx":1712
* return server
*
* async def create_unix_connection(self, protocol_factory, path, *, # <<<<<<<<<<<<<<
* ssl=None, sock=None,
* server_hostname=None):
*/
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_10_create_unix_connection {
PyObject_HEAD
PyObject *__pyx_v_app_protocol;
PyObject *__pyx_v_fileno;
PyObject *__pyx_v_path;
PyObject *__pyx_v_protocol;
PyObject *__pyx_v_protocol_factory;
struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
PyObject *__pyx_v_server_hostname;
PyObject *__pyx_v_sock;
PyObject *__pyx_v_ssl;
PyObject *__pyx_v_ssl_waiter;
PyObject *__pyx_v_sslcontext;
struct __pyx_obj_6uvloop_4loop_UnixTransport *__pyx_v_tr;
PyObject *__pyx_v_waiter;
PyObject *__pyx_t_0;
PyObject *__pyx_t_1;
PyObject *__pyx_t_2;
};
/* "uvloop/loop.pyx":1949
* return fut
*
* async def sock_sendall(self, sock, data): # <<<<<<<<<<<<<<
* """Send data to the socket.
*
*/
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_11_sock_sendall {
PyObject_HEAD
PyObject *__pyx_v_data;
int __pyx_v_fd;
PyObject *__pyx_v_fut;
struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle;
int __pyx_v_n;
struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
PyObject *__pyx_v_sock;
};
/* "uvloop/loop.pyx":2028
* return fut
*
* async def sock_connect(self, sock, address): # <<<<<<<<<<<<<<
* """Connect to a remote socket at address.
*
*/
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_12_sock_connect {
PyObject_HEAD
PyObject *__pyx_v__;
PyObject *__pyx_v_address;
PyObject *__pyx_v_fut;
struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
PyObject *__pyx_v_sock;
};
/* "uvloop/loop.pyx":2046
* await fut
*
* async def connect_accepted_socket(self, protocol_factory, sock, *, # <<<<<<<<<<<<<<
* ssl=None):
* """Handle an accepted connection.
*/
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_13_connect_accepted_socket {
PyObject_HEAD
PyObject *__pyx_v_app_protocol;
PyObject *__pyx_v_fileno;
PyObject *__pyx_v_protocol;
PyObject *__pyx_v_protocol_factory;
struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
PyObject *__pyx_v_sock;
PyObject *__pyx_v_ssl;
struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_transport;
PyObject *__pyx_v_transport_waiter;
PyObject *__pyx_v_waiter;
};
/* "uvloop/loop.pyx":2119
* self._default_executor = executor
*
* async def __subprocess_run(self, protocol_factory, args, # <<<<<<<<<<<<<<
* stdin=subprocess_PIPE,
* stdout=subprocess_PIPE,
*/
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_14___subprocess_run {
PyObject_HEAD
PyObject *__pyx_v___uvloop_sleep_after_fork;
PyObject *__pyx_v_args;
PyObject *__pyx_v_bufsize;
PyObject *__pyx_v_close_fds;
PyObject *__pyx_v_creationflags;
PyObject *__pyx_v_cwd;
int __pyx_v_debug_flags;
PyObject *__pyx_v_env;
PyObject *__pyx_v_executable;
PyObject *__pyx_v_pass_fds;
PyObject *__pyx_v_preexec_fn;
struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_proc;
PyObject *__pyx_v_protocol;
PyObject *__pyx_v_protocol_factory;
PyObject *__pyx_v_restore_signals;
struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
PyObject *__pyx_v_shell;
PyObject *__pyx_v_start_new_session;
PyObject *__pyx_v_startupinfo;
PyObject *__pyx_v_stderr;
PyObject *__pyx_v_stdin;
PyObject *__pyx_v_stdout;
PyObject *__pyx_v_universal_newlines;
PyObject *__pyx_v_waiter;
PyObject *__pyx_t_0;
PyObject *__pyx_t_1;
PyObject *__pyx_t_2;
};
/* "uvloop/loop.pyx":2205
* **kwargs)
*
* async def connect_read_pipe(self, proto_factory, pipe): # <<<<<<<<<<<<<<
* """Register read pipe in event loop. Set the pipe to non-blocking mode.
*
*/
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_15_connect_read_pipe {
PyObject_HEAD
int __pyx_v_fileno;
PyObject *__pyx_v_pipe;
PyObject *__pyx_v_proto;
PyObject *__pyx_v_proto_factory;
struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_transp;
PyObject *__pyx_v_waiter;
PyObject *__pyx_t_0;
PyObject *__pyx_t_1;
PyObject *__pyx_t_2;
};
/* "uvloop/loop.pyx":2231
* return transp, proto
*
* async def connect_write_pipe(self, proto_factory, pipe): # <<<<<<<<<<<<<<
* """Register write pipe in event loop.
*
*/
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_16_connect_write_pipe {
PyObject_HEAD
int __pyx_v_fileno;
PyObject *__pyx_v_pipe;
PyObject *__pyx_v_proto;
PyObject *__pyx_v_proto_factory;
struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *__pyx_v_transp;
PyObject *__pyx_v_waiter;
PyObject *__pyx_t_0;
PyObject *__pyx_t_1;
PyObject *__pyx_t_2;
};
/* "uvloop/loop.pyx":2330
* return True
*
* async def create_datagram_endpoint(self, protocol_factory, # <<<<<<<<<<<<<<
* local_addr=None, remote_addr=None, *,
* family=0, proto=0, flags=0,
*/
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_create_datagram_endpoint {
PyObject_HEAD
PyObject *__pyx_v_allow_broadcast;
PyObject *__pyx_v_ctx;
PyObject *__pyx_v_ex;
PyObject *__pyx_v_excs;
PyObject *__pyx_v_family;
PyObject *__pyx_v_flags;
PyObject *__pyx_v_genexpr;
PyObject *__pyx_v_lads;
struct addrinfo *__pyx_v_lai;
PyObject *__pyx_v_local_addr;
PyObject *__pyx_v_opts;
PyObject *__pyx_v_problems;
PyObject *__pyx_v_proto;
PyObject *__pyx_v_protocol;
PyObject *__pyx_v_protocol_factory;
PyObject *__pyx_v_rads;
struct addrinfo *__pyx_v_rai;
PyObject *__pyx_v_remote_addr;
PyObject *__pyx_v_reuse_address;
PyObject *__pyx_v_reuse_port;
struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
PyObject *__pyx_v_sock;
PyObject *__pyx_v_socket;
struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_udp;
PyObject *__pyx_v_waiter;
};
/* "uvloop/loop.pyx":2381
* allow_broadcast=allow_broadcast)
* problems = ', '.join(
* '{}={}'.format(k, v) for k, v in opts.items() if v) # <<<<<<<<<<<<<<
* raise ValueError(
* 'socket modifier keyword arguments can not be used '
*/
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_18_genexpr {
PyObject_HEAD
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_create_datagram_endpoint *__pyx_outer_scope;
PyObject *__pyx_v_k;
PyObject *__pyx_v_v;
};
/* "uvloop/loop.pyx":2508
* self._asyncgens.add(agen)
*
* async def shutdown_asyncgens(self): # <<<<<<<<<<<<<<
* """Shutdown all active asynchronous generators."""
* self._asyncgens_shutdown_called = True
*/
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_19_shutdown_asyncgens {
PyObject_HEAD
PyObject *__pyx_v_agen;
PyObject *__pyx_v_closing_agens;
PyObject *__pyx_v_result;
PyObject *__pyx_v_results;
struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self;
PyObject *__pyx_v_shutdown_coro;
};
/* "uvloop/server.pyx":35
* return '<%s sockets=%r>' % (self.__class__.__name__, self.sockets)
*
* async def wait_closed(self): # <<<<<<<<<<<<<<
* if self._servers is None or self._waiters is None:
* return
*/
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_20_wait_closed {
PyObject_HEAD
struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self;
PyObject *__pyx_v_waiter;
};
/* "uvloop/future.pyx":227
*
* # Copy of __await__
* def __iter__(self): # <<<<<<<<<<<<<<
* if self._state == _FUT_PENDING:
* self._blocking = True
*/
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_21___iter__ {
PyObject_HEAD
struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self;
};
/* "uvloop/future.pyx":238
*
* # Copy of __iter__
* def __await__(self): # <<<<<<<<<<<<<<
* if self._state == _FUT_PENDING:
* self._blocking = True
*/
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_22___await__ {
PyObject_HEAD
struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self;
};
/* "uvloop/chain_futs.pyx":41
*
*
* cdef _chain_future(source, destination): # <<<<<<<<<<<<<<
* """Chain two futures so that when one completes, so does the other.
*
*/
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_23___pyx_f_6uvloop_4loop__chain_future {
PyObject_HEAD
PyObject *__pyx_v__set_state;
PyObject *__pyx_v_dest_loop;
PyObject *__pyx_v_destination;
PyObject *__pyx_v_source;
PyObject *__pyx_v_source_loop;
};
/* "uvloop/loop.pyx":2640
* ########### Stuff for tests:
*
* async def _test_coroutine_1(): # <<<<<<<<<<<<<<
* return 42
*/
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_24__test_coroutine_1 {
PyObject_HEAD
};
/* "uvloop/handles/handle.pyx":2
* @cython.no_gc_clear
* cdef class UVHandle: # <<<<<<<<<<<<<<
* """A base class for all libuv handles.
*
*/
struct __pyx_vtabstruct_6uvloop_4loop_UVHandle {
PyObject *(*_start_init)(struct __pyx_obj_6uvloop_4loop_UVHandle *, struct __pyx_obj_6uvloop_4loop_Loop *);
PyObject *(*_abort_init)(struct __pyx_obj_6uvloop_4loop_UVHandle *);
PyObject *(*_finish_init)(struct __pyx_obj_6uvloop_4loop_UVHandle *);
int (*_is_alive)(struct __pyx_obj_6uvloop_4loop_UVHandle *);
PyObject *(*_ensure_alive)(struct __pyx_obj_6uvloop_4loop_UVHandle *);
PyObject *(*_error)(struct __pyx_obj_6uvloop_4loop_UVHandle *, PyObject *, PyObject *);
PyObject *(*_fatal_error)(struct __pyx_obj_6uvloop_4loop_UVHandle *, PyObject *, PyObject *, struct __pyx_opt_args_6uvloop_4loop_8UVHandle__fatal_error *__pyx_optional_args);
PyObject *(*_warn_unclosed)(struct __pyx_obj_6uvloop_4loop_UVHandle *);
PyObject *(*_free)(struct __pyx_obj_6uvloop_4loop_UVHandle *);
PyObject *(*_close)(struct __pyx_obj_6uvloop_4loop_UVHandle *);
};
static struct __pyx_vtabstruct_6uvloop_4loop_UVHandle *__pyx_vtabptr_6uvloop_4loop_UVHandle;
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVHandle__start_init(struct __pyx_obj_6uvloop_4loop_UVHandle *, struct __pyx_obj_6uvloop_4loop_Loop *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVHandle__abort_init(struct __pyx_obj_6uvloop_4loop_UVHandle *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVHandle__finish_init(struct __pyx_obj_6uvloop_4loop_UVHandle *);
static CYTHON_INLINE int __pyx_f_6uvloop_4loop_8UVHandle__is_alive(struct __pyx_obj_6uvloop_4loop_UVHandle *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVHandle__ensure_alive(struct __pyx_obj_6uvloop_4loop_UVHandle *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVHandle__free(struct __pyx_obj_6uvloop_4loop_UVHandle *);
/* "uvloop/handles/handle.pyx":213
*
* @cython.no_gc_clear
* cdef class UVSocketHandle(UVHandle): # <<<<<<<<<<<<<<
*
* def __cinit__(self):
*/
struct __pyx_vtabstruct_6uvloop_4loop_UVSocketHandle {
struct __pyx_vtabstruct_6uvloop_4loop_UVHandle __pyx_base;
PyObject *(*_fileno)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *);
PyObject *(*_new_socket)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *);
PyObject *(*_get_socket)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *);
PyObject *(*_attach_fileobj)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *, PyObject *);
PyObject *(*_open)(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *, int);
};
static struct __pyx_vtabstruct_6uvloop_4loop_UVSocketHandle *__pyx_vtabptr_6uvloop_4loop_UVSocketHandle;
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVSocketHandle__fileno(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVSocketHandle__get_socket(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVSocketHandle__attach_fileobj(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *, PyObject *);
/* "uvloop/handles/async_.pyx":2
* @cython.no_gc_clear
* cdef class UVAsync(UVHandle): # <<<<<<<<<<<<<<
* cdef _init(self, Loop loop, method_t callback, object ctx):
* cdef int err
*/
struct __pyx_vtabstruct_6uvloop_4loop_UVAsync {
struct __pyx_vtabstruct_6uvloop_4loop_UVHandle __pyx_base;
PyObject *(*_init)(struct __pyx_obj_6uvloop_4loop_UVAsync *, struct __pyx_obj_6uvloop_4loop_Loop *, __pyx_t_6uvloop_4loop_method_t, PyObject *);
PyObject *(*send)(struct __pyx_obj_6uvloop_4loop_UVAsync *);
struct __pyx_obj_6uvloop_4loop_UVAsync *(*new)(struct __pyx_obj_6uvloop_4loop_Loop *, __pyx_t_6uvloop_4loop_method_t, PyObject *);
};
static struct __pyx_vtabstruct_6uvloop_4loop_UVAsync *__pyx_vtabptr_6uvloop_4loop_UVAsync;
/* "uvloop/handles/timer.pyx":2
* @cython.no_gc_clear
* cdef class UVTimer(UVHandle): # <<<<<<<<<<<<<<
* cdef _init(self, Loop loop, method_t callback, object ctx,
* uint64_t timeout):
*/
struct __pyx_vtabstruct_6uvloop_4loop_UVTimer {
struct __pyx_vtabstruct_6uvloop_4loop_UVHandle __pyx_base;
PyObject *(*_init)(struct __pyx_obj_6uvloop_4loop_UVTimer *, struct __pyx_obj_6uvloop_4loop_Loop *, __pyx_t_6uvloop_4loop_method_t, PyObject *, uint64_t);
PyObject *(*stop)(struct __pyx_obj_6uvloop_4loop_UVTimer *);
PyObject *(*start)(struct __pyx_obj_6uvloop_4loop_UVTimer *);
struct __pyx_obj_6uvloop_4loop_UVTimer *(*new)(struct __pyx_obj_6uvloop_4loop_Loop *, __pyx_t_6uvloop_4loop_method_t, PyObject *, uint64_t);
};
static struct __pyx_vtabstruct_6uvloop_4loop_UVTimer *__pyx_vtabptr_6uvloop_4loop_UVTimer;
/* "uvloop/handles/idle.pyx":2
* @cython.no_gc_clear
* cdef class UVIdle(UVHandle): # <<<<<<<<<<<<<<
* cdef _init(self, Loop loop, Handle h):
* cdef int err
*/
struct __pyx_vtabstruct_6uvloop_4loop_UVIdle {
struct __pyx_vtabstruct_6uvloop_4loop_UVHandle __pyx_base;
PyObject *(*_init)(struct __pyx_obj_6uvloop_4loop_UVIdle *, struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_Handle *);
PyObject *(*stop)(struct __pyx_obj_6uvloop_4loop_UVIdle *);
PyObject *(*start)(struct __pyx_obj_6uvloop_4loop_UVIdle *);
struct __pyx_obj_6uvloop_4loop_UVIdle *(*new)(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_Handle *);
};
static struct __pyx_vtabstruct_6uvloop_4loop_UVIdle *__pyx_vtabptr_6uvloop_4loop_UVIdle;
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6UVIdle_stop(struct __pyx_obj_6uvloop_4loop_UVIdle *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6UVIdle_start(struct __pyx_obj_6uvloop_4loop_UVIdle *);
/* "uvloop/handles/basetransport.pyx":2
* @cython.no_gc_clear
* cdef class UVBaseTransport(UVSocketHandle): # <<<<<<<<<<<<<<
*
* def __cinit__(self):
*/
struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport {
struct __pyx_vtabstruct_6uvloop_4loop_UVSocketHandle __pyx_base;
PyObject *(*_set_write_buffer_limits)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, struct __pyx_opt_args_6uvloop_4loop_15UVBaseTransport__set_write_buffer_limits *__pyx_optional_args);
PyObject *(*_maybe_pause_protocol)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
PyObject *(*_maybe_resume_protocol)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
PyObject *(*_schedule_call_connection_made)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
PyObject *(*_schedule_call_connection_lost)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, PyObject *);
PyObject *(*_wakeup_waiter)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
PyObject *(*_call_connection_made)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
PyObject *(*_call_connection_lost)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, PyObject *);
PyObject *(*_set_server)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, struct __pyx_obj_6uvloop_4loop_Server *);
PyObject *(*_set_waiter)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, PyObject *);
PyObject *(*_set_protocol)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, PyObject *);
PyObject *(*_init_protocol)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
PyObject *(*_add_extra_info)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, PyObject *, PyObject *);
size_t (*_get_write_buffer_size)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
int (*_is_reading)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
PyObject *(*_start_reading)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
PyObject *(*_stop_reading)(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
};
static struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *__pyx_vtabptr_6uvloop_4loop_UVBaseTransport;
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__set_write_buffer_limits(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, struct __pyx_opt_args_6uvloop_4loop_15UVBaseTransport__set_write_buffer_limits *__pyx_optional_args);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__maybe_pause_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__maybe_resume_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__schedule_call_connection_made(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__schedule_call_connection_lost(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, PyObject *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__set_server(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, struct __pyx_obj_6uvloop_4loop_Server *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__set_waiter(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, PyObject *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__set_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, PyObject *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__init_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__add_extra_info(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *, PyObject *, PyObject *);
/* "uvloop/loop.pyx":63
*
* @cython.no_gc_clear
* cdef class Loop: # <<<<<<<<<<<<<<
* def __cinit__(self):
* cdef int err
*/
struct __pyx_vtabstruct_6uvloop_4loop_Loop {
PyObject *(*_init_debug_fields)(struct __pyx_obj_6uvloop_4loop_Loop *);
PyObject *(*_on_wake)(struct __pyx_obj_6uvloop_4loop_Loop *);
PyObject *(*_on_idle)(struct __pyx_obj_6uvloop_4loop_Loop *);
PyObject *(*__pyx___run)(struct __pyx_obj_6uvloop_4loop_Loop *, uv_run_mode);
PyObject *(*_run)(struct __pyx_obj_6uvloop_4loop_Loop *, uv_run_mode);
PyObject *(*_close)(struct __pyx_obj_6uvloop_4loop_Loop *);
PyObject *(*_stop)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *);
uint64_t (*_time)(struct __pyx_obj_6uvloop_4loop_Loop *);
PyObject *(*_queue_write)(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_UVStream *);
PyObject *(*_exec_queued_writes)(struct __pyx_obj_6uvloop_4loop_Loop *);
PyObject *(*_call_soon)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *);
PyObject *(*_call_soon_handle)(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_Handle *);
PyObject *(*_call_later)(struct __pyx_obj_6uvloop_4loop_Loop *, uint64_t, PyObject *, PyObject *);
void (*_handle_exception)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *);
PyObject *(*_new_future)(struct __pyx_obj_6uvloop_4loop_Loop *);
PyObject *(*_check_signal)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *);
PyObject *(*_check_closed)(struct __pyx_obj_6uvloop_4loop_Loop *);
PyObject *(*_check_thread)(struct __pyx_obj_6uvloop_4loop_Loop *);
PyObject *(*_getaddrinfo)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *, int, int, int, int, int);
PyObject *(*_getnameinfo)(struct __pyx_obj_6uvloop_4loop_Loop *, struct sockaddr *, int);
PyObject *(*_create_server)(struct __pyx_obj_6uvloop_4loop_Loop *, struct sockaddr *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *, int, PyObject *);
PyObject *(*_track_transport)(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_UVBaseTransport *);
PyObject *(*_ensure_fd_no_transport)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *);
PyObject *(*_add_reader)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Handle *);
PyObject *(*_remove_reader)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *);
PyObject *(*_add_writer)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Handle *);
PyObject *(*_remove_writer)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *);
PyObject *(*_sock_recv)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *, PyObject *);
PyObject *(*_sock_sendall)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *, PyObject *);
PyObject *(*_sock_accept)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *);
PyObject *(*_sock_connect)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *, PyObject *);
PyObject *(*_sock_connect_cb)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *, PyObject *);
PyObject *(*_sock_set_reuseport)(struct __pyx_obj_6uvloop_4loop_Loop *, int);
PyObject *(*_setup_signals)(struct __pyx_obj_6uvloop_4loop_Loop *);
PyObject *(*_shutdown_signals)(struct __pyx_obj_6uvloop_4loop_Loop *);
PyObject *(*_handle_signal)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *);
PyObject *(*_read_from_self)(struct __pyx_obj_6uvloop_4loop_Loop *);
PyObject *(*_process_self_data)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *);
PyObject *(*_set_coroutine_wrapper)(struct __pyx_obj_6uvloop_4loop_Loop *, int);
};
static struct __pyx_vtabstruct_6uvloop_4loop_Loop *__pyx_vtabptr_6uvloop_4loop_Loop;
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__queue_write(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_UVStream *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__call_soon(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__call_soon_handle(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_Handle *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__new_future(struct __pyx_obj_6uvloop_4loop_Loop *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__check_signal(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__check_closed(struct __pyx_obj_6uvloop_4loop_Loop *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__check_thread(struct __pyx_obj_6uvloop_4loop_Loop *);
static PyObject *__pyx_f_6uvloop_4loop_4Loop__add_reader(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Handle *);
static PyObject *__pyx_f_6uvloop_4loop_4Loop__remove_reader(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *);
static PyObject *__pyx_f_6uvloop_4loop_4Loop__add_writer(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Handle *);
static PyObject *__pyx_f_6uvloop_4loop_4Loop__remove_writer(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *);
/* "uvloop/cbhandles.pyx":3
* @cython.no_gc_clear
* @cython.freelist(DEFAULT_FREELIST_SIZE)
* cdef class Handle: # <<<<<<<<<<<<<<
* def __cinit__(self):
* self.cancelled = 0
*/
struct __pyx_vtabstruct_6uvloop_4loop_Handle {
PyObject *(*_set_loop)(struct __pyx_obj_6uvloop_4loop_Handle *, struct __pyx_obj_6uvloop_4loop_Loop *);
PyObject *(*_run)(struct __pyx_obj_6uvloop_4loop_Handle *);
PyObject *(*_cancel)(struct __pyx_obj_6uvloop_4loop_Handle *);
};
static struct __pyx_vtabstruct_6uvloop_4loop_Handle *__pyx_vtabptr_6uvloop_4loop_Handle;
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6Handle__set_loop(struct __pyx_obj_6uvloop_4loop_Handle *, struct __pyx_obj_6uvloop_4loop_Loop *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6Handle__run(struct __pyx_obj_6uvloop_4loop_Handle *);
/* "uvloop/cbhandles.pyx":126
* @cython.no_gc_clear
* @cython.freelist(DEFAULT_FREELIST_SIZE)
* cdef class TimerHandle: # <<<<<<<<<<<<<<
* def __cinit__(self, Loop loop, object callback, object args,
* uint64_t delay):
*/
struct __pyx_vtabstruct_6uvloop_4loop_TimerHandle {
PyObject *(*_run)(struct __pyx_obj_6uvloop_4loop_TimerHandle *);
PyObject *(*_cancel)(struct __pyx_obj_6uvloop_4loop_TimerHandle *);
};
static struct __pyx_vtabstruct_6uvloop_4loop_TimerHandle *__pyx_vtabptr_6uvloop_4loop_TimerHandle;
/* "uvloop/handles/check.pyx":2
* @cython.no_gc_clear
* cdef class UVCheck(UVHandle): # <<<<<<<<<<<<<<
* cdef _init(self, Loop loop, Handle h):
* cdef int err
*/
struct __pyx_vtabstruct_6uvloop_4loop_UVCheck {
struct __pyx_vtabstruct_6uvloop_4loop_UVHandle __pyx_base;
PyObject *(*_init)(struct __pyx_obj_6uvloop_4loop_UVCheck *, struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_Handle *);
PyObject *(*stop)(struct __pyx_obj_6uvloop_4loop_UVCheck *);
PyObject *(*start)(struct __pyx_obj_6uvloop_4loop_UVCheck *);
struct __pyx_obj_6uvloop_4loop_UVCheck *(*new)(struct __pyx_obj_6uvloop_4loop_Loop *, struct __pyx_obj_6uvloop_4loop_Handle *);
};
static struct __pyx_vtabstruct_6uvloop_4loop_UVCheck *__pyx_vtabptr_6uvloop_4loop_UVCheck;
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_7UVCheck_stop(struct __pyx_obj_6uvloop_4loop_UVCheck *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_7UVCheck_start(struct __pyx_obj_6uvloop_4loop_UVCheck *);
/* "uvloop/handles/poll.pyx":2
* @cython.no_gc_clear
* cdef class UVPoll(UVHandle): # <<<<<<<<<<<<<<
* cdef _init(self, Loop loop, int fd):
* cdef int err
*/
struct __pyx_vtabstruct_6uvloop_4loop_UVPoll {
struct __pyx_vtabstruct_6uvloop_4loop_UVHandle __pyx_base;
PyObject *(*_init)(struct __pyx_obj_6uvloop_4loop_UVPoll *, struct __pyx_obj_6uvloop_4loop_Loop *, int);
PyObject *(*_poll_start)(struct __pyx_obj_6uvloop_4loop_UVPoll *, int);
PyObject *(*_poll_stop)(struct __pyx_obj_6uvloop_4loop_UVPoll *);
int (*is_active)(struct __pyx_obj_6uvloop_4loop_UVPoll *);
PyObject *(*start_reading)(struct __pyx_obj_6uvloop_4loop_UVPoll *, struct __pyx_obj_6uvloop_4loop_Handle *);
PyObject *(*start_writing)(struct __pyx_obj_6uvloop_4loop_UVPoll *, struct __pyx_obj_6uvloop_4loop_Handle *);
PyObject *(*stop_reading)(struct __pyx_obj_6uvloop_4loop_UVPoll *);
PyObject *(*stop_writing)(struct __pyx_obj_6uvloop_4loop_UVPoll *);
PyObject *(*stop)(struct __pyx_obj_6uvloop_4loop_UVPoll *);
struct __pyx_obj_6uvloop_4loop_UVPoll *(*new)(struct __pyx_obj_6uvloop_4loop_Loop *, int);
};
static struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *__pyx_vtabptr_6uvloop_4loop_UVPoll;
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6UVPoll__poll_start(struct __pyx_obj_6uvloop_4loop_UVPoll *, int);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6UVPoll__poll_stop(struct __pyx_obj_6uvloop_4loop_UVPoll *);
/* "uvloop/handles/stream.pyx":208
*
* @cython.no_gc_clear
* cdef class UVStream(UVBaseTransport): # <<<<<<<<<<<<<<
*
* def __cinit__(self):
*/
struct __pyx_vtabstruct_6uvloop_4loop_UVStream {
struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport __pyx_base;
PyObject *(*_init)(struct __pyx_obj_6uvloop_4loop_UVStream *, struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *);
PyObject *(*_exec_write)(struct __pyx_obj_6uvloop_4loop_UVStream *);
PyObject *(*_shutdown)(struct __pyx_obj_6uvloop_4loop_UVStream *);
PyObject *(*_accept)(struct __pyx_obj_6uvloop_4loop_UVStream *, struct __pyx_obj_6uvloop_4loop_UVStream *);
PyObject *(*_close_on_read_error)(struct __pyx_obj_6uvloop_4loop_UVStream *);
PyObject *(*__pyx___reading_started)(struct __pyx_obj_6uvloop_4loop_UVStream *);
PyObject *(*__pyx___reading_stopped)(struct __pyx_obj_6uvloop_4loop_UVStream *);
PyObject *(*_write)(struct __pyx_obj_6uvloop_4loop_UVStream *, PyObject *);
PyObject *(*_try_write)(struct __pyx_obj_6uvloop_4loop_UVStream *, PyObject *);
PyObject *(*_on_accept)(struct __pyx_obj_6uvloop_4loop_UVStream *);
PyObject *(*_on_read)(struct __pyx_obj_6uvloop_4loop_UVStream *, PyObject *);
PyObject *(*_on_eof)(struct __pyx_obj_6uvloop_4loop_UVStream *);
PyObject *(*_on_write)(struct __pyx_obj_6uvloop_4loop_UVStream *);
PyObject *(*_on_connect)(struct __pyx_obj_6uvloop_4loop_UVStream *, PyObject *);
};
static struct __pyx_vtabstruct_6uvloop_4loop_UVStream *__pyx_vtabptr_6uvloop_4loop_UVStream;
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__init(struct __pyx_obj_6uvloop_4loop_UVStream *, struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__exec_write(struct __pyx_obj_6uvloop_4loop_UVStream *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__shutdown(struct __pyx_obj_6uvloop_4loop_UVStream *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__accept(struct __pyx_obj_6uvloop_4loop_UVStream *, struct __pyx_obj_6uvloop_4loop_UVStream *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__close_on_read_error(struct __pyx_obj_6uvloop_4loop_UVStream *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream___reading_started(struct __pyx_obj_6uvloop_4loop_UVStream *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream___reading_stopped(struct __pyx_obj_6uvloop_4loop_UVStream *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__write(struct __pyx_obj_6uvloop_4loop_UVStream *, PyObject *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__try_write(struct __pyx_obj_6uvloop_4loop_UVStream *, PyObject *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__on_accept(struct __pyx_obj_6uvloop_4loop_UVStream *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__on_read(struct __pyx_obj_6uvloop_4loop_UVStream *, PyObject *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__on_eof(struct __pyx_obj_6uvloop_4loop_UVStream *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__on_write(struct __pyx_obj_6uvloop_4loop_UVStream *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__on_connect(struct __pyx_obj_6uvloop_4loop_UVStream *, PyObject *);
/* "uvloop/handles/streamserver.pyx":2
* @cython.no_gc_clear
* cdef class UVStreamServer(UVSocketHandle): # <<<<<<<<<<<<<<
*
* def __cinit__(self):
*/
struct __pyx_vtabstruct_6uvloop_4loop_UVStreamServer {
struct __pyx_vtabstruct_6uvloop_4loop_UVSocketHandle __pyx_base;
PyObject *(*_init)(struct __pyx_obj_6uvloop_4loop_UVStreamServer *, struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *);
PyObject *(*_mark_as_open)(struct __pyx_obj_6uvloop_4loop_UVStreamServer *);
PyObject *(*listen)(struct __pyx_obj_6uvloop_4loop_UVStreamServer *, PyObject *);
PyObject *(*_on_listen)(struct __pyx_obj_6uvloop_4loop_UVStreamServer *);
struct __pyx_obj_6uvloop_4loop_UVStream *(*_make_new_transport)(struct __pyx_obj_6uvloop_4loop_UVStreamServer *, PyObject *, PyObject *);
};
static struct __pyx_vtabstruct_6uvloop_4loop_UVStreamServer *__pyx_vtabptr_6uvloop_4loop_UVStreamServer;
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVStreamServer__init(struct __pyx_obj_6uvloop_4loop_UVStreamServer *, struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVStreamServer__mark_as_open(struct __pyx_obj_6uvloop_4loop_UVStreamServer *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVStreamServer_listen(struct __pyx_obj_6uvloop_4loop_UVStreamServer *, PyObject *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVStreamServer__on_listen(struct __pyx_obj_6uvloop_4loop_UVStreamServer *);
/* "uvloop/handles/tcp.pyx":57
*
* @cython.no_gc_clear
* cdef class TCPServer(UVStreamServer): # <<<<<<<<<<<<<<
*
* @staticmethod
*/
struct __pyx_vtabstruct_6uvloop_4loop_TCPServer {
struct __pyx_vtabstruct_6uvloop_4loop_UVStreamServer __pyx_base;
PyObject *(*bind)(struct __pyx_obj_6uvloop_4loop_TCPServer *, struct sockaddr *, struct __pyx_opt_args_6uvloop_4loop_9TCPServer_bind *__pyx_optional_args);
struct __pyx_obj_6uvloop_4loop_TCPServer *(*new)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *, unsigned int);
};
static struct __pyx_vtabstruct_6uvloop_4loop_TCPServer *__pyx_vtabptr_6uvloop_4loop_TCPServer;
/* "uvloop/handles/tcp.pyx":97
*
* @cython.no_gc_clear
* cdef class TCPTransport(UVStream): # <<<<<<<<<<<<<<
*
* @staticmethod
*/
struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport {
struct __pyx_vtabstruct_6uvloop_4loop_UVStream __pyx_base;
PyObject *(*bind)(struct __pyx_obj_6uvloop_4loop_TCPTransport *, struct sockaddr *, struct __pyx_opt_args_6uvloop_4loop_12TCPTransport_bind *__pyx_optional_args);
PyObject *(*connect)(struct __pyx_obj_6uvloop_4loop_TCPTransport *, struct sockaddr *);
struct __pyx_obj_6uvloop_4loop_TCPTransport *(*new)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *);
};
static struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *__pyx_vtabptr_6uvloop_4loop_TCPTransport;
/* "uvloop/handles/pipe.pyx":38
*
* @cython.no_gc_clear
* cdef class UnixServer(UVStreamServer): # <<<<<<<<<<<<<<
*
* @staticmethod
*/
struct __pyx_vtabstruct_6uvloop_4loop_UnixServer {
struct __pyx_vtabstruct_6uvloop_4loop_UVStreamServer __pyx_base;
PyObject *(*bind)(struct __pyx_obj_6uvloop_4loop_UnixServer *, PyObject *);
struct __pyx_obj_6uvloop_4loop_UnixServer *(*new)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *);
};
static struct __pyx_vtabstruct_6uvloop_4loop_UnixServer *__pyx_vtabptr_6uvloop_4loop_UnixServer;
/* "uvloop/handles/pipe.pyx":77
*
* @cython.no_gc_clear
* cdef class UnixTransport(UVStream): # <<<<<<<<<<<<<<
*
* @staticmethod
*/
struct __pyx_vtabstruct_6uvloop_4loop_UnixTransport {
struct __pyx_vtabstruct_6uvloop_4loop_UVStream __pyx_base;
struct __pyx_obj_6uvloop_4loop_UnixTransport *(*new)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *);
PyObject *(*connect)(struct __pyx_obj_6uvloop_4loop_UnixTransport *, char *);
};
static struct __pyx_vtabstruct_6uvloop_4loop_UnixTransport *__pyx_vtabptr_6uvloop_4loop_UnixTransport;
/* "uvloop/handles/pipe.pyx":102
*
* @cython.no_gc_clear
* cdef class ReadUnixTransport(UVStream): # <<<<<<<<<<<<<<
*
* @staticmethod
*/
struct __pyx_vtabstruct_6uvloop_4loop_ReadUnixTransport {
struct __pyx_vtabstruct_6uvloop_4loop_UVStream __pyx_base;
struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *(*new)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *);
};
static struct __pyx_vtabstruct_6uvloop_4loop_ReadUnixTransport *__pyx_vtabptr_6uvloop_4loop_ReadUnixTransport;
/* "uvloop/handles/pipe.pyx":145
*
* @cython.no_gc_clear
* cdef class WriteUnixTransport(UVStream): # <<<<<<<<<<<<<<
*
* @staticmethod
*/
struct __pyx_vtabstruct_6uvloop_4loop_WriteUnixTransport {
struct __pyx_vtabstruct_6uvloop_4loop_UVStream __pyx_base;
struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *(*new)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, struct __pyx_obj_6uvloop_4loop_Server *, PyObject *);
};
static struct __pyx_vtabstruct_6uvloop_4loop_WriteUnixTransport *__pyx_vtabptr_6uvloop_4loop_WriteUnixTransport;
/* "uvloop/handles/process.pyx":2
* @cython.no_gc_clear
* cdef class UVProcess(UVHandle): # <<<<<<<<<<<<<<
* """Abstract class; wrapper over uv_process_t handle."""
*
*/
struct __pyx_vtabstruct_6uvloop_4loop_UVProcess {
struct __pyx_vtabstruct_6uvloop_4loop_UVHandle __pyx_base;
PyObject *(*_init)(struct __pyx_obj_6uvloop_4loop_UVProcess *, struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *);
PyObject *(*_after_fork)(struct __pyx_obj_6uvloop_4loop_UVProcess *);
char **(*__pyx___to_cstring_array)(struct __pyx_obj_6uvloop_4loop_UVProcess *, PyObject *);
PyObject *(*_init_args)(struct __pyx_obj_6uvloop_4loop_UVProcess *, PyObject *);
PyObject *(*_init_env)(struct __pyx_obj_6uvloop_4loop_UVProcess *, PyObject *);
PyObject *(*_init_files)(struct __pyx_obj_6uvloop_4loop_UVProcess *, PyObject *, PyObject *, PyObject *);
PyObject *(*_init_options)(struct __pyx_obj_6uvloop_4loop_UVProcess *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *);
PyObject *(*_close_after_spawn)(struct __pyx_obj_6uvloop_4loop_UVProcess *, int);
PyObject *(*_on_exit)(struct __pyx_obj_6uvloop_4loop_UVProcess *, int64_t, int);
PyObject *(*_kill)(struct __pyx_obj_6uvloop_4loop_UVProcess *, int);
};
static struct __pyx_vtabstruct_6uvloop_4loop_UVProcess *__pyx_vtabptr_6uvloop_4loop_UVProcess;
/* "uvloop/handles/process.pyx":314
*
* @cython.no_gc_clear
* cdef class UVProcessTransport(UVProcess): # <<<<<<<<<<<<<<
* def __cinit__(self):
* self._exit_waiters = []
*/
struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport {
struct __pyx_vtabstruct_6uvloop_4loop_UVProcess __pyx_base;
PyObject *(*_file_redirect_stdio)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *, int);
PyObject *(*_file_devnull)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *);
PyObject *(*_file_inpipe)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *);
PyObject *(*_file_outpipe)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *);
PyObject *(*_check_proc)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *);
PyObject *(*_pipe_connection_lost)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *, int, PyObject *);
PyObject *(*_pipe_data_received)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *, int, PyObject *);
PyObject *(*_call_connection_made)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *, PyObject *);
PyObject *(*_try_finish)(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *);
struct __pyx_obj_6uvloop_4loop_UVProcessTransport *(*new)(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *, PyObject *);
};
static struct __pyx_vtabstruct_6uvloop_4loop_UVProcessTransport *__pyx_vtabptr_6uvloop_4loop_UVProcessTransport;
/* "uvloop/request.pyx":1
* cdef class UVRequest: # <<<<<<<<<<<<<<
* """A base class for all libuv requests (uv_getaddrinfo_t, etc).
*
*/
struct __pyx_vtabstruct_6uvloop_4loop_UVRequest {
PyObject *(*on_done)(struct __pyx_obj_6uvloop_4loop_UVRequest *);
PyObject *(*cancel)(struct __pyx_obj_6uvloop_4loop_UVRequest *);
};
static struct __pyx_vtabstruct_6uvloop_4loop_UVRequest *__pyx_vtabptr_6uvloop_4loop_UVRequest;
/* "uvloop/handles/udp.pyx":54
*
* @cython.no_gc_clear
* cdef class UDPTransport(UVBaseTransport): # <<<<<<<<<<<<<<
* def __cinit__(self):
* self._family = uv.AF_UNSPEC
*/
struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport {
struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport __pyx_base;
PyObject *(*_init)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, struct __pyx_obj_6uvloop_4loop_Loop *, unsigned int);
PyObject *(*_set_remote_address)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, struct sockaddr *, size_t);
PyObject *(*_bind)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, struct sockaddr *, int);
PyObject *(*open)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, int, int);
PyObject *(*_set_broadcast)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, int);
PyObject *(*__pyx___receiving_started)(struct __pyx_obj_6uvloop_4loop_UDPTransport *);
PyObject *(*__pyx___receiving_stopped)(struct __pyx_obj_6uvloop_4loop_UDPTransport *);
PyObject *(*_send)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, PyObject *, PyObject *);
PyObject *(*_on_receive)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, PyObject *, PyObject *, PyObject *);
PyObject *(*_on_sent)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, PyObject *);
};
static struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *__pyx_vtabptr_6uvloop_4loop_UDPTransport;
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_12UDPTransport___receiving_started(struct __pyx_obj_6uvloop_4loop_UDPTransport *);
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_12UDPTransport___receiving_stopped(struct __pyx_obj_6uvloop_4loop_UDPTransport *);
/* "uvloop/server.pyx":1
* cdef class Server: # <<<<<<<<<<<<<<
* def __cinit__(self, Loop loop):
* self._loop = loop
*/
struct __pyx_vtabstruct_6uvloop_4loop_Server {
PyObject *(*_add_server)(struct __pyx_obj_6uvloop_4loop_Server *, struct __pyx_obj_6uvloop_4loop_UVStreamServer *);
PyObject *(*_wakeup)(struct __pyx_obj_6uvloop_4loop_Server *);
PyObject *(*_attach)(struct __pyx_obj_6uvloop_4loop_Server *);
PyObject *(*_detach)(struct __pyx_obj_6uvloop_4loop_Server *);
};
static struct __pyx_vtabstruct_6uvloop_4loop_Server *__pyx_vtabptr_6uvloop_4loop_Server;
/* "uvloop/handles/stream.pyx":5
* @cython.no_gc_clear
* @cython.freelist(DEFAULT_FREELIST_SIZE)
* cdef class _StreamWriteContext: # <<<<<<<<<<<<<<
* # used to hold additional write request information for uv_write
*
*/
struct __pyx_vtabstruct_6uvloop_4loop__StreamWriteContext {
PyObject *(*free_bufs)(struct __pyx_obj_6uvloop_4loop__StreamWriteContext *);
PyObject *(*close)(struct __pyx_obj_6uvloop_4loop__StreamWriteContext *);
PyObject *(*advance_uv_buf)(struct __pyx_obj_6uvloop_4loop__StreamWriteContext *, size_t);
struct __pyx_obj_6uvloop_4loop__StreamWriteContext *(*new)(struct __pyx_obj_6uvloop_4loop_UVStream *, PyObject *);
};
static struct __pyx_vtabstruct_6uvloop_4loop__StreamWriteContext *__pyx_vtabptr_6uvloop_4loop__StreamWriteContext;
/* "uvloop/handles/tcp.pyx":171
*
*
* cdef class _TCPConnectRequest(UVRequest): # <<<<<<<<<<<<<<
* cdef:
* TCPTransport transport
*/
struct __pyx_vtabstruct_6uvloop_4loop__TCPConnectRequest {
struct __pyx_vtabstruct_6uvloop_4loop_UVRequest __pyx_base;
PyObject *(*connect)(struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *, struct sockaddr *);
};
static struct __pyx_vtabstruct_6uvloop_4loop__TCPConnectRequest *__pyx_vtabptr_6uvloop_4loop__TCPConnectRequest;
/* "uvloop/handles/pipe.pyx":176
*
*
* cdef class _PipeConnectRequest(UVRequest): # <<<<<<<<<<<<<<
* cdef:
* UnixTransport transport
*/
struct __pyx_vtabstruct_6uvloop_4loop__PipeConnectRequest {
struct __pyx_vtabstruct_6uvloop_4loop_UVRequest __pyx_base;
PyObject *(*connect)(struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *, char *);
};
static struct __pyx_vtabstruct_6uvloop_4loop__PipeConnectRequest *__pyx_vtabptr_6uvloop_4loop__PipeConnectRequest;
/* "uvloop/dns.pyx":185
*
* @cython.freelist(DEFAULT_FREELIST_SIZE)
* cdef class AddrInfo: # <<<<<<<<<<<<<<
* cdef:
* system.addrinfo *data
*/
struct __pyx_vtabstruct_6uvloop_4loop_AddrInfo {
void (*set_data)(struct __pyx_obj_6uvloop_4loop_AddrInfo *, struct addrinfo *);
PyObject *(*unpack)(struct __pyx_obj_6uvloop_4loop_AddrInfo *);
int (*isinstance)(PyObject *);
};
static struct __pyx_vtabstruct_6uvloop_4loop_AddrInfo *__pyx_vtabptr_6uvloop_4loop_AddrInfo;
/* "uvloop/dns.pyx":229
*
*
* cdef class AddrInfoRequest(UVRequest): # <<<<<<<<<<<<<<
* cdef:
* system.addrinfo hints
*/
struct __pyx_vtabstruct_6uvloop_4loop_AddrInfoRequest {
struct __pyx_vtabstruct_6uvloop_4loop_UVRequest __pyx_base;
};
static struct __pyx_vtabstruct_6uvloop_4loop_AddrInfoRequest *__pyx_vtabptr_6uvloop_4loop_AddrInfoRequest;
/* "uvloop/dns.pyx":288
*
*
* cdef class NameInfoRequest(UVRequest): # <<<<<<<<<<<<<<
* cdef:
* object callback
*/
struct __pyx_vtabstruct_6uvloop_4loop_NameInfoRequest {
struct __pyx_vtabstruct_6uvloop_4loop_UVRequest __pyx_base;
PyObject *(*query)(struct __pyx_obj_6uvloop_4loop_NameInfoRequest *, struct sockaddr *, int);
};
static struct __pyx_vtabstruct_6uvloop_4loop_NameInfoRequest *__pyx_vtabptr_6uvloop_4loop_NameInfoRequest;
/* "uvloop/handles/udp.pyx":3
* @cython.no_gc_clear
* @cython.freelist(DEFAULT_FREELIST_SIZE)
* cdef class _UDPSendContext: # <<<<<<<<<<<<<<
* # used to hold additional write request information for uv_write
*
*/
struct __pyx_vtabstruct_6uvloop_4loop__UDPSendContext {
PyObject *(*close)(struct __pyx_obj_6uvloop_4loop__UDPSendContext *);
struct __pyx_obj_6uvloop_4loop__UDPSendContext *(*new)(struct __pyx_obj_6uvloop_4loop_UDPTransport *, PyObject *);
};
static struct __pyx_vtabstruct_6uvloop_4loop__UDPSendContext *__pyx_vtabptr_6uvloop_4loop__UDPSendContext;
/* "uvloop/future.pyx":24
*
*
* cdef class BaseFuture: # <<<<<<<<<<<<<<
* cdef:
* int _state
*/
struct __pyx_vtabstruct_6uvloop_4loop_BaseFuture {
PyObject *(*_schedule_callbacks)(struct __pyx_obj_6uvloop_4loop_BaseFuture *);
PyObject *(*_add_done_callback)(struct __pyx_obj_6uvloop_4loop_BaseFuture *, PyObject *);
PyObject *(*_done)(struct __pyx_obj_6uvloop_4loop_BaseFuture *);
PyObject *(*_cancel)(struct __pyx_obj_6uvloop_4loop_BaseFuture *);
PyObject *(*_result_impl)(struct __pyx_obj_6uvloop_4loop_BaseFuture *);
PyObject *(*_str_state)(struct __pyx_obj_6uvloop_4loop_BaseFuture *);
PyObject *(*set_result)(struct __pyx_obj_6uvloop_4loop_BaseFuture *, PyObject *, int __pyx_skip_dispatch);
PyObject *(*set_exception)(struct __pyx_obj_6uvloop_4loop_BaseFuture *, PyObject *, int __pyx_skip_dispatch);
};
static struct __pyx_vtabstruct_6uvloop_4loop_BaseFuture *__pyx_vtabptr_6uvloop_4loop_BaseFuture;
/* "uvloop/future.pyx":249
*
*
* cdef class BaseTask(BaseFuture): # <<<<<<<<<<<<<<
* cdef:
* readonly object _coro
*/
struct __pyx_vtabstruct_6uvloop_4loop_BaseTask {
struct __pyx_vtabstruct_6uvloop_4loop_BaseFuture __pyx_base;
PyObject *(*_raise_wrong_loop)(struct __pyx_obj_6uvloop_4loop_BaseTask *, PyObject *);
PyObject *(*_raise_yield)(struct __pyx_obj_6uvloop_4loop_BaseTask *, PyObject *);
PyObject *(*_raise_generator)(struct __pyx_obj_6uvloop_4loop_BaseTask *, PyObject *);
PyObject *(*_raise_else)(struct __pyx_obj_6uvloop_4loop_BaseTask *, PyObject *);
PyObject *(*_skip_oneloop)(struct __pyx_obj_6uvloop_4loop_BaseTask *);
PyObject *(*_fast_step)(struct __pyx_obj_6uvloop_4loop_BaseTask *, PyObject *);
PyObject *(*_fast_wakeup)(struct __pyx_obj_6uvloop_4loop_BaseTask *, PyObject *);
};
static struct __pyx_vtabstruct_6uvloop_4loop_BaseTask *__pyx_vtabptr_6uvloop_4loop_BaseTask;
/* --- Runtime support code (head) --- */
/* Refnanny.proto */
#ifndef CYTHON_REFNANNY
#define CYTHON_REFNANNY 0
#endif
#if CYTHON_REFNANNY
typedef struct {
void (*INCREF)(void*, PyObject*, int);
void (*DECREF)(void*, PyObject*, int);
void (*GOTREF)(void*, PyObject*, int);
void (*GIVEREF)(void*, PyObject*, int);
void* (*SetupContext)(const char*, int, const char*);
void (*FinishContext)(void**);
} __Pyx_RefNannyAPIStruct;
static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname);
#define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;
#ifdef WITH_THREAD
#define __Pyx_RefNannySetupContext(name, acquire_gil)\
if (acquire_gil) {\
PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
__pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
PyGILState_Release(__pyx_gilstate_save);\
} else {\
__pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
}
#else
#define __Pyx_RefNannySetupContext(name, acquire_gil)\
__pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
#endif
#define __Pyx_RefNannyFinishContext()\
__Pyx_RefNanny->FinishContext(&__pyx_refnanny)
#define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
#define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
#define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
#define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
#define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
#define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
#define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
#define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
#else
#define __Pyx_RefNannyDeclarations
#define __Pyx_RefNannySetupContext(name, acquire_gil)
#define __Pyx_RefNannyFinishContext()
#define __Pyx_INCREF(r) Py_INCREF(r)
#define __Pyx_DECREF(r) Py_DECREF(r)
#define __Pyx_GOTREF(r)
#define __Pyx_GIVEREF(r)
#define __Pyx_XINCREF(r) Py_XINCREF(r)
#define __Pyx_XDECREF(r) Py_XDECREF(r)
#define __Pyx_XGOTREF(r)
#define __Pyx_XGIVEREF(r)
#endif
#define __Pyx_XDECREF_SET(r, v) do {\
PyObject *tmp = (PyObject *) r;\
r = v; __Pyx_XDECREF(tmp);\
} while (0)
#define __Pyx_DECREF_SET(r, v) do {\
PyObject *tmp = (PyObject *) r;\
r = v; __Pyx_DECREF(tmp);\
} while (0)
#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)
/* PyObjectGetAttrStr.proto */
#if CYTHON_USE_TYPE_SLOTS
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
PyTypeObject* tp = Py_TYPE(obj);
if (likely(tp->tp_getattro))
return tp->tp_getattro(obj, attr_name);
#if PY_MAJOR_VERSION < 3
if (likely(tp->tp_getattr))
return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
#endif
return PyObject_GetAttr(obj, attr_name);
}
#else
#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
#endif
/* GetBuiltinName.proto */
static PyObject *__Pyx_GetBuiltinName(PyObject *name);
/* IncludeStringH.proto */
#include
/* decode_c_string.proto */
static CYTHON_INLINE PyObject* __Pyx_decode_c_string(
const char* cstring, Py_ssize_t start, Py_ssize_t stop,
const char* encoding, const char* errors,
PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors));
/* PyFunctionFastCall.proto */
#if CYTHON_FAST_PYCALL
#define __Pyx_PyFunction_FastCall(func, args, nargs)\
__Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
#if 1 || PY_VERSION_HEX < 0x030600B1
static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs);
#else
#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs)
#endif
#endif
/* PyCFunctionFastCall.proto */
#if CYTHON_FAST_PYCCALL
static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs);
#else
#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL)
#endif
/* PyObjectCall.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
#else
#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
#endif
/* PyObjectCallMethO.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
#endif
/* PyObjectCallOneArg.proto */
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);
/* PyObjectCallNoArg.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
#else
#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL)
#endif
/* RaiseArgTupleInvalid.proto */
static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);
/* KeywordStringCheck.proto */
static CYTHON_INLINE int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed);
/* PyThreadStateGet.proto */
#if CYTHON_FAST_THREAD_STATE
#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate;
#define __Pyx_PyThreadState_assign __pyx_tstate = PyThreadState_GET();
#else
#define __Pyx_PyThreadState_declare
#define __Pyx_PyThreadState_assign
#endif
/* PyErrFetchRestore.proto */
#if CYTHON_FAST_THREAD_STATE
#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb)
#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
#else
#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb)
#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb)
#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb)
#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb)
#endif
/* RaiseException.proto */
static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);
/* ExtTypeTest.proto */
static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type);
/* GetModuleGlobalName.proto */
static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name);
/* WriteUnraisableException.proto */
static void __Pyx_WriteUnraisable(const char *name, int clineno,
int lineno, const char *filename,
int full_traceback, int nogil);
/* RaiseTooManyValuesToUnpack.proto */
static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);
/* RaiseNeedMoreValuesToUnpack.proto */
static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);
/* IterFinish.proto */
static CYTHON_INLINE int __Pyx_IterFinish(void);
/* UnpackItemEndCheck.proto */
static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected);
/* SaveResetException.proto */
#if CYTHON_FAST_THREAD_STATE
#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb)
static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb)
static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
#else
#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb)
#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb)
#endif
/* PyErrExceptionMatches.proto */
#if CYTHON_FAST_THREAD_STATE
#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err)
static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
#else
#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err)
#endif
/* GetException.proto */
#if CYTHON_FAST_THREAD_STATE
#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb)
static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
#else
static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb);
#endif
/* DictGetItem.proto */
#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
PyObject *value;
value = PyDict_GetItemWithError(d, key);
if (unlikely(!value)) {
if (!PyErr_Occurred()) {
PyObject* args = PyTuple_Pack(1, key);
if (likely(args))
PyErr_SetObject(PyExc_KeyError, args);
Py_XDECREF(args);
}
return NULL;
}
Py_INCREF(value);
return value;
}
#else
#define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key)
#endif
/* SwapException.proto */
#if CYTHON_FAST_THREAD_STATE
#define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb)
static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
#else
static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb);
#endif
/* PyObjectCallMethod0.proto */
static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name);
/* RaiseNoneIterError.proto */
static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);
/* UnpackTupleError.proto */
static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index);
/* UnpackTuple2.proto */
static CYTHON_INLINE int __Pyx_unpack_tuple2(PyObject* tuple, PyObject** value1, PyObject** value2,
int is_tuple, int has_known_size, int decref_tuple);
/* dict_iter.proto */
static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name,
Py_ssize_t* p_orig_length, int* p_is_dict);
static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos,
PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict);
/* py_dict_clear.proto */
#define __Pyx_PyDict_Clear(d) (PyDict_Clear(d), 0)
/* ListAppend.proto */
#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
PyListObject* L = (PyListObject*) list;
Py_ssize_t len = Py_SIZE(list);
if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) {
Py_INCREF(x);
PyList_SET_ITEM(list, len, x);
Py_SIZE(list) = len+1;
return 0;
}
return PyList_Append(list, x);
}
#else
#define __Pyx_PyList_Append(L,x) PyList_Append(L,x)
#endif
/* PyObjectCallMethod1.proto */
static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg);
/* append.proto */
static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x);
/* None.proto */
static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname);
/* FetchCommonType.proto */
static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);
/* CythonFunction.proto */
#define __Pyx_CyFunction_USED 1
#include
#define __Pyx_CYFUNCTION_STATICMETHOD 0x01
#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02
#define __Pyx_CYFUNCTION_CCLASS 0x04
#define __Pyx_CyFunction_GetClosure(f)\
(((__pyx_CyFunctionObject *) (f))->func_closure)
#define __Pyx_CyFunction_GetClassObj(f)\
(((__pyx_CyFunctionObject *) (f))->func_classobj)
#define __Pyx_CyFunction_Defaults(type, f)\
((type *)(((__pyx_CyFunctionObject *) (f))->defaults))
#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\
((__pyx_CyFunctionObject *) (f))->defaults_getter = (g)
typedef struct {
PyCFunctionObject func;
#if PY_VERSION_HEX < 0x030500A0
PyObject *func_weakreflist;
#endif
PyObject *func_dict;
PyObject *func_name;
PyObject *func_qualname;
PyObject *func_doc;
PyObject *func_globals;
PyObject *func_code;
PyObject *func_closure;
PyObject *func_classobj;
void *defaults;
int defaults_pyobjects;
int flags;
PyObject *defaults_tuple;
PyObject *defaults_kwdict;
PyObject *(*defaults_getter)(PyObject *);
PyObject *func_annotations;
} __pyx_CyFunctionObject;
static PyTypeObject *__pyx_CyFunctionType = 0;
#define __Pyx_CyFunction_NewEx(ml, flags, qualname, self, module, globals, code)\
__Pyx_CyFunction_New(__pyx_CyFunctionType, ml, flags, qualname, self, module, globals, code)
static PyObject *__Pyx_CyFunction_New(PyTypeObject *, PyMethodDef *ml,
int flags, PyObject* qualname,
PyObject *self,
PyObject *module, PyObject *globals,
PyObject* code);
static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m,
size_t size,
int pyobjects);
static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m,
PyObject *tuple);
static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m,
PyObject *dict);
static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
PyObject *dict);
static int __pyx_CyFunction_init(void);
/* SliceObject.proto */
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(
PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop,
PyObject** py_start, PyObject** py_stop, PyObject** py_slice,
int has_cstart, int has_cstop, int wraparound);
/* RaiseDoubleKeywords.proto */
static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);
/* ParseKeywords.proto */
static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
const char* function_name);
/* None.proto */
static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname);
/* CallableCheck.proto */
#if CYTHON_USE_TYPE_SLOTS && PY_MAJOR_VERSION >= 3
#define __Pyx_PyCallable_Check(obj) ((obj)->ob_type->tp_call != NULL)
#else
#define __Pyx_PyCallable_Check(obj) PyCallable_Check(obj)
#endif
/* PyObjectSetAttrStr.proto */
#if CYTHON_USE_TYPE_SLOTS
#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o,n,NULL)
static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) {
PyTypeObject* tp = Py_TYPE(obj);
if (likely(tp->tp_setattro))
return tp->tp_setattro(obj, attr_name, value);
#if PY_MAJOR_VERSION < 3
if (likely(tp->tp_setattr))
return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value);
#endif
return PyObject_SetAttr(obj, attr_name, value);
}
#else
#define __Pyx_PyObject_DelAttrStr(o,n) PyObject_DelAttr(o,n)
#define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v)
#endif
/* GetItemInt.proto */
#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
(__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
__Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\
(is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\
__Pyx_GetItemInt_Generic(o, to_py_func(i))))
#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
(__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
__Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
(PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL))
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
int wraparound, int boundscheck);
#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
(__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
__Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
(PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL))
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
int wraparound, int boundscheck);
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j);
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,
int is_list, int wraparound, int boundscheck);
/* CoroutineBase.proto */
typedef PyObject *(*__pyx_coroutine_body_t)(PyObject *, PyObject *);
typedef struct {
PyObject_HEAD
__pyx_coroutine_body_t body;
PyObject *closure;
PyObject *exc_type;
PyObject *exc_value;
PyObject *exc_traceback;
PyObject *gi_weakreflist;
PyObject *classobj;
PyObject *yieldfrom;
PyObject *gi_name;
PyObject *gi_qualname;
PyObject *gi_modulename;
int resume_label;
char is_running;
} __pyx_CoroutineObject;
static __pyx_CoroutineObject *__Pyx__Coroutine_New(
PyTypeObject *type, __pyx_coroutine_body_t body, PyObject *closure,
PyObject *name, PyObject *qualname, PyObject *module_name);
static int __Pyx_Coroutine_clear(PyObject *self);
#if 1 || PY_VERSION_HEX < 0x030300B0
static int __Pyx_PyGen_FetchStopIterationValue(PyObject **pvalue);
#else
#define __Pyx_PyGen_FetchStopIterationValue(pvalue) PyGen_FetchStopIterationValue(pvalue)
#endif
/* PatchModuleWithCoroutine.proto */
static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code);
/* PatchGeneratorABC.proto */
static int __Pyx_patch_abc(void);
/* Coroutine.proto */
#define __Pyx_Coroutine_USED
static PyTypeObject *__pyx_CoroutineType = 0;
static PyTypeObject *__pyx_CoroutineAwaitType = 0;
#define __Pyx_Coroutine_CheckExact(obj) (Py_TYPE(obj) == __pyx_CoroutineType)
#define __Pyx_Coroutine_New(body, closure, name, qualname, module_name)\
__Pyx__Coroutine_New(__pyx_CoroutineType, body, closure, name, qualname, module_name)
static int __pyx_Coroutine_init(void);
static PyObject *__Pyx__Coroutine_await(PyObject *coroutine);
/* GetAwaitIter.proto */
static CYTHON_INLINE PyObject *__Pyx_Coroutine_GetAwaitableIter(PyObject *o);
static PyObject *__Pyx__Coroutine_GetAwaitableIter(PyObject *o);
/* CoroutineYieldFrom.proto */
#define __Pyx_Coroutine_Yield_From(gen, source) __Pyx__Coroutine_Yield_From(gen, source, 0)
static CYTHON_INLINE PyObject* __Pyx__Coroutine_Yield_From(__pyx_CoroutineObject *gen, PyObject *source, int warn);
/* ReturnWithStopIteration.proto */
#define __Pyx_ReturnWithStopIteration(value)\
if (value == Py_None) PyErr_SetNone(PyExc_StopIteration); else __Pyx__ReturnWithStopIteration(value)
static void __Pyx__ReturnWithStopIteration(PyObject* value);
/* BytesEquals.proto */
static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals);
/* UnicodeEquals.proto */
static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals);
/* ListCompAppend.proto */
#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
PyListObject* L = (PyListObject*) list;
Py_ssize_t len = Py_SIZE(list);
if (likely(L->allocated > len)) {
Py_INCREF(x);
PyList_SET_ITEM(list, len, x);
Py_SIZE(list) = len+1;
return 0;
}
return PyList_Append(list, x);
}
#else
#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x)
#endif
/* ArgTypeTest.proto */
static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed,
const char *name, int exact);
/* SetItemInt.proto */
#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
(__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
__Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\
(is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\
__Pyx_SetItemInt_Generic(o, to_py_func(i), v)))
static CYTHON_INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v);
static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v,
int is_list, int wraparound, int boundscheck);
/* MergeKeywords.proto */
static int __Pyx_MergeKeywords(PyObject *kwdict, PyObject *source_mapping);
/* ForceInitThreads.proto */
#ifndef __PYX_FORCE_INIT_THREADS
#define __PYX_FORCE_INIT_THREADS 0
#endif
/* GetAttr.proto */
static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *);
/* None.proto */
static CYTHON_INLINE long __Pyx_div_long(long, long);
/* PyDictContains.proto */
static CYTHON_INLINE int __Pyx_PyDict_ContainsTF(PyObject* item, PyObject* dict, int eq) {
int result = PyDict_Contains(dict, item);
return unlikely(result < 0) ? result : (result == (eq == Py_EQ));
}
/* PyIntBinop.proto */
#if !CYTHON_COMPILING_IN_PYPY
static PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, long intval, int inplace);
#else
#define __Pyx_PyInt_EqObjC(op1, op2, intval, inplace)\
PyObject_RichCompare(op1, op2, Py_EQ)
#endif
/* PyIntBinop.proto */
#if !CYTHON_COMPILING_IN_PYPY
static PyObject* __Pyx_PyInt_AndObjC(PyObject *op1, PyObject *op2, long intval, int inplace);
#else
#define __Pyx_PyInt_AndObjC(op1, op2, intval, inplace)\
(inplace ? PyNumber_InPlaceAnd(op1, op2) : PyNumber_And(op1, op2))
#endif
/* GetAttr3.proto */
static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *);
/* PyObjectLookupSpecial.proto */
#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x02070000
static CYTHON_INLINE PyObject* __Pyx_PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name) {
PyObject *res;
PyTypeObject *tp = Py_TYPE(obj);
#if PY_MAJOR_VERSION < 3
if (unlikely(PyInstance_Check(obj)))
return __Pyx_PyObject_GetAttrStr(obj, attr_name);
#endif
res = _PyType_Lookup(tp, attr_name);
if (likely(res)) {
descrgetfunc f = Py_TYPE(res)->tp_descr_get;
if (!f) {
Py_INCREF(res);
} else {
res = f(res, obj, (PyObject *)tp);
}
} else {
PyErr_SetObject(PyExc_AttributeError, attr_name);
}
return res;
}
#else
#define __Pyx_PyObject_LookupSpecial(o,n) __Pyx_PyObject_GetAttrStr(o,n)
#endif
/* decode_c_bytes.proto */
static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes(
const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop,
const char* encoding, const char* errors,
PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors));
/* decode_bytes.proto */
static CYTHON_INLINE PyObject* __Pyx_decode_bytes(
PyObject* string, Py_ssize_t start, Py_ssize_t stop,
const char* encoding, const char* errors,
PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) {
return __Pyx_decode_c_bytes(
PyBytes_AS_STRING(string), PyBytes_GET_SIZE(string),
start, stop, encoding, errors, decode_func);
}
/* SliceObject.proto */
#define __Pyx_PyObject_DelSlice(obj, cstart, cstop, py_start, py_stop, py_slice, has_cstart, has_cstop, wraparound)\
__Pyx_PyObject_SetSlice(obj, (PyObject*)NULL, cstart, cstop, py_start, py_stop, py_slice, has_cstart, has_cstop, wraparound)
static CYTHON_INLINE int __Pyx_PyObject_SetSlice(
PyObject* obj, PyObject* value, Py_ssize_t cstart, Py_ssize_t cstop,
PyObject** py_start, PyObject** py_stop, PyObject** py_slice,
int has_cstart, int has_cstop, int wraparound);
/* SetVTable.proto */
static int __Pyx_SetVtable(PyObject *dict, void *vtable);
/* Import.proto */
static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);
/* PatchInspect.proto */
static PyObject* __Pyx_patch_inspect(PyObject* module);
/* PatchAsyncIO.proto */
static PyObject* __Pyx_patch_asyncio(PyObject* module);
/* ImportFrom.proto */
static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name);
/* CalculateMetaclass.proto */
static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases);
/* Py3ClassCreate.proto */
static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname,
PyObject *mkw, PyObject *modname, PyObject *doc);
static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict,
PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass);
/* CodeObjectCache.proto */
typedef struct {
PyCodeObject* code_object;
int code_line;
} __Pyx_CodeObjectCacheEntry;
struct __Pyx_CodeObjectCache {
int count;
int max_count;
__Pyx_CodeObjectCacheEntry* entries;
};
static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
static PyCodeObject *__pyx_find_code_object(int code_line);
static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);
/* AddTraceback.proto */
static void __Pyx_AddTraceback(const char *funcname, int c_line,
int py_line, const char *filename);
/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value);
/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint64_t(uint64_t value);
/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);
/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint32_t(uint32_t value);
/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_short(unsigned short value);
/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_volatile__int(volatile int value);
/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int64_t(int64_t value);
/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_long(unsigned long value);
/* CIntFromPy.proto */
static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);
/* CIntFromPy.proto */
static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);
/* CIntFromPy.proto */
static CYTHON_INLINE uint64_t __Pyx_PyInt_As_uint64_t(PyObject *);
/* CIntFromPy.proto */
static CYTHON_INLINE unsigned long __Pyx_PyInt_As_unsigned_long(PyObject *);
/* CIntFromPy.proto */
static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *);
/* CIntFromPy.proto */
static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *);
/* Generator.proto */
#define __Pyx_Generator_USED
static PyTypeObject *__pyx_GeneratorType = 0;
#define __Pyx_Generator_CheckExact(obj) (Py_TYPE(obj) == __pyx_GeneratorType)
#define __Pyx_Generator_New(body, closure, name, qualname, module_name)\
__Pyx__Coroutine_New(__pyx_GeneratorType, body, closure, name, qualname, module_name)
static PyObject *__Pyx_Generator_Next(PyObject *self);
static int __pyx_Generator_init(void);
/* CheckBinaryVersion.proto */
static int __Pyx_check_binary_version(void);
/* PyIdentifierFromString.proto */
#if !defined(__Pyx_PyIdentifier_FromString)
#if PY_MAJOR_VERSION < 3
#define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s)
#else
#define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s)
#endif
#endif
/* ModuleImport.proto */
static PyObject *__Pyx_ImportModule(const char *name);
/* TypeImport.proto */
static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, size_t size, int strict);
/* InitStrings.proto */
static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);
static PyObject *__pyx_f_6uvloop_4loop_4Loop__init_debug_fields(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__setup_signals(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__shutdown_signals(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__read_from_self(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__process_self_data(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_data); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__handle_signal(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sig); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__on_wake(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__on_idle(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__stop(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_exc); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop___run(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, uv_run_mode __pyx_v_mode); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__run(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, uv_run_mode __pyx_v_mode); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__close(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
static uint64_t __pyx_f_6uvloop_4loop_4Loop__time(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__queue_write(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_stream); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__exec_queued_writes(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__call_soon(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__call_soon_handle(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__call_later(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, uint64_t __pyx_v_delay, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto*/
static void __pyx_f_6uvloop_4loop_4Loop__handle_exception(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_ex); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__check_signal(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sig); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__check_closed(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__check_thread(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__new_future(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__track_transport(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_transport); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__ensure_fd_no_transport(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fd); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__add_reader(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fd, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__remove_reader(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fd); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__add_writer(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fd, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__remove_writer(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fd); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__getaddrinfo(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_host, PyObject *__pyx_v_port, int __pyx_v_family, int __pyx_v_type, int __pyx_v_proto, int __pyx_v_flags, int __pyx_v_unpack); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__getnameinfo(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, struct sockaddr *__pyx_v_addr, int __pyx_v_flags); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_recv(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fut, PyObject *__pyx_v_sock, PyObject *__pyx_v_n); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_sendall(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fut, PyObject *__pyx_v_sock, PyObject *__pyx_v_data); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_accept(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fut, PyObject *__pyx_v_sock); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_connect(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fut, PyObject *__pyx_v_sock, PyObject *__pyx_v_address); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_connect_cb(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fut, PyObject *__pyx_v_sock, PyObject *__pyx_v_address); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_set_reuseport(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, int __pyx_v_fd); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__set_coroutine_wrapper(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, int __pyx_v_enabled); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__create_server(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, struct sockaddr *__pyx_v_addr, PyObject *__pyx_v_protocol_factory, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, PyObject *__pyx_v_ssl, int __pyx_v_reuse_port, PyObject *__pyx_v_backlog); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6Handle__set_loop(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6Handle__run(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_6Handle__cancel(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_11TimerHandle__cancel(struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_11TimerHandle__run(struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVHandle__free(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_8UVHandle__warn_unclosed(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVHandle__abort_init(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVHandle__finish_init(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVHandle__start_init(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop); /* proto*/
static CYTHON_INLINE int __pyx_f_6uvloop_4loop_8UVHandle__is_alive(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVHandle__ensure_alive(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_8UVHandle__fatal_error(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self, PyObject *__pyx_v_exc, PyObject *__pyx_v_throw, struct __pyx_opt_args_6uvloop_4loop_8UVHandle__fatal_error *__pyx_optional_args); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_8UVHandle__error(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self, PyObject *__pyx_v_exc, PyObject *__pyx_v_throw); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_8UVHandle__close(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVSocketHandle__fileno(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_14UVSocketHandle__new_socket(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVSocketHandle__get_socket(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVSocketHandle__attach_fileobj(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__pyx_v_self, PyObject *__pyx_v_file); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_14UVSocketHandle__close(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_14UVSocketHandle__open(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__pyx_v_self, CYTHON_UNUSED int __pyx_v_sockfd); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_7UVAsync__init(struct __pyx_obj_6uvloop_4loop_UVAsync *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, __pyx_t_6uvloop_4loop_method_t __pyx_v_callback, PyObject *__pyx_v_ctx); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_7UVAsync_send(struct __pyx_obj_6uvloop_4loop_UVAsync *__pyx_v_self); /* proto*/
static struct __pyx_obj_6uvloop_4loop_UVAsync *__pyx_f_6uvloop_4loop_7UVAsync_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, __pyx_t_6uvloop_4loop_method_t __pyx_v_callback, PyObject *__pyx_v_ctx); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_6UVIdle__init(struct __pyx_obj_6uvloop_4loop_UVIdle *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_h); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6UVIdle_stop(struct __pyx_obj_6uvloop_4loop_UVIdle *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6UVIdle_start(struct __pyx_obj_6uvloop_4loop_UVIdle *__pyx_v_self); /* proto*/
static struct __pyx_obj_6uvloop_4loop_UVIdle *__pyx_f_6uvloop_4loop_6UVIdle_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_h); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_7UVCheck__init(struct __pyx_obj_6uvloop_4loop_UVCheck *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_h); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_7UVCheck_stop(struct __pyx_obj_6uvloop_4loop_UVCheck *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_7UVCheck_start(struct __pyx_obj_6uvloop_4loop_UVCheck *__pyx_v_self); /* proto*/
static struct __pyx_obj_6uvloop_4loop_UVCheck *__pyx_f_6uvloop_4loop_7UVCheck_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_h); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_7UVTimer__init(struct __pyx_obj_6uvloop_4loop_UVTimer *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, __pyx_t_6uvloop_4loop_method_t __pyx_v_callback, PyObject *__pyx_v_ctx, uint64_t __pyx_v_timeout); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_7UVTimer_stop(struct __pyx_obj_6uvloop_4loop_UVTimer *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_7UVTimer_start(struct __pyx_obj_6uvloop_4loop_UVTimer *__pyx_v_self); /* proto*/
static struct __pyx_obj_6uvloop_4loop_UVTimer *__pyx_f_6uvloop_4loop_7UVTimer_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, __pyx_t_6uvloop_4loop_method_t __pyx_v_callback, PyObject *__pyx_v_ctx, uint64_t __pyx_v_timeout); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_6UVPoll__init(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, int __pyx_v_fd); /* proto*/
static struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_f_6uvloop_4loop_6UVPoll_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, int __pyx_v_fd); /* proto*/
static int __pyx_f_6uvloop_4loop_6UVPoll_is_active(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6UVPoll__poll_start(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self, int __pyx_v_flags); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6UVPoll__poll_stop(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_6UVPoll_start_reading(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_callback); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_6UVPoll_start_writing(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_callback); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_6UVPoll_stop_reading(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_6UVPoll_stop_writing(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_6UVPoll_stop(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_6UVPoll__close(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_6UVPoll__fatal_error(struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_exc, CYTHON_UNUSED PyObject *__pyx_v_throw, struct __pyx_opt_args_6uvloop_4loop_6UVPoll__fatal_error *__pyx_optional_args); /* proto*/
static size_t __pyx_f_6uvloop_4loop_15UVBaseTransport__get_write_buffer_size(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__schedule_call_connection_made(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__schedule_call_connection_lost(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_exc); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__fatal_error(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_exc, PyObject *__pyx_v_throw, struct __pyx_opt_args_6uvloop_4loop_15UVBaseTransport__fatal_error *__pyx_optional_args); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__set_write_buffer_limits(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, struct __pyx_opt_args_6uvloop_4loop_15UVBaseTransport__set_write_buffer_limits *__pyx_optional_args); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__maybe_pause_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__maybe_resume_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__wakeup_waiter(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__call_connection_made(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__call_connection_lost(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_exc); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__set_server(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__set_waiter(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_waiter); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__set_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_protocol); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__init_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__add_extra_info(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_obj); /* proto*/
static int __pyx_f_6uvloop_4loop_15UVBaseTransport__is_reading(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__start_reading(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_15UVBaseTransport__stop_reading(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_19_StreamWriteContext_free_bufs(struct __pyx_obj_6uvloop_4loop__StreamWriteContext *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_19_StreamWriteContext_close(struct __pyx_obj_6uvloop_4loop__StreamWriteContext *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_19_StreamWriteContext_advance_uv_buf(struct __pyx_obj_6uvloop_4loop__StreamWriteContext *__pyx_v_self, size_t __pyx_v_sent); /* proto*/
static struct __pyx_obj_6uvloop_4loop__StreamWriteContext *__pyx_f_6uvloop_4loop_19_StreamWriteContext_new(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_stream, PyObject *__pyx_v_buffers); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__shutdown(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__accept(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_server); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__close_on_read_error(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
static int __pyx_f_6uvloop_4loop_8UVStream__is_reading(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_8UVStream__start_reading(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream___reading_started(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream___reading_stopped(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_8UVStream__stop_reading(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__try_write(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self, PyObject *__pyx_v_data); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__write(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self, PyObject *__pyx_v_data); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__exec_write(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
static size_t __pyx_f_6uvloop_4loop_8UVStream__get_write_buffer_size(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_8UVStream__close(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__on_accept(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__on_read(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self, PyObject *__pyx_v_buf); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__on_eof(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__on_write(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__init(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, PyObject *__pyx_v_waiter); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_8UVStream__on_connect(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self, PyObject *__pyx_v_exc); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVStreamServer__init(struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol_factory, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, PyObject *__pyx_v_ssl); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVStreamServer_listen(struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self, PyObject *__pyx_v_backlog); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVStreamServer__on_listen(struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_14UVStreamServer__fatal_error(struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self, PyObject *__pyx_v_exc, PyObject *__pyx_v_throw, struct __pyx_opt_args_6uvloop_4loop_14UVStreamServer__fatal_error *__pyx_optional_args); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_14UVStreamServer__mark_as_open(struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self); /* proto*/
static struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_f_6uvloop_4loop_14UVStreamServer__make_new_transport(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_protocol, CYTHON_UNUSED PyObject *__pyx_v_waiter); /* proto*/
static struct __pyx_obj_6uvloop_4loop_TCPServer *__pyx_f_6uvloop_4loop_9TCPServer_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol_factory, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, PyObject *__pyx_v_ssl, unsigned int __pyx_v_flags); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_9TCPServer__new_socket(struct __pyx_obj_6uvloop_4loop_TCPServer *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_9TCPServer__open(struct __pyx_obj_6uvloop_4loop_TCPServer *__pyx_v_self, int __pyx_v_sockfd); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_9TCPServer_bind(struct __pyx_obj_6uvloop_4loop_TCPServer *__pyx_v_self, struct sockaddr *__pyx_v_addr, struct __pyx_opt_args_6uvloop_4loop_9TCPServer_bind *__pyx_optional_args); /* proto*/
static struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_f_6uvloop_4loop_9TCPServer__make_new_transport(struct __pyx_obj_6uvloop_4loop_TCPServer *__pyx_v_self, PyObject *__pyx_v_protocol, PyObject *__pyx_v_waiter); /* proto*/
static struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_f_6uvloop_4loop_12TCPTransport_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, PyObject *__pyx_v_waiter); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_12TCPTransport__call_connection_made(struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_12TCPTransport__new_socket(struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_12TCPTransport_bind(struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_self, struct sockaddr *__pyx_v_addr, struct __pyx_opt_args_6uvloop_4loop_12TCPTransport_bind *__pyx_optional_args); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_12TCPTransport__open(struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_self, int __pyx_v_sockfd); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_12TCPTransport_connect(struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_self, struct sockaddr *__pyx_v_addr); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_18_TCPConnectRequest_connect(struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *__pyx_v_self, struct sockaddr *__pyx_v_addr); /* proto*/
static struct __pyx_obj_6uvloop_4loop_UnixServer *__pyx_f_6uvloop_4loop_10UnixServer_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol_factory, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, PyObject *__pyx_v_ssl); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_10UnixServer__new_socket(struct __pyx_obj_6uvloop_4loop_UnixServer *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_10UnixServer__open(struct __pyx_obj_6uvloop_4loop_UnixServer *__pyx_v_self, int __pyx_v_sockfd); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_10UnixServer_bind(struct __pyx_obj_6uvloop_4loop_UnixServer *__pyx_v_self, PyObject *__pyx_v_path); /* proto*/
static struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_f_6uvloop_4loop_10UnixServer__make_new_transport(struct __pyx_obj_6uvloop_4loop_UnixServer *__pyx_v_self, PyObject *__pyx_v_protocol, PyObject *__pyx_v_waiter); /* proto*/
static struct __pyx_obj_6uvloop_4loop_UnixTransport *__pyx_f_6uvloop_4loop_13UnixTransport_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, PyObject *__pyx_v_waiter); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_13UnixTransport__new_socket(struct __pyx_obj_6uvloop_4loop_UnixTransport *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_13UnixTransport__open(struct __pyx_obj_6uvloop_4loop_UnixTransport *__pyx_v_self, int __pyx_v_sockfd); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_13UnixTransport_connect(struct __pyx_obj_6uvloop_4loop_UnixTransport *__pyx_v_self, char *__pyx_v_addr); /* proto*/
static struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_f_6uvloop_4loop_17ReadUnixTransport_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, PyObject *__pyx_v_waiter); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_17ReadUnixTransport__new_socket(struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_17ReadUnixTransport__open(struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self, int __pyx_v_sockfd); /* proto*/
static struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *__pyx_f_6uvloop_4loop_18WriteUnixTransport_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, PyObject *__pyx_v_waiter); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_18WriteUnixTransport__new_socket(struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_18WriteUnixTransport__open(struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *__pyx_v_self, int __pyx_v_sockfd); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_19_PipeConnectRequest_connect(struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *__pyx_v_self, char *__pyx_v_addr); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__init(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_args, PyObject *__pyx_v_env, PyObject *__pyx_v_cwd, PyObject *__pyx_v_start_new_session, PyObject *__pyx_v__stdin, PyObject *__pyx_v__stdout, PyObject *__pyx_v__stderr, PyObject *__pyx_v_pass_fds, PyObject *__pyx_v_debug_flags, PyObject *__pyx_v_preexec_fn, PyObject *__pyx_v_restore_signals); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__after_fork(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__close_after_spawn(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, int __pyx_v_fd); /* proto*/
static char **__pyx_f_6uvloop_4loop_9UVProcess___to_cstring_array(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, PyObject *__pyx_v_arr); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__init_options(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, PyObject *__pyx_v_args, PyObject *__pyx_v_env, PyObject *__pyx_v_cwd, PyObject *__pyx_v_start_new_session, PyObject *__pyx_v__stdin, PyObject *__pyx_v__stdout, PyObject *__pyx_v__stderr); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__init_args(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, PyObject *__pyx_v_args); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__init_env(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, PyObject *__pyx_v_env); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__init_files(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v__stdin, CYTHON_UNUSED PyObject *__pyx_v__stdout, CYTHON_UNUSED PyObject *__pyx_v__stderr); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__kill(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, int __pyx_v_signum); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_9UVProcess__on_exit(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self, int64_t __pyx_v_exit_status, int __pyx_v_term_signal); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__on_exit(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, int64_t __pyx_v_exit_status, int __pyx_v_term_signal); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__check_proc(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__pipe_connection_lost(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, int __pyx_v_fd, PyObject *__pyx_v_exc); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__pipe_data_received(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, int __pyx_v_fd, PyObject *__pyx_v_data); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__file_redirect_stdio(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, int __pyx_v_fd); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__file_devnull(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__file_outpipe(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__file_inpipe(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__init_files(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, PyObject *__pyx_v__stdin, PyObject *__pyx_v__stdout, PyObject *__pyx_v__stderr); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__call_connection_made(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, PyObject *__pyx_v_waiter); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_18UVProcessTransport__try_finish(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto*/
static struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_f_6uvloop_4loop_18UVProcessTransport_new(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_protocol, PyObject *__pyx_v_args, PyObject *__pyx_v_env, PyObject *__pyx_v_cwd, PyObject *__pyx_v_start_new_session, PyObject *__pyx_v__stdin, PyObject *__pyx_v__stdout, PyObject *__pyx_v__stderr, PyObject *__pyx_v_pass_fds, PyObject *__pyx_v_waiter, PyObject *__pyx_v_debug_flags, PyObject *__pyx_v_preexec_fn, PyObject *__pyx_v_restore_signals); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_9UVRequest_on_done(struct __pyx_obj_6uvloop_4loop_UVRequest *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_9UVRequest_cancel(struct __pyx_obj_6uvloop_4loop_UVRequest *__pyx_v_self); /* proto*/
static void __pyx_f_6uvloop_4loop_8AddrInfo_set_data(struct __pyx_obj_6uvloop_4loop_AddrInfo *__pyx_v_self, struct addrinfo *__pyx_v_data); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_8AddrInfo_unpack(struct __pyx_obj_6uvloop_4loop_AddrInfo *__pyx_v_self); /* proto*/
static int __pyx_f_6uvloop_4loop_8AddrInfo_isinstance(PyObject *__pyx_v_other); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_15NameInfoRequest_query(struct __pyx_obj_6uvloop_4loop_NameInfoRequest *__pyx_v_self, struct sockaddr *__pyx_v_addr, int __pyx_v_flags); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_15_UDPSendContext_close(struct __pyx_obj_6uvloop_4loop__UDPSendContext *__pyx_v_self); /* proto*/
static struct __pyx_obj_6uvloop_4loop__UDPSendContext *__pyx_f_6uvloop_4loop_15_UDPSendContext_new(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_udp, PyObject *__pyx_v_data); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__init(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, unsigned int __pyx_v_family); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__set_remote_address(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, struct sockaddr *__pyx_v_addr, size_t __pyx_v_addr_len); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport_open(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, int __pyx_v_family, int __pyx_v_sockfd); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__bind(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, struct sockaddr *__pyx_v_addr, int __pyx_v_reuse_addr); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__set_broadcast(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, int __pyx_v_on); /* proto*/
static size_t __pyx_f_6uvloop_4loop_12UDPTransport__get_write_buffer_size(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self); /* proto*/
static int __pyx_f_6uvloop_4loop_12UDPTransport__is_reading(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__start_reading(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__stop_reading(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_12UDPTransport___receiving_started(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self); /* proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_12UDPTransport___receiving_stopped(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__new_socket(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__send(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, PyObject *__pyx_v_data, PyObject *__pyx_v_addr); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__on_receive(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, PyObject *__pyx_v_data, PyObject *__pyx_v_exc, PyObject *__pyx_v_addr); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_12UDPTransport__on_sent(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, PyObject *__pyx_v_exc); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_6Server__add_server(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_srv); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_6Server__wakeup(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_6Server__attach(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_6Server__detach(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_10BaseFuture__schedule_callbacks(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_10BaseFuture__add_done_callback(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self, PyObject *__pyx_v_fn); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_10BaseFuture__done(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_10BaseFuture__cancel(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_10BaseFuture__result_impl(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_10BaseFuture__str_state(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_10BaseFuture_set_result(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self, PyObject *__pyx_v_result, int __pyx_skip_dispatch); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_10BaseFuture_set_exception(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self, PyObject *__pyx_v_exception, int __pyx_skip_dispatch); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_8BaseTask__raise_wrong_loop(struct __pyx_obj_6uvloop_4loop_BaseTask *__pyx_v_self, PyObject *__pyx_v_fut); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_8BaseTask__raise_yield(struct __pyx_obj_6uvloop_4loop_BaseTask *__pyx_v_self, PyObject *__pyx_v_fut); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_8BaseTask__raise_generator(struct __pyx_obj_6uvloop_4loop_BaseTask *__pyx_v_self, PyObject *__pyx_v_val); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_8BaseTask__raise_else(struct __pyx_obj_6uvloop_4loop_BaseTask *__pyx_v_self, PyObject *__pyx_v_val); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_8BaseTask__skip_oneloop(struct __pyx_obj_6uvloop_4loop_BaseTask *__pyx_v_self); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_8BaseTask__fast_step(struct __pyx_obj_6uvloop_4loop_BaseTask *__pyx_v_self, PyObject *__pyx_v_exc); /* proto*/
static PyObject *__pyx_f_6uvloop_4loop_8BaseTask__fast_wakeup(struct __pyx_obj_6uvloop_4loop_BaseTask *__pyx_v_self, PyObject *__pyx_v_future); /* proto*/
/* Module declarations from 'uvloop.includes' */
/* Module declarations from 'libc.stdint' */
/* Module declarations from 'posix.types' */
/* Module declarations from 'uvloop.includes.system' */
/* Module declarations from 'uvloop.includes.uv' */
/* Module declarations from 'cython' */
/* Module declarations from 'uvloop.includes.debug' */
/* Module declarations from 'uvloop.includes.python' */
/* Module declarations from 'libc.string' */
/* Module declarations from 'libc' */
/* Module declarations from 'libc.errno' */
/* Module declarations from 'cpython.version' */
/* Module declarations from '__builtin__' */
/* Module declarations from 'cpython.type' */
static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0;
/* Module declarations from 'libc.stdio' */
/* Module declarations from 'cpython.object' */
/* Module declarations from 'cpython.ref' */
/* Module declarations from 'cpython.exc' */
/* Module declarations from 'cpython.module' */
/* Module declarations from 'cpython.mem' */
/* Module declarations from 'cpython.tuple' */
/* Module declarations from 'cpython.list' */
/* Module declarations from 'cpython.sequence' */
/* Module declarations from 'cpython.mapping' */
/* Module declarations from 'cpython.iterator' */
/* Module declarations from 'cpython.number' */
/* Module declarations from 'cpython.int' */
/* Module declarations from '__builtin__' */
/* Module declarations from 'cpython.bool' */
static PyTypeObject *__pyx_ptype_7cpython_4bool_bool = 0;
/* Module declarations from 'cpython.long' */
/* Module declarations from 'cpython.float' */
/* Module declarations from '__builtin__' */
/* Module declarations from 'cpython.complex' */
static PyTypeObject *__pyx_ptype_7cpython_7complex_complex = 0;
/* Module declarations from 'cpython.string' */
/* Module declarations from 'cpython.unicode' */
/* Module declarations from 'cpython.dict' */
/* Module declarations from 'cpython.instance' */
/* Module declarations from 'cpython.function' */
/* Module declarations from 'cpython.method' */
/* Module declarations from 'cpython.weakref' */
/* Module declarations from 'cpython.getargs' */
/* Module declarations from 'cpython.pythread' */
/* Module declarations from 'cpython.pystate' */
/* Module declarations from 'cpython.cobject' */
/* Module declarations from 'cpython.oldbuffer' */
/* Module declarations from 'cpython.set' */
/* Module declarations from 'cpython.buffer' */
/* Module declarations from 'cpython.bytes' */
/* Module declarations from 'cpython.pycapsule' */
/* Module declarations from 'cpython' */
/* Module declarations from 'uvloop.loop' */
static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVHandle = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVSocketHandle = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVAsync = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVTimer = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVIdle = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVBaseTransport = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_Loop = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_Handle = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_TimerHandle = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVCheck = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVPoll = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVStream = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVStreamServer = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_TCPServer = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_TCPTransport = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_UnixServer = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_UnixTransport = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_ReadUnixTransport = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_WriteUnixTransport = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVProcess = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVProcessTransport = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_UVRequest = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_UDPTransport = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_Server = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop__StreamWriteContext = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop__TCPConnectRequest = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop__PipeConnectRequest = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_AddrInfo = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_AddrInfoRequest = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_NameInfoRequest = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop__UDPSendContext = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_BaseFuture = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop_BaseTask = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct___getaddrinfo = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_1__getnameinfo = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_2__sock_connect = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_3_run_until_complete = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_4_getnameinfo = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_5_create_server = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_6_create_connection = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_7_genexpr = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_8_genexpr = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_9_create_unix_server = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_10_create_unix_connection = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_11_sock_sendall = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_12_sock_connect = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_13_connect_accepted_socket = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_14___subprocess_run = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_15_connect_read_pipe = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_16_connect_write_pipe = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_17_create_datagram_endpoint = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_18_genexpr = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_19_shutdown_asyncgens = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_20_wait_closed = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_21___iter__ = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_22___await__ = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_23___pyx_f_6uvloop_4loop__chain_future = 0;
static PyTypeObject *__pyx_ptype_6uvloop_4loop___pyx_scope_struct_24__test_coroutine_1 = 0;
static PyObject *__pyx_v_6uvloop_4loop_aio_get_event_loop = 0;
static PyObject *__pyx_v_6uvloop_4loop_aio_CancelledError = 0;
static PyObject *__pyx_v_6uvloop_4loop_aio_InvalidStateError = 0;
static PyObject *__pyx_v_6uvloop_4loop_aio_TimeoutError = 0;
static PyObject *__pyx_v_6uvloop_4loop_aio_Future = 0;
static PyObject *__pyx_v_6uvloop_4loop_aio_Task = 0;
static PyObject *__pyx_v_6uvloop_4loop_aio_ensure_future = 0;
static PyObject *__pyx_v_6uvloop_4loop_aio_gather = 0;
static PyObject *__pyx_v_6uvloop_4loop_aio_wait = 0;
static PyObject *__pyx_v_6uvloop_4loop_aio_logger = 0;
static PyObject *__pyx_v_6uvloop_4loop_aio_iscoroutine = 0;
static PyObject *__pyx_v_6uvloop_4loop_aio_iscoroutinefunction = 0;
static PyObject *__pyx_v_6uvloop_4loop_aio_BaseProtocol = 0;
static PyObject *__pyx_v_6uvloop_4loop_aio_Protocol = 0;
static PyObject *__pyx_v_6uvloop_4loop_aio_SSLProtocol = 0;
static PyObject *__pyx_v_6uvloop_4loop_aio_debug_wrapper = 0;
static PyObject *__pyx_v_6uvloop_4loop_aio_isfuture = 0;
static PyObject *__pyx_v_6uvloop_4loop_aio_get_running_loop = 0;
static PyObject *__pyx_v_6uvloop_4loop_aio_set_running_loop = 0;
static PyObject *__pyx_v_6uvloop_4loop_col_deque = 0;
static PyObject *__pyx_v_6uvloop_4loop_col_Iterable = 0;
static PyObject *__pyx_v_6uvloop_4loop_col_Counter = 0;
static PyObject *__pyx_v_6uvloop_4loop_cc_ThreadPoolExecutor = 0;
static PyObject *__pyx_v_6uvloop_4loop_cc_Future = 0;
static PyObject *__pyx_v_6uvloop_4loop_errno_EINVAL = 0;
static PyObject *__pyx_v_6uvloop_4loop_ft_partial = 0;
static PyObject *__pyx_v_6uvloop_4loop_gc_disable = 0;
static PyObject *__pyx_v_6uvloop_4loop_iter_chain = 0;
static PyObject *__pyx_v_6uvloop_4loop_inspect_isgenerator = 0;
static int __pyx_v_6uvloop_4loop_has_SO_REUSEPORT;
static int __pyx_v_6uvloop_4loop_SO_REUSEPORT;
static PyObject *__pyx_v_6uvloop_4loop_socket_gaierror = 0;
static PyObject *__pyx_v_6uvloop_4loop_socket_error = 0;
static PyObject *__pyx_v_6uvloop_4loop_socket_timeout = 0;
static PyObject *__pyx_v_6uvloop_4loop_socket_socket = 0;
static PyObject *__pyx_v_6uvloop_4loop_socket_socketpair = 0;
static PyObject *__pyx_v_6uvloop_4loop_socket_getservbyname = 0;
static int __pyx_v_6uvloop_4loop_socket_EAI_ADDRFAMILY;
static int __pyx_v_6uvloop_4loop_socket_EAI_AGAIN;
static int __pyx_v_6uvloop_4loop_socket_EAI_BADFLAGS;
static int __pyx_v_6uvloop_4loop_socket_EAI_BADHINTS;
static int __pyx_v_6uvloop_4loop_socket_EAI_CANCELED;
static int __pyx_v_6uvloop_4loop_socket_EAI_FAIL;
static int __pyx_v_6uvloop_4loop_socket_EAI_FAMILY;
static int __pyx_v_6uvloop_4loop_socket_EAI_MEMORY;
static int __pyx_v_6uvloop_4loop_socket_EAI_NODATA;
static int __pyx_v_6uvloop_4loop_socket_EAI_NONAME;
static int __pyx_v_6uvloop_4loop_socket_EAI_OVERFLOW;
static int __pyx_v_6uvloop_4loop_socket_EAI_PROTOCOL;
static int __pyx_v_6uvloop_4loop_socket_EAI_SERVICE;
static int __pyx_v_6uvloop_4loop_socket_EAI_SOCKTYPE;
static PyObject *__pyx_v_6uvloop_4loop_os_name = 0;
static PyObject *__pyx_v_6uvloop_4loop_os_environ = 0;
static PyObject *__pyx_v_6uvloop_4loop_os_dup = 0;
static PyObject *__pyx_v_6uvloop_4loop_os_set_inheritable = 0;
static PyObject *__pyx_v_6uvloop_4loop_os_get_inheritable = 0;
static PyObject *__pyx_v_6uvloop_4loop_os_close = 0;
static PyObject *__pyx_v_6uvloop_4loop_os_open = 0;
static PyObject *__pyx_v_6uvloop_4loop_os_devnull = 0;
static PyObject *__pyx_v_6uvloop_4loop_os_O_RDWR = 0;
static PyObject *__pyx_v_6uvloop_4loop_os_pipe = 0;
static PyObject *__pyx_v_6uvloop_4loop_os_read = 0;
static PyObject *__pyx_v_6uvloop_4loop_sys_ignore_environment = 0;
static PyObject *__pyx_v_6uvloop_4loop_sys_exc_info = 0;
static PyObject *__pyx_v_6uvloop_4loop_sys_set_coroutine_wrapper = 0;
static PyObject *__pyx_v_6uvloop_4loop_sys_get_coroutine_wrapper = 0;
static PyObject *__pyx_v_6uvloop_4loop_sys_getframe = 0;
static PyObject *__pyx_v_6uvloop_4loop_ssl_SSLContext = 0;
static long __pyx_v_6uvloop_4loop_MAIN_THREAD_ID;
static int __pyx_v_6uvloop_4loop_subprocess_PIPE;
static int __pyx_v_6uvloop_4loop_subprocess_STDOUT;
static int __pyx_v_6uvloop_4loop_subprocess_DEVNULL;
static PyObject *__pyx_v_6uvloop_4loop_subprocess_SubprocessError = 0;
static int __pyx_v_6uvloop_4loop_signal_NSIG;
static PyObject *__pyx_v_6uvloop_4loop_signal_signal = 0;
static PyObject *__pyx_v_6uvloop_4loop_signal_set_wakeup_fd = 0;
static PyObject *__pyx_v_6uvloop_4loop_signal_default_int_handler = 0;
static PyObject *__pyx_v_6uvloop_4loop_signal_SIG_DFL = 0;
static PyObject *__pyx_v_6uvloop_4loop_time_sleep = 0;
static PyObject *__pyx_v_6uvloop_4loop_time_monotonic = 0;
static PyObject *__pyx_v_6uvloop_4loop_tb_extract_stack = 0;
static PyObject *__pyx_v_6uvloop_4loop_tb_format_list = 0;
static PyObject *__pyx_v_6uvloop_4loop_warnings_warn = 0;
static PyObject *__pyx_v_6uvloop_4loop_weakref_WeakValueDictionary = 0;
static PyObject *__pyx_v_6uvloop_4loop_weakref_WeakSet = 0;
static PyObject *__pyx_v_6uvloop_4loop_uvloop_Future = 0;
static PyObject *__pyx_v_6uvloop_4loop_future_factory = 0;
static PyObject *__pyx_v_6uvloop_4loop_task_factory = 0;
static volatile int __pyx_v_6uvloop_4loop___atfork_installed;
static volatile int __pyx_v_6uvloop_4loop___forking;
static struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_6uvloop_4loop___forking_loop = 0;
static volatile int __pyx_v_6uvloop_4loop___mem_installed;
static PyObject *__pyx_f_6uvloop_4loop___strerr(int); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop___convert_python_error(int); /*proto*/
static int __pyx_f_6uvloop_4loop___convert_socket_error(int); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop_convert_error(int); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop__is_sock_stream(PyObject *); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop__is_sock_dgram(PyObject *); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop_isfuture(PyObject *); /*proto*/
static void __pyx_f_6uvloop_4loop___loop_alloc_buffer(uv_handle_t *, size_t, uv_buf_t *); /*proto*/
static CYTHON_INLINE void __pyx_f_6uvloop_4loop___loop_free_buffer(struct __pyx_obj_6uvloop_4loop_Loop *); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop_new_Handle(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, PyObject *); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop_new_MethodHandle(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, __pyx_t_6uvloop_4loop_method_t, PyObject *); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop_new_MethodHandle1(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, __pyx_t_6uvloop_4loop_method1_t, PyObject *, PyObject *); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop_new_MethodHandle2(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, __pyx_t_6uvloop_4loop_method2_t, PyObject *, PyObject *, PyObject *); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop_new_MethodHandle3(struct __pyx_obj_6uvloop_4loop_Loop *, PyObject *, __pyx_t_6uvloop_4loop_method3_t, PyObject *, PyObject *, PyObject *, PyObject *); /*proto*/
static CYTHON_INLINE int __pyx_f_6uvloop_4loop___ensure_handle_data(uv_handle_t *, char const *); /*proto*/
static void __pyx_f_6uvloop_4loop___uv_close_handle_cb(uv_handle_t *); /*proto*/
static void __pyx_f_6uvloop_4loop___close_all_handles(struct __pyx_obj_6uvloop_4loop_Loop *); /*proto*/
static void __pyx_f_6uvloop_4loop___uv_walk_close_all_handles_cb(uv_handle_t *, void *); /*proto*/
static void __pyx_f_6uvloop_4loop___uvasync_callback(uv_async_t *); /*proto*/
static void __pyx_f_6uvloop_4loop_cb_idle_callback(uv_idle_t *); /*proto*/
static void __pyx_f_6uvloop_4loop_cb_check_callback(uv_check_t *); /*proto*/
static void __pyx_f_6uvloop_4loop___uvtimer_callback(uv_timer_t *); /*proto*/
static void __pyx_f_6uvloop_4loop___on_uvpoll_event(uv_poll_t *, int, int); /*proto*/
static void __pyx_f_6uvloop_4loop___uv_stream_on_shutdown(uv_shutdown_t *, int); /*proto*/
static CYTHON_INLINE void __pyx_f_6uvloop_4loop___uv_stream_on_read_impl(uv_stream_t *, Py_ssize_t, uv_buf_t const *); /*proto*/
static CYTHON_INLINE void __pyx_f_6uvloop_4loop___uv_stream_on_write_impl(uv_write_t *, int); /*proto*/
static void __pyx_f_6uvloop_4loop___uv_stream_on_read(uv_stream_t *, Py_ssize_t, uv_buf_t const *); /*proto*/
static void __pyx_f_6uvloop_4loop___uv_stream_on_write(uv_write_t *, int); /*proto*/
static void __pyx_f_6uvloop_4loop___uv_streamserver_on_listen(uv_stream_t *, int); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop___tcp_init_uv_handle(struct __pyx_obj_6uvloop_4loop_UVStream *, struct __pyx_obj_6uvloop_4loop_Loop *, unsigned int); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop___tcp_bind(struct __pyx_obj_6uvloop_4loop_UVStream *, struct sockaddr *, unsigned int); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop___tcp_open(struct __pyx_obj_6uvloop_4loop_UVStream *, int); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop___tcp_get_socket(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *); /*proto*/
static void __pyx_f_6uvloop_4loop___tcp_connect_callback(uv_connect_t *, int); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop___pipe_init_uv_handle(struct __pyx_obj_6uvloop_4loop_UVStream *, struct __pyx_obj_6uvloop_4loop_Loop *); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop___pipe_open(struct __pyx_obj_6uvloop_4loop_UVStream *, int); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop___pipe_get_socket(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *); /*proto*/
static void __pyx_f_6uvloop_4loop___pipe_connect_callback(uv_connect_t *, int); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop___process_convert_fileno(PyObject *); /*proto*/
static void __pyx_f_6uvloop_4loop___uvprocess_on_exit_callback(uv_process_t *, int64_t, int); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop___socketpair(void); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop___port_to_int(PyObject *, PyObject *); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop___convert_sockaddr_to_pyaddr(struct sockaddr const *); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop___convert_pyaddr_to_sockaddr(int, PyObject *, struct sockaddr *); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop___static_getaddrinfo(PyObject *, PyObject *, int, int, int, struct sockaddr *); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop___static_getaddrinfo_pyaddr(PyObject *, PyObject *, int, int, int, int); /*proto*/
static void __pyx_f_6uvloop_4loop___on_addrinfo_resolved(uv_getaddrinfo_t *, int, struct addrinfo *); /*proto*/
static void __pyx_f_6uvloop_4loop___on_nameinfo_resolved(uv_getnameinfo_t *, int, char const *, char const *); /*proto*/
static void __pyx_f_6uvloop_4loop___uv_udp_on_receive(uv_udp_t *, Py_ssize_t, uv_buf_t const *, struct sockaddr const *, unsigned int); /*proto*/
static void __pyx_f_6uvloop_4loop___uv_udp_on_send(uv_udp_send_t *, int); /*proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop__future_get_blocking(PyObject *); /*proto*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop__future_set_blocking(PyObject *, PyObject *); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop__is_uvloop_future(PyObject *); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop__set_concurrent_future_state(PyObject *, PyObject *); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop__copy_future_state(PyObject *, PyObject *); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop__chain_future(PyObject *, PyObject *); /*proto*/
static void __pyx_f_6uvloop_4loop___atfork_child(void); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop___install_atfork(void); /*proto*/
static PyObject *__pyx_f_6uvloop_4loop___install_pymem(void); /*proto*/
#define __Pyx_MODULE_NAME "uvloop.loop"
int __pyx_module_is_main_uvloop__loop = 0;
/* Implementation of 'uvloop.loop' */
static PyObject *__pyx_builtin_OSError;
static PyObject *__pyx_builtin_PermissionError;
static PyObject *__pyx_builtin_BlockingIOError;
static PyObject *__pyx_builtin_BrokenPipeError;
static PyObject *__pyx_builtin_ConnectionAbortedError;
static PyObject *__pyx_builtin_ConnectionRefusedError;
static PyObject *__pyx_builtin_ConnectionResetError;
static PyObject *__pyx_builtin_FileExistsError;
static PyObject *__pyx_builtin_FileNotFoundError;
static PyObject *__pyx_builtin_InterruptedError;
static PyObject *__pyx_builtin_IsADirectoryError;
static PyObject *__pyx_builtin_ProcessLookupError;
static PyObject *__pyx_builtin_TimeoutError;
static PyObject *__pyx_builtin_MemoryError;
static PyObject *__pyx_builtin_RuntimeError;
static PyObject *__pyx_builtin_ValueError;
static PyObject *__pyx_builtin_KeyError;
static PyObject *__pyx_builtin_BaseException;
static PyObject *__pyx_builtin_TypeError;
static PyObject *__pyx_builtin_memoryview;
static PyObject *__pyx_builtin_RuntimeWarning;
static PyObject *__pyx_builtin_NotImplementedError;
static PyObject *__pyx_builtin_print;
static PyObject *__pyx_builtin_OverflowError;
static PyObject *__pyx_builtin_LookupError;
static PyObject *__pyx_builtin_ResourceWarning;
static PyObject *__pyx_builtin_zip;
static PyObject *__pyx_builtin_id;
static PyObject *__pyx_builtin_AttributeError;
static PyObject *__pyx_builtin_super;
static PyObject *__pyx_builtin_open;
static PyObject *__pyx_builtin_range;
static PyObject *__pyx_builtin_StopIteration;
static PyObject *__pyx_builtin_AssertionError;
static const char __pyx_k_b[] = "b";
static const char __pyx_k_c[] = "-c";
static const char __pyx_k_n[] = "n";
static const char __pyx_k_r[] = "{}: {!r}";
static const char __pyx_k_ex[] = "ex";
static const char __pyx_k_fd[] = "fd";
static const char __pyx_k_gc[] = "gc";
static const char __pyx_k_id[] = "id";
static const char __pyx_k_os[] = "os";
static const char __pyx_k_wb[] = "wb";
static const char __pyx_k__30[] = "";
static const char __pyx_k__36[] = "-------------------------------+---------+---------";
static const char __pyx_k__64[] = ", ";
static const char __pyx_k__75[] = "{}: {}";
static const char __pyx_k__76[] = "\n";
static const char __pyx_k__97[] = "{}={}";
static const char __pyx_k_add[] = "add";
static const char __pyx_k_cmd[] = "cmd";
static const char __pyx_k_cwd[] = "cwd";
static const char __pyx_k_doc[] = "__doc__";
static const char __pyx_k_dup[] = "dup";
static const char __pyx_k_env[] = "env";
static const char __pyx_k_exc[] = "exc";
static const char __pyx_k_fut[] = "fut";
static const char __pyx_k_get[] = "get";
static const char __pyx_k_log[] = "log";
static const char __pyx_k_low[] = "low";
static const char __pyx_k_pop[] = "pop";
static const char __pyx_k_sig[] = "sig";
static const char __pyx_k_ssl[] = "ssl";
static const char __pyx_k_sys[] = "sys";
static const char __pyx_k_tcp[] = "tcp";
static const char __pyx_k_udp[] = "udp";
static const char __pyx_k_zip[] = "zip";
static const char __pyx_k_NSIG[] = "NSIG";
static const char __pyx_k_PIPE[] = "PIPE";
static const char __pyx_k_Task[] = "Task";
static const char __pyx_k__108[] = "<";
static const char __pyx_k__109[] = " ";
static const char __pyx_k__110[] = ">";
static const char __pyx_k__117[] = "{} ({})";
static const char __pyx_k__143[] = ":";
static const char __pyx_k__154[] = "=";
static const char __pyx_k_addr[] = "addr";
static const char __pyx_k_args[] = "args";
static const char __pyx_k_bind[] = "bind";
static const char __pyx_k_cast[] = "cast";
static const char __pyx_k_copy[] = "copy";
static const char __pyx_k_coro[] = "coro";
static const char __pyx_k_data[] = "data";
static const char __pyx_k_done[] = "done";
static const char __pyx_k_exit[] = "__exit__";
static const char __pyx_k_func[] = "func";
static const char __pyx_k_high[] = "high";
static const char __pyx_k_host[] = "host";
static const char __pyx_k_idna[] = "idna";
static const char __pyx_k_init[] = "__init__";
static const char __pyx_k_iter[] = "__iter__";
static const char __pyx_k_loop[] = "loop";
static const char __pyx_k_main[] = "__main__";
static const char __pyx_k_name[] = "__name__";
static const char __pyx_k_noop[] = "_noop";
static const char __pyx_k_open[] = "open";
static const char __pyx_k_path[] = "path";
static const char __pyx_k_pipe[] = "pipe";
static const char __pyx_k_port[] = "port";
static const char __pyx_k_proc[] = "proc";
static const char __pyx_k_read[] = "read";
static const char __pyx_k_recv[] = "recv";
static const char __pyx_k_repr[] = "__repr__";
static const char __pyx_k_self[] = "self";
static const char __pyx_k_send[] = "send";
static const char __pyx_k_sock[] = "sock";
static const char __pyx_k_stop[] = "stop";
static const char __pyx_k_test[] = "__test__";
static const char __pyx_k_time[] = "time";
static const char __pyx_k_type[] = "type";
static const char __pyx_k_wait[] = "wait";
static const char __pyx_k_warn[] = "warn";
static const char __pyx_k_when[] = "when";
static const char __pyx_k_await[] = "__await__";
static const char __pyx_k_cause[] = "__cause__";
static const char __pyx_k_chain[] = "chain";
static const char __pyx_k_class[] = "__class__";
static const char __pyx_k_clear[] = "clear";
static const char __pyx_k_close[] = "close";
static const char __pyx_k_delay[] = "delay";
static const char __pyx_k_deque[] = "deque";
static const char __pyx_k_enter[] = "__enter__";
static const char __pyx_k_errno[] = "errno";
static const char __pyx_k_error[] = "error";
static const char __pyx_k_flags[] = "flags";
static const char __pyx_k_flush[] = "flush";
static const char __pyx_k_frame[] = "frame";
static const char __pyx_k_ident[] = "ident";
static const char __pyx_k_items[] = "items";
static const char __pyx_k_lower[] = "lower";
static const char __pyx_k_other[] = "other";
static const char __pyx_k_print[] = "print";
static const char __pyx_k_proto[] = "proto";
static const char __pyx_k_range[] = "range";
static const char __pyx_k_shell[] = "shell";
static const char __pyx_k_sleep[] = "sleep";
static const char __pyx_k_split[] = "split";
static const char __pyx_k_stdin[] = "stdin";
static const char __pyx_k_super[] = "super";
static const char __pyx_k_throw[] = "throw";
static const char __pyx_k_value[] = "value";
static const char __pyx_k_write[] = "write";
static const char __pyx_k_Future[] = "Future";
static const char __pyx_k_O_RDWR[] = "O_RDWR";
static const char __pyx_k_STDOUT[] = "STDOUT";
static const char __pyx_k_accept[] = "accept";
static const char __pyx_k_aclose[] = "aclose";
static const char __pyx_k_append[] = "append";
static const char __pyx_k_bin_sh[] = "/bin/sh";
static const char __pyx_k_cancel[] = "cancel";
static const char __pyx_k_decode[] = "decode";
static const char __pyx_k_detach[] = "detach";
static const char __pyx_k_encode[] = "encode";
static const char __pyx_k_family[] = "family";
static const char __pyx_k_fileno[] = "fileno";
static const char __pyx_k_format[] = "format";
static const char __pyx_k_future[] = "future";
static const char __pyx_k_gather[] = "gather";
static const char __pyx_k_handle[] = "handle";
static const char __pyx_k_import[] = "__import__";
static const char __pyx_k_logger[] = "logger";
static const char __pyx_k_loop_2[] = "_loop";
static const char __pyx_k_module[] = "__module__";
static const char __pyx_k_name_2[] = "name";
static const char __pyx_k_noop_2[] = "noop";
static const char __pyx_k_remove[] = "remove";
static const char __pyx_k_result[] = "result";
static const char __pyx_k_rstrip[] = "rstrip";
static const char __pyx_k_signal[] = "signal";
static const char __pyx_k_signum[] = "signum";
static const char __pyx_k_socket[] = "socket";
static const char __pyx_k_source[] = "source";
static const char __pyx_k_stderr[] = "stderr";
static const char __pyx_k_stdout[] = "stdout";
static const char __pyx_k_submit[] = "submit";
static const char __pyx_k_update[] = "update";
static const char __pyx_k_values[] = "values";
static const char __pyx_k_waiter[] = "waiter";
static const char __pyx_k_wakeup[] = "_wakeup";
static const char __pyx_k_0_0_0_0[] = "0.0.0.0";
static const char __pyx_k_Counter[] = "Counter";
static const char __pyx_k_DEVNULL[] = "DEVNULL";
static const char __pyx_k_OSError[] = "OSError";
static const char __pyx_k_PENDING[] = "PENDING";
static const char __pyx_k_SIG_DFL[] = "SIG_DFL";
static const char __pyx_k_WeakSet[] = "WeakSet";
static const char __pyx_k_address[] = "address";
static const char __pyx_k_asyncio[] = "asyncio";
static const char __pyx_k_backlog[] = "backlog";
static const char __pyx_k_bufsize[] = "bufsize";
static const char __pyx_k_connect[] = "connect";
static const char __pyx_k_context[] = "context";
static const char __pyx_k_default[] = "default";
static const char __pyx_k_devnull[] = "devnull";
static const char __pyx_k_disable[] = "disable";
static const char __pyx_k_discard[] = "discard";
static const char __pyx_k_environ[] = "environ";
static const char __pyx_k_futures[] = "futures";
static const char __pyx_k_genexpr[] = "genexpr";
static const char __pyx_k_inspect[] = "inspect";
static const char __pyx_k_message[] = "message";
static const char __pyx_k_partial[] = "partial";
static const char __pyx_k_popleft[] = "popleft";
static const char __pyx_k_prepare[] = "__prepare__";
static const char __pyx_k_program[] = "program";
static const char __pyx_k_sockets[] = "sockets";
static const char __pyx_k_timeout[] = "timeout";
static const char __pyx_k_warning[] = "warning";
static const char __pyx_k_weakref[] = "weakref";
static const char __pyx_k_18_7_7_7[] = " {: <18} {: >7} | {: >7} | {: >7}";
static const char __pyx_k_EAI_FAIL[] = "EAI_FAIL";
static const char __pyx_k_FINISHED[] = "FINISHED";
static const char __pyx_k_Iterable[] = "Iterable";
static const char __pyx_k_KeyError[] = "KeyError";
static const char __pyx_k_Protocol[] = "Protocol";
static const char __pyx_k_asyncgen[] = "asyncgen";
static const char __pyx_k_blocking[] = "_blocking";
static const char __pyx_k_builtins[] = "__builtins__";
static const char __pyx_k_callback[] = "callback";
static const char __pyx_k_closed_x[] = "<{} closed={} {:#x}>";
static const char __pyx_k_exc_info[] = "exc_info";
static const char __pyx_k_executor[] = "executor";
static const char __pyx_k_gaierror[] = "gaierror";
static const char __pyx_k_getframe[] = "_getframe";
static const char __pyx_k_isfuture[] = "isfuture";
static const char __pyx_k_pass_fds[] = "pass_fds";
static const char __pyx_k_peername[] = "peername";
static const char __pyx_k_protocol[] = "protocol";
static const char __pyx_k_qualname[] = "__qualname__";
static const char __pyx_k_shutdown[] = "shutdown";
static const char __pyx_k_sockaddr[] = "sockaddr";
static const char __pyx_k_sockname[] = "sockname";
static const char __pyx_k_sslproto[] = "sslproto";
static const char __pyx_k_strerror[] = "strerror";
static const char __pyx_k_subtract[] = "subtract";
static const char __pyx_k_warnings[] = "warnings";
static const char __pyx_k_CANCELLED[] = "CANCELLED";
static const char __pyx_k_EAI_AGAIN[] = "EAI_AGAIN";
static const char __pyx_k_Loop_time[] = "Loop time: {}";
static const char __pyx_k_Read_EOFs[] = "Read EOFs: {}";
static const char __pyx_k_TypeError[] = "TypeError";
static const char __pyx_k_all_tasks[] = "_all_tasks";
static const char __pyx_k_call_soon[] = "call_soon";
static const char __pyx_k_cancelled[] = "cancelled";
static const char __pyx_k_close_fds[] = "close_fds";
static const char __pyx_k_exception[] = "exception";
static const char __pyx_k_finalizer[] = "finalizer";
static const char __pyx_k_firstiter[] = "firstiter";
static const char __pyx_k_functools[] = "functools";
static const char __pyx_k_get_debug[] = "get_debug";
static const char __pyx_k_is_closed[] = "is_closed";
static const char __pyx_k_itertools[] = "itertools";
static const char __pyx_k_metaclass[] = "__metaclass__";
static const char __pyx_k_monotonic[] = "monotonic";
static const char __pyx_k_set_debug[] = "set_debug";
static const char __pyx_k_set_state[] = "_set_state";
static const char __pyx_k_stdio_fut[] = "stdio_fut";
static const char __pyx_k_threading[] = "threading";
static const char __pyx_k_traceback[] = "__traceback__";
static const char __pyx_k_transport[] = "transport";
static const char __pyx_k_EAI_FAMILY[] = "EAI_FAMILY";
static const char __pyx_k_EAI_MEMORY[] = "EAI_MEMORY";
static const char __pyx_k_EAI_NODATA[] = "EAI_NODATA";
static const char __pyx_k_EAI_NONAME[] = "EAI_NONAME";
static const char __pyx_k_Loop__stop[] = "Loop._stop";
static const char __pyx_k_Not_paused[] = "Not paused";
static const char __pyx_k_SSLContext[] = "SSLContext";
static const char __pyx_k_Task__step[] = "Task._step";
static const char __pyx_k_ValueError[] = "ValueError";
static const char __pyx_k_call_later[] = "call_later";
static const char __pyx_k_concurrent[] = "concurrent";
static const char __pyx_k_coroutines[] = "coroutines";
static const char __pyx_k_created_at[] = "created at {}:{}";
static const char __pyx_k_executable[] = "executable";
static const char __pyx_k_getsockopt[] = "getsockopt";
static const char __pyx_k_gettimeout[] = "gettimeout";
static const char __pyx_k_is_running[] = "is_running";
static const char __pyx_k_local_addr[] = "local_addr";
static const char __pyx_k_memoryview[] = "memoryview";
static const char __pyx_k_new_future[] = "new_future";
static const char __pyx_k_preexec_fn[] = "preexec_fn";
static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__";
static const char __pyx_k_reuse_port[] = "reuse_port";
static const char __pyx_k_set_result[] = "set_result";
static const char __pyx_k_socketpair[] = "socketpair";
static const char __pyx_k_std_signal[] = "std_signal";
static const char __pyx_k_subprocess[] = "subprocess";
static const char __pyx_k_EAI_SERVICE[] = "EAI_SERVICE";
static const char __pyx_k_LookupError[] = "LookupError";
static const char __pyx_k_MemoryError[] = "MemoryError";
static const char __pyx_k_Read_errors[] = "Read errors: {}";
static const char __pyx_k_Read_events[] = "Read events: {}";
static const char __pyx_k_SSLProtocol[] = "SSLProtocol";
static const char __pyx_k_asyncio_log[] = "asyncio.log";
static const char __pyx_k_collections[] = "collections";
static const char __pyx_k_create_task[] = "create_task";
static const char __pyx_k_destination[] = "destination";
static const char __pyx_k_force_close[] = "_force_close";
static const char __pyx_k_format_list[] = "format_list";
static const char __pyx_k_getaddrinfo[] = "getaddrinfo";
static const char __pyx_k_getnameinfo[] = "getnameinfo";
static const char __pyx_k_getpeername[] = "getpeername";
static const char __pyx_k_getsockname[] = "getsockname";
static const char __pyx_k_iscoroutine[] = "iscoroutine";
static const char __pyx_k_isgenerator[] = "isgenerator";
static const char __pyx_k_main_thread[] = "main_thread";
static const char __pyx_k_remote_addr[] = "remote_addr";
static const char __pyx_k_run_forever[] = "run_forever";
static const char __pyx_k_s_sockets_r[] = "<%s sockets=%r>";
static const char __pyx_k_setblocking[] = "setblocking";
static const char __pyx_k_startupinfo[] = "startupinfo";
static const char __pyx_k_traceback_2[] = "traceback";
static const char __pyx_k_uvloop_loop[] = "uvloop.loop";
static const char __pyx_k_wait_closed[] = "wait_closed";
static const char __pyx_k_wrap_future[] = "_wrap_future";
static const char __pyx_k_BaseProtocol[] = "BaseProtocol";
static const char __pyx_k_EAI_BADFLAGS[] = "EAI_BADFLAGS";
static const char __pyx_k_EAI_BADHINTS[] = "EAI_BADHINTS";
static const char __pyx_k_EAI_CANCELED[] = "EAI_CANCELED";
static const char __pyx_k_EAI_OVERFLOW[] = "EAI_OVERFLOW";
static const char __pyx_k_EAI_PROTOCOL[] = "EAI_PROTOCOL";
static const char __pyx_k_EAI_SOCKTYPE[] = "EAI_SOCKTYPE";
static const char __pyx_k_Process_info[] = "---- Process info: -----";
static const char __pyx_k_RuntimeError[] = "RuntimeError";
static const char __pyx_k_SO_REUSEPORT[] = "SO_REUSEPORT";
static const char __pyx_k_TimeoutError[] = "TimeoutError";
static const char __pyx_k_Write_errors[] = "Write errors: {}";
static const char __pyx_k_Write_events[] = "Write events: {}";
static const char __pyx_k_alive_closed[] = " alive | closed |";
static const char __pyx_k_disconnected[] = "disconnected";
static const char __pyx_k_eof_received[] = "eof_received";
static const char __pyx_k_objs_handles[] = " objs | handles |";
static const char __pyx_k_sock_connect[] = "sock_connect";
static const char __pyx_k_sock_sendall[] = "sock_sendall";
static const char __pyx_k_stdio_inited[] = "__stdio_inited";
static const char __pyx_k_version_info[] = "version_info";
static const char __pyx_k_BaseException[] = "BaseException";
static const char __pyx_k_Errors_logged[] = "Errors logged: {}";
static const char __pyx_k_Listen_errors[] = "Listen errors: {}";
static const char __pyx_k_OverflowError[] = "OverflowError";
static const char __pyx_k_StopIteration[] = "StopIteration";
static const char __pyx_k_app_transport[] = "_app_transport";
static const char __pyx_k_asyncio_tasks[] = "asyncio.tasks";
static const char __pyx_k_create_future[] = "create_future";
static const char __pyx_k_create_server[] = "create_server";
static const char __pyx_k_creationflags[] = "creationflags";
static const char __pyx_k_current_tasks[] = "_current_tasks";
static const char __pyx_k_data_received[] = "data_received";
static const char __pyx_k_debug_wrapper[] = "debug_wrapper";
static const char __pyx_k_ensure_future[] = "ensure_future";
static const char __pyx_k_extract_stack[] = "extract_stack";
static const char __pyx_k_getservbyname[] = "getservbyname";
static const char __pyx_k_loop__on_idle[] = "loop._on_idle";
static const char __pyx_k_pause_writing[] = "pause_writing";
static const char __pyx_k_proto_factory[] = "proto_factory";
static const char __pyx_k_reuse_address[] = "reuse_address";
static const char __pyx_k_s_fd_s_pipe_r[] = "<%s fd=%s pipe=%r>";
static const char __pyx_k_set_exception[] = "set_exception";
static const char __pyx_k_set_wakeup_fd[] = "set_wakeup_fd";
static const char __pyx_k_Already_paused[] = "Already paused";
static const char __pyx_k_AssertionError[] = "AssertionError";
static const char __pyx_k_AttributeError[] = "AttributeError";
static const char __pyx_k_CancelledError[] = "CancelledError";
static const char __pyx_k_EAI_ADDRFAMILY[] = "EAI_ADDRFAMILY";
static const char __pyx_k_Process_memory[] = "Process memory: {}";
static const char __pyx_k_Read_callbacks[] = "Read callbacks: {}";
static const char __pyx_k_RuntimeWarning[] = "RuntimeWarning";
static const char __pyx_k_call_set_state[] = "_call_set_state";
static const char __pyx_k_connect_failed[] = "connect failed";
static const char __pyx_k_error_received[] = "error_received";
static const char __pyx_k_get_event_loop[] = "get_event_loop";
static const char __pyx_k_get_extra_info[] = "get_extra_info";
static const char __pyx_k_process_exited[] = "process_exited";
static const char __pyx_k_resume_writing[] = "resume_writing";
static const char __pyx_k_subprocess_run[] = "__subprocess_run";
static const char __pyx_k_BlockingIOError[] = "BlockingIOError";
static const char __pyx_k_BrokenPipeError[] = "BrokenPipeError";
static const char __pyx_k_FileExistsError[] = "FileExistsError";
static const char __pyx_k_Loop__sock_recv[] = "Loop._sock_recv";
static const char __pyx_k_Loop_debug_info[] = "--- Loop debug info: ---";
static const char __pyx_k_PermissionError[] = "PermissionError";
static const char __pyx_k_ResourceWarning[] = "ResourceWarning";
static const char __pyx_k_Shutdown_errors[] = "Shutdown errors {}";
static const char __pyx_k_SubprocessError[] = "SubprocessError";
static const char __pyx_k_Timer_handles_8[] = "Timer handles: {: <8} | {}";
static const char __pyx_k_allow_broadcast[] = "allow_broadcast";
static const char __pyx_k_asyncio_futures[] = "asyncio.futures";
static const char __pyx_k_connection_lost[] = "connection_lost";
static const char __pyx_k_connection_made[] = "connection_made";
static const char __pyx_k_get_inheritable[] = "get_inheritable";
static const char __pyx_k_restore_signals[] = "restore_signals";
static const char __pyx_k_server_hostname[] = "server_hostname";
static const char __pyx_k_set_inheritable[] = "set_inheritable";
static const char __pyx_k_sighandler_noop[] = "_sighandler_noop";
static const char __pyx_k_InterruptedError[] = "InterruptedError";
static const char __pyx_k_Loop_getnameinfo[] = "Loop.getnameinfo";
static const char __pyx_k_Polls_debug_info[] = "--- Polls debug info: ---";
static const char __pyx_k_Write_contexts_8[] = "Write contexts: {: <8} | {}";
static const char __pyx_k_asyncio_sslproto[] = "asyncio.sslproto";
static const char __pyx_k_closed_reading_x[] = "<{} closed={} reading={} {:#x}>";
static const char __pyx_k_get_running_loop[] = "_get_running_loop";
static const char __pyx_k_on_ssl_connected[] = "__on_ssl_connected";
static const char __pyx_k_protocol_factory[] = "protocol_factory";
static const char __pyx_k_set_running_loop[] = "_set_running_loop";
static const char __pyx_k_source_traceback[] = "source_traceback";
static const char __pyx_k_test_coroutine_1[] = "_test_coroutine_1";
static const char __pyx_k_BaseFuture___iter[] = "BaseFuture.__iter__";
static const char __pyx_k_FileNotFoundError[] = "FileNotFoundError";
static const char __pyx_k_InvalidStateError[] = "InvalidStateError";
static const char __pyx_k_IsADirectoryError[] = "IsADirectoryError";
static const char __pyx_k_Loop__sock_accept[] = "Loop._sock_accept";
static const char __pyx_k_Loop_sock_connect[] = "Loop.sock_connect";
static const char __pyx_k_Loop_sock_sendall[] = "Loop.sock_sendall";
static const char __pyx_k_Number_of_signals[] = "Number of signals: {}";
static const char __pyx_k_Socket_try_writes[] = "Socket try-writes: {}";
static const char __pyx_k_add_done_callback[] = "add_done_callback";
static const char __pyx_k_bufsize_must_be_0[] = "bufsize must be 0";
static const char __pyx_k_call_check_cancel[] = "_call_check_cancel";
static const char __pyx_k_connect_read_pipe[] = "connect_read_pipe";
static const char __pyx_k_create_connection[] = "create_connection";
static const char __pyx_k_datagram_received[] = "datagram_received";
static const char __pyx_k_return_exceptions[] = "return_exceptions";
static const char __pyx_k_start_new_session[] = "start_new_session";
static const char __pyx_k_BaseFuture___await[] = "BaseFuture.__await__";
static const char __pyx_k_Callback_handles_8[] = "Callback handles: {: <8} | {}";
static const char __pyx_k_Loop__sock_connect[] = "Loop._sock_connect";
static const char __pyx_k_Loop__sock_sendall[] = "Loop._sock_sendall";
static const char __pyx_k_Loop_create_server[] = "Loop.create_server";
static const char __pyx_k_PYTHONASYNCIODEBUG[] = "PYTHONASYNCIODEBUG";
static const char __pyx_k_ProcessLookupError[] = "ProcessLookupError";
static const char __pyx_k_Server_wait_closed[] = "Server.wait_closed";
static const char __pyx_k_Streams_debug_info[] = "--- Streams debug info: ---";
static const char __pyx_k_ThreadPoolExecutor[] = "ThreadPoolExecutor";
static const char __pyx_k_Write_without_poll[] = "Write without poll: {}";
static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines";
static const char __pyx_k_concurrent_futures[] = "concurrent.futures";
static const char __pyx_k_connect_write_pipe[] = "connect_write_pipe";
static const char __pyx_k_create_unix_server[] = "create_unix_server";
static const char __pyx_k_get_asyncgen_hooks[] = "get_asyncgen_hooks";
static const char __pyx_k_ignore_environment[] = "ignore_environment";
static const char __pyx_k_pipe_data_received[] = "pipe_data_received";
static const char __pyx_k_set_asyncgen_hooks[] = "set_asyncgen_hooks";
static const char __pyx_k_shell_must_be_True[] = "shell must be True";
static const char __pyx_k_shutdown_asyncgens[] = "shutdown_asyncgens";
static const char __pyx_k_sig_out_of_range_1[] = "sig {} out of range(1, {})";
static const char __pyx_k_universal_newlines[] = "universal_newlines";
static const char __pyx_k_unopened_TCPServer[] = "unopened TCPServer";
static const char __pyx_k_Multiple_exceptions[] = "Multiple exceptions: {}";
static const char __pyx_k_NotImplementedError[] = "NotImplementedError";
static const char __pyx_k_Result_is_not_ready[] = "Result is not ready.";
static const char __pyx_k_WeakValueDictionary[] = "WeakValueDictionary";
static const char __pyx_k_asyncio_base_events[] = "asyncio.base_events";
static const char __pyx_k_default_int_handler[] = "default_int_handler";
static const char __pyx_k_iscoroutinefunction[] = "iscoroutinefunction";
static const char __pyx_k_log_destroy_pending[] = "_log_destroy_pending";
static const char __pyx_k_shell_must_be_False[] = "shell must be False";
static const char __pyx_k_unclosed_resource_r[] = "unclosed resource {!r}; {}";
static const char __pyx_k_ConnectionResetError[] = "ConnectionResetError";
static const char __pyx_k_Event_loop_is_closed[] = "Event loop is closed";
static const char __pyx_k_Exception_is_not_set[] = "Exception is not set.";
static const char __pyx_k_Loop__read_from_self[] = "Loop._read_from_self";
static const char __pyx_k_Task_got_bad_yield_r[] = "Task got bad yield: {!r}";
static const char __pyx_k_call_soon_threadsafe[] = "call_soon_threadsafe";
static const char __pyx_k_pipe_connection_lost[] = "pipe_connection_lost";
static const char __pyx_k_protocol_is_required[] = "protocol is required";
static const char __pyx_k_remove_done_callback[] = "remove_done_callback";
static const char __pyx_k_running_closed_debug[] = "<{}.{} running={} closed={} debug={}>";
static const char __pyx_k_sig_cannot_be_caught[] = "sig {} cannot be caught";
static const char __pyx_k_unknown_Future_state[] = "unknown Future state";
static const char __pyx_k_AddrInfo_data_is_NULL[] = "AddrInfo.data is NULL";
static const char __pyx_k_Connect_call_failed_s[] = "Connect call failed %s";
static const char __pyx_k_Exception_in_callback[] = "Exception in callback {}";
static const char __pyx_k_Fatal_error_on_server[] = "Fatal error on server {}";
static const char __pyx_k_Loop___subprocess_run[] = "Loop.__subprocess_run";
static const char __pyx_k_Read_callbacks_failed[] = "Read callbacks failed: {}";
static const char __pyx_k_Read_failed_callbacks[] = "Read failed callbacks: {}";
static const char __pyx_k_get_coroutine_wrapper[] = "get_coroutine_wrapper";
static const char __pyx_k_remove_signal_handler[] = "remove_signal_handler";
static const char __pyx_k_set_coroutine_wrapper[] = "set_coroutine_wrapper";
static const char __pyx_k_step_already_done_r_r[] = "_step(): already done: {!r}, {!r}";
static const char __pyx_k_unclosed_resource_r_2[] = "unclosed resource {!r}";
static const char __pyx_k_ConnectionAbortedError[] = "ConnectionAbortedError";
static const char __pyx_k_ConnectionRefusedError[] = "ConnectionRefusedError";
static const char __pyx_k_Loop_connect_read_pipe[] = "Loop.connect_read_pipe";
static const char __pyx_k_Loop_create_connection[] = "Loop.create_connection";
static const char __pyx_k_Write_callbacks_failed[] = "Write callbacks failed: {}";
static const char __pyx_k_Write_failed_callbacks[] = "Write failed callbacks: {}";
static const char __pyx_k_call_exception_handler[] = "call_exception_handler";
static const char __pyx_k_cancel_request_is_NULL[] = "{}.cancel: .request is NULL";
static const char __pyx_k_concurrent_allocations[] = "concurrent allocations";
static const char __pyx_k_create_unix_connection[] = "create_unix_connection";
static const char __pyx_k_invalid_Handle_cb_type[] = "invalid Handle.cb_type: {}";
static const char __pyx_k_Loop_connect_write_pipe[] = "Loop.connect_write_pipe";
static const char __pyx_k_Loop_create_unix_server[] = "Loop.create_unix_server";
static const char __pyx_k_Loop_shutdown_asyncgens[] = "Loop.shutdown_asyncgens";
static const char __pyx_k_ReadSubprocessPipeProto[] = "ReadSubprocessPipeProto";
static const char __pyx_k_asyncgen_finalizer_hook[] = "_asyncgen_finalizer_hook";
static const char __pyx_k_asyncgen_firstiter_hook[] = "_asyncgen_firstiter_hook";
static const char __pyx_k_asyncio_future_blocking[] = "_asyncio_future_blocking";
static const char __pyx_k_connect_accepted_socket[] = "connect_accepted_socket";
static const char __pyx_k_service_proto_not_found[] = "service/proto not found";
static const char __pyx_k_uvloop_sleep_after_fork[] = "__uvloop_sleep_after_fork";
static const char __pyx_k_AF_UNSPEC_in_DNS_results[] = "AF_UNSPEC in DNS results";
static const char __pyx_k_Fatal_error_on_transport[] = "Fatal error on transport {}";
static const char __pyx_k_WriteSubprocessPipeProto[] = "WriteSubprocessPipeProto";
static const char __pyx_k_create_datagram_endpoint[] = "create_datagram_endpoint";
static const char __pyx_k_loop__exec_queued_writes[] = "loop._exec_queued_writes";
static const char __pyx_k_sig_must_be_an_int_not_r[] = "sig must be an int, not {!r}";
static const char __pyx_k_Read_EOF_failed_callbacks[] = "Read EOF failed callbacks: {}";
static const char __pyx_k_abort_init__closed_is_set[] = "_abort_init: {}._closed is set";
static const char __pyx_k_abort_init__inited_is_set[] = "_abort_init: {}._inited is set";
static const char __pyx_k_default_exception_handler[] = "default_exception_handler";
static const char __pyx_k_unexpected_address_family[] = "unexpected address family";
static const char __pyx_k_UVTransport__start_reading[] = "UVTransport._start_reading";
static const char __pyx_k_close__handle_data_is_NULL[] = "{}._close: _handle.data is NULL";
static const char __pyx_k_is_alive_but__loop_is_None[] = "{} is alive, but _loop is None";
static const char __pyx_k_Address_r_is_already_in_use[] = "Address {!r} is already in use";
static const char __pyx_k_Executing_r_took_3f_seconds[] = "Executing %r took %.3f seconds";
static const char __pyx_k_Loop_create_unix_connection[] = "Loop.create_unix_connection";
static const char __pyx_k_cancel_request_data_is_NULL[] = "{}.cancel: .request.data is NULL";
static const char __pyx_k_close_uv_is_closing_is_true[] = "{}._close: uv_is_closing() is true";
static const char __pyx_k_host_must_be_a_str_or_bytes[] = "host must be a str or bytes";
static const char __pyx_k_invalid__init_protocol_call[] = "invalid _init_protocol call";
static const char __pyx_k_not_holding_the_import_lock[] = "not holding the import lock";
static const char __pyx_k_Loop_connect_accepted_socket[] = "Loop.connect_accepted_socket";
static const char __pyx_k_UVHandles_python_libuv_total[] = "UVHandles python | libuv | total";
static const char __pyx_k_called_with_handle_data_NULL[] = "{} called with handle.data == NULL";
static const char __pyx_k_could_not_bind_to_local_addr[] = "could not bind to local_addr {}";
static const char __pyx_k_is_alive_but__handle_is_NULL[] = "{} is alive, but _handle is NULL";
static const char __pyx_k_set_running_or_notify_cancel[] = "set_running_or_notify_cancel";
static const char __pyx_k_startupinfo_is_not_supported[] = "startupinfo is not supported";
static const char __pyx_k_AF_INET_address_must_be_tuple[] = "AF_INET address must be tuple";
static const char __pyx_k_Handle_loop_is_None_in_Handle[] = "Handle.loop is None in Handle.__dealloc__";
static const char __pyx_k_IPv4_sockaddr_must_be_2_tuple[] = "IPv4 sockaddr must be 2 tuple";
static const char __pyx_k_Loop_create_datagram_endpoint[] = "Loop.create_datagram_endpoint";
static const char __pyx_k_all_args_must_be_str_or_bytes[] = "all args must be str or bytes";
static const char __pyx_k_could_not_bind_to_remote_addr[] = "could not bind to remote_addr {}";
static const char __pyx_k_dealloc____handle_is_NULL__cl[] = "{}.__dealloc__: _handle is NULL, _closed == 1";
static const char __pyx_k_integer_argument_expected_got[] = "integer argument expected, got {}";
static const char __pyx_k_protocol_pause_writing_failed[] = "protocol.pause_writing() failed";
static const char __pyx_k_r_fileno_returned_non_integer[] = "{!r}.fileno() returned non-integer";
static const char __pyx_k_start_init_can_only_be_called[] = "{}._start_init can only be called once";
static const char __pyx_k_AF_INET6_address_must_be_tuple[] = "AF_INET6 address must be tuple";
static const char __pyx_k_cannot_apply_subprocess_STDOUT[] = "cannot apply subprocess.STDOUT";
static const char __pyx_k_chain_future_locals__set_state[] = "_chain_future.._set_state";
static const char __pyx_k_close__handle_data_is_not_UVHa[] = "{}._close: _handle.data is not UVHandle/self";
static const char __pyx_k_creationflags_is_not_supported[] = "creationflags is not supported";
static const char __pyx_k_fatal_sent_0_in_advance_uv_buf[] = "fatal: sent < 0 in advance_uv_buf";
static const char __pyx_k_high_r_must_be_low_r_must_be_0[] = "high (%r) must be >= low (%r) must be >= 0";
static const char __pyx_k_invalid_stdin_argument_value_r[] = "invalid stdin argument value {!r}";
static const char __pyx_k_protocol_resume_writing_failed[] = "protocol.resume_writing() failed";
static const char __pyx_k_uv_close_handle_cb_handle_loop[] = "__uv_close_handle_cb: handle.loop is invalid";
static const char __pyx_k_AF_INET6_must_be_a_tuple_of_2_4[] = "AF_INET6 must be a tuple of 2-4 parameters: (host, port, flowinfo?, scope_id?)";
static const char __pyx_k_A_UDP_Socket_was_expected_got_r[] = "A UDP Socket was expected, got {!r}";
static const char __pyx_k_A_UNIX_Domain_Stream_Socket_was[] = "A UNIX Domain Stream Socket was expected, got {!r}";
static const char __pyx_k_A_future_is_required_for_source[] = "A future is required for source argument";
static const char __pyx_k_AddrInfoRequest_callback_called[] = "AddrInfoRequest callback called with NULL resolver.data";
static const char __pyx_k_Bad_exception_data_from_child_r[] = "Bad exception data from child: {!r}";
static const char __pyx_k_Cannot_run_the_event_loop_while[] = "Cannot run the event loop while another loop is running";
static const char __pyx_k_Invalid_address_must_be_None_or[] = "Invalid address: must be None or %s";
static const char __pyx_k_Neither_host_port_nor_sock_were[] = "Neither host/port nor sock were specified";
static const char __pyx_k_Sock_ops_successfull_on_1st_try[] = "--- Sock ops successfull on 1st try: ---";
static const char __pyx_k_StreamWriteContext_close_py_buf[] = "_StreamWriteContext.close: py_bufs != NULL and py_bufs_sml_inuse is True";
static const char __pyx_k_StreamWriteContext_close_uv_buf[] = "_StreamWriteContext.close: uv_bufs != NULL and py_bufs_sml_inuse is True";
static const char __pyx_k_Task_r_got_Future_r_attached_to[] = "Task {!r} got Future {!r} attached to a different loop";
static const char __pyx_k_UVStream__try_write_called_with[] = "UVStream._try_write called with data in uv buffers";
static const char __pyx_k_WriteSubprocessPipeProto___init[] = "WriteSubprocessPipeProto.__init__";
static const char __pyx_k_WriteSubprocessPipeProto___repr[] = "WriteSubprocessPipeProto.__repr__";
static const char __pyx_k_WriteSubprocessPipeProto_resume[] = "WriteSubprocessPipeProto.resume_writing";
static const char __pyx_k_buffer_size_is_not_0_after_a_su[] = "_buffer_size is not 0 after a successful _exec_write";
static const char __pyx_k_called_after_destroying_the_UVH[] = "{} called after destroying the UVHandle";
static const char __pyx_k_cancel_request_data_is_not_UVRe[] = "{}.cancel: .request.data is not UVRequest";
static const char __pyx_k_cannot_spawn_a_process_args_are[] = "cannot spawn a process: args are empty";
static const char __pyx_k_chain_future_locals__call_check[] = "_chain_future.._call_check_cancel";
static const char __pyx_k_chain_future_locals__call_set_s[] = "_chain_future.._call_set_state";
static const char __pyx_k_create_datagram_endpoint_locals[] = "create_datagram_endpoint..genexpr";
static const char __pyx_k_deallocating_an_open_event_loop[] = "deallocating an open event loop";
static const char __pyx_k_getaddrinfo_returned_empty_list[] = "getaddrinfo() returned empty list";
static const char __pyx_k_getsockaddrarg_flowinfo_must_be[] = "getsockaddrarg: flowinfo must be 0-1048575.";
static const char __pyx_k_getsockaddrarg_scope_id_must_be[] = "getsockaddrarg: scope_id must be unsigned 32 bit integer";
static const char __pyx_k_handle_loop_is_NULL_in___ensure[] = "handle.loop is NULL in __ensure_handle_data";
static const char __pyx_k_home_travis_build_MagicStack_uv[] = "/home/travis/build/MagicStack/uvloop/uvloop/loop.pyx";
static const char __pyx_k_host_and_port_was_not_specified[] = "host and port was not specified and no sock specified";
static const char __pyx_k_invalid_stderr_argument_value_r[] = "invalid stderr argument value {!r}";
static const char __pyx_k_invalid_stdout_argument_value_r[] = "invalid stdout argument value {!r}";
static const char __pyx_k_is_alive_but__handle_data_is_no[] = "{} is alive, but _handle.data is not initialized";
static const char __pyx_k_is_alive_but__handle_loop_is_no[] = "{} is alive, but _handle.loop is not initialized";
static const char __pyx_k_is_not_supposed_to_be_instantia[] = "{} is not supposed to be instantiated from Python";
static const char __pyx_k_is_open_in___dealloc___with_loo[] = "{} is open in __dealloc__ with loop set to NULL";
static const char __pyx_k_no_path_and_sock_were_specified[] = "no path and sock were specified";
static const char __pyx_k_port_must_be_a_str_bytes_or_int[] = "port must be a str, bytes or int";
static const char __pyx_k_protocol_is_not_set_cannot_call[] = "protocol is not set, cannot call connection_made()";
static const char __pyx_k_sockaddr_must_be_a_tuple_of_2_3[] = "sockaddr must be a tuple of 2, 3 or 4 values";
static const char __pyx_k_task_factory_must_be_a_callable[] = "task factory must be a callable or None";
static const char __pyx_k_the_socket_must_be_non_blocking[] = "the socket must be non-blocking";
static const char __pyx_k_try_write_sent_all_data_and_ret[] = "_try_write sent all data and returned non-zero";
static const char __pyx_k_unable_to_start_the_loop_it_was[] = "unable to start the loop; it was closed";
static const char __pyx_k_uv_handle_t_current_freed_total[] = "uv_handle_t (current: {}; freed: {}; total: {})";
static const char __pyx_k_uv_udp_receive_callback_addr_is[] = "uv_udp.receive callback: addr is NULL and nread >= 0";
static const char __pyx_k_without_no_gc_clear_loop_was_se[] = "{} without @no_gc_clear; loop was set to None by GC";
static const char __pyx_k_yield_was_used_instead_of_yield[] = "yield was used instead of yield from in task {!r} with {!r}";
static const char __pyx_k_AF_INET_address_must_be_tuple_of[] = "AF_INET address must be tuple of (host, port)";
static const char __pyx_k_A_Stream_Socket_was_expected_got[] = "A Stream Socket was expected, got {!r}";
static const char __pyx_k_A_callable_object_or_None_is_exp[] = "A callable object or None is expected, got {!r}";
static const char __pyx_k_A_future_is_required_for_destina[] = "A future is required for destination argument";
static const char __pyx_k_Cannot_call_write_after_write_eo[] = "Cannot call write() after write_eof()";
static const char __pyx_k_Cannot_call_writelines_after_wri[] = "Cannot call writelines() after write_eof()";
static const char __pyx_k_Cannot_close_a_running_event_loo[] = "Cannot close a running event loop";
static const char __pyx_k_Cannot_pause_reading_when_closin[] = "Cannot pause_reading() when closing";
static const char __pyx_k_Event_loop_stopped_before_Future[] = "Event loop stopped before Future completed.";
static const char __pyx_k_Exception_in___repr___r_value_ty[] = "Exception in __repr__ {!r}; value type: {!r}";
static const char __pyx_k_Exception_in_default_exception_h[] = "Exception in default exception handler";
static const char __pyx_k_Exception_occurred_in_preexec_fn[] = "Exception occurred in preexec_fn.";
static const char __pyx_k_Fatal_write_error_on_datagram_tr[] = "Fatal write error on datagram transport";
static const char __pyx_k_File_descriptor_r_is_used_by_tra[] = "File descriptor {!r} is used by transport {!r}";
static const char __pyx_k_Loop__getaddrinfo_locals_callbac[] = "Loop._getaddrinfo..callback";
static const char __pyx_k_Loop__getnameinfo_locals_callbac[] = "Loop._getnameinfo..callback";
static const char __pyx_k_Loop__sock_connect_locals_lambda[] = "Loop._sock_connect..";
static const char __pyx_k_Non_thread_safe_operation_invoke[] = "Non-thread-safe operation invoked on an event loop other than the current one";
static const char __pyx_k_Object_created_at_most_recent_ca[] = "Object created at (most recent call last):\n";
static const char __pyx_k_Racing_with_another_loop_to_spaw[] = "Racing with another loop to spawn a process.";
static const char __pyx_k_ReadSubprocessPipeProto_data_rec[] = "ReadSubprocessPipeProto.data_received";
static const char __pyx_k_StopIteration_interacts_badly_wi[] = "StopIteration interacts badly with generators and cannot be raised into a Future";
static const char __pyx_k_UDPTransport_family_is_undefined[] = "UDPTransport.family is undefined; cannot create python socket";
static const char __pyx_k_UVProcessTransport__call_connect[] = "UVProcessTransport._call_connection_made";
static const char __pyx_k_UVProcess__close_after_spawn_cal[] = "UVProcess._close_after_spawn called after uv_spawn";
static const char __pyx_k_UVStream_shutdown_callback_calle[] = "UVStream.shutdown callback called with NULL req.data, status=%r";
static const char __pyx_k_UVStream_write_callback_called_w[] = "UVStream.write callback called with NULL req.data, status=%r";
static const char __pyx_k_UVTransport__call_connection_los[] = "UVTransport._call_connection_lost";
static const char __pyx_k_UVTransport__call_connection_mad[] = "UVTransport._call_connection_made";
static const char __pyx_k_Unable_to_deallocate_request_for[] = "Unable to deallocate request for {!r} (not done)";
static const char __pyx_k_Unhandled_error_in_exception_han[] = "Unhandled error in exception handler";
static const char __pyx_k_Unhandled_exception_in_event_loo[] = "Unhandled exception in event loop";
static const char __pyx_k_WriteSubprocessPipeProto_connect[] = "WriteSubprocessPipeProto.connection_made";
static const char __pyx_k_WriteSubprocessPipeProto_pause_w[] = "WriteSubprocessPipeProto.pause_writing";
static const char __pyx_k_You_must_set_server_hostname_whe[] = "You must set server_hostname when using ssl without a host";
static const char __pyx_k_active_TimerHandle_is_deallacati[] = "active TimerHandle is deallacating";
static const char __pyx_k_all_environment_values_must_be_b[] = "all environment values must be bytes or str";
static const char __pyx_k_all_environment_vars_must_be_byt[] = "all environment vars must be bytes or str";
static const char __pyx_k_an_error_occurred_during_closing[] = "an error occurred during closing of asynchronous generator {!r}";
static const char __pyx_k_asynchronous_generator_r_was_sch[] = "asynchronous generator {!r} was scheduled after loop.shutdown_asyncgens() call";
static const char __pyx_k_cannot_convert_sockaddr_into_Pyt[] = "cannot convert sockaddr into Python object";
static const char __pyx_k_cannot_open_a_UDP_handle_invalid[] = "cannot open a UDP handle, invalid family {}";
static const char __pyx_k_concurrent_futures_Future_is_exp[] = "concurrent.futures.Future is expected, got {!r}";
static const char __pyx_k_coroutines_cannot_be_used_with_a[] = "coroutines cannot be used with add_signal_handler()";
static const char __pyx_k_coroutines_cannot_be_used_with_r[] = "coroutines cannot be used with run_in_executor()";
static const char __pyx_k_could_not_close_attached_file_ob[] = "could not close attached file object {!r}";
static const char __pyx_k_create_connection_locals_genexpr[] = "create_connection..genexpr";
static const char __pyx_k_cwd_must_be_a_str_or_bytes_objec[] = "cwd must be a str or bytes object";
static const char __pyx_k_deallocating_a_running_event_loo[] = "deallocating a running event loop!";
static const char __pyx_k_epected_AF_INET_or_AF_INET6_fami[] = "epected AF_INET or AF_INET6 family, got {}";
static const char __pyx_k_error_status_in_uv_stream_t_list[] = "error status in uv_stream_t.listen callback";
static const char __pyx_k_error_status_in_uv_stream_t_read[] = "error status in uv_stream_t.read callback";
static const char __pyx_k_error_status_in_uv_stream_t_shut[] = "error status in uv_stream_t.shutdown callback";
static const char __pyx_k_error_status_in_uv_stream_t_writ[] = "error status in uv_stream_t.write callback";
static const char __pyx_k_error_while_attempting_to_bind_o[] = "error while attempting to bind on address %r: %s";
static const char __pyx_k_fatal_Could_not_advance__StreamW[] = "fatal: Could not advance _StreamWriteContext";
static const char __pyx_k_getnameinfo_argument_1_must_be_a[] = "getnameinfo() argument 1 must be a tuple";
static const char __pyx_k_handle_data_is_NULL_in___close_a[] = "handle.data is NULL in __close_all_handles_cb";
static const char __pyx_k_handle_loop_data_is_NULL_in___en[] = "handle.loop.data is NULL in __ensure_handle_data";
static const char __pyx_k_host_must_be_a_string_or_bytes_o[] = "host must be a string or bytes object";
static const char __pyx_k_host_port_and_sock_can_not_be_sp[] = "host/port and sock can not be specified at the same time";
static const char __pyx_k_invalid_data_in_writebuf_an_inst[] = "invalid data in writebuf: an instance of bytes, bytearray or memoryview was expected, got {}";
static const char __pyx_k_invalid_socket_family_expected_A[] = "invalid socket family, expected AF_UNIX, AF_INET or AF_INET6";
static const char __pyx_k_invalid_waiter_object_r_expected[] = "invalid waiter object {!r}, expected asyncio.Future";
static const char __pyx_k_local_addr_must_be_a_tuple_of_ho[] = "local_addr must be a tuple of host and port";
static const char __pyx_k_loop__queued_streams_are_not_emp[] = "loop._queued_streams are not empty after _exec_queued_writes";
static const char __pyx_k_loop_set_debug_False_cannot_unse[] = "loop.set_debug(False): cannot unset debug coroutine wrapper; another wrapper was set %r";
static const char __pyx_k_loop_set_debug_True_cannot_set_d[] = "loop.set_debug(True): cannot set debug coroutine wrapper; another wrapper is already set %r";
static const char __pyx_k_new_callbacks_were_queued_during[] = "new callbacks were queued during loop closing: {}";
static const char __pyx_k_new_poll_handles_were_queued_dur[] = "new poll handles were queued during loop closing: {}";
static const char __pyx_k_new_timers_were_queued_during_lo[] = "new timers were queued during loop closing: {}";
static const char __pyx_k_object_created_at_most_recent_ca[] = "object created at (most recent call last):\n{}";
static const char __pyx_k_open__StreamWriteContext_is_bein[] = "open _StreamWriteContext is being deallocated";
static const char __pyx_k_open__UDPSendContext_is_being_de[] = "open _UDPSendContext is being deallocated";
static const char __pyx_k_path_and_sock_can_not_be_specifi[] = "path and sock can not be specified at the same time";
static const char __pyx_k_path_was_not_specified_and_no_so[] = "path was not specified, and no sock specified";
static const char __pyx_k_remote_addr_must_be_a_tuple_of_h[] = "remote_addr must be a tuple of (host, port)";
static const char __pyx_k_reuse_port_not_supported_by_sock[] = "reuse_port not supported by socket module";
static const char __pyx_k_run_until_complete_locals_lambda[] = "run_until_complete..";
static const char __pyx_k_server_hostname_is_only_meaningf[] = "server_hostname is only meaningful with ssl";
static const char __pyx_k_set_wakeup_fd_only_works_in_main[] = "set_wakeup_fd only works in main thread";
static const char __pyx_k_sockaddr_resolved_to_multiple_ad[] = "sockaddr resolved to multiple addresses";
static const char __pyx_k_socket_modifier_keyword_argument[] = "socket modifier keyword arguments can not be used when sock is specified. ({})";
static const char __pyx_k_ssl_argument_must_be_an_SSLConte[] = "ssl argument must be an SSLContext or None";
static const char __pyx_k_ssl_is_expected_to_be_None_or_an[] = "ssl is expected to be None or an instance of ssl.SSLContext, got {!r}";
static const char __pyx_k_stream_is_open_after_UVStream__t[] = "stream is open after UVStream._try_write returned None";
static const char __pyx_k_subprocess_STDOUT_is_supported_o[] = "subprocess.STDOUT is supported only by stderr parameter";
static const char __pyx_k_this_event_loop_is_already_runni[] = "this event loop is already running.";
static const char __pyx_k_unable_to_listen_no_protocol_fac[] = "unable to listen(); no protocol_factory";
static const char __pyx_k_unable_to_perform_operation_on_r[] = "unable to perform operation on {!r}; the handler is closed";
static const char __pyx_k_unable_to_perform_send_operation[] = "unable to perform send operation: no address";
static const char __pyx_k_universal_newlines_must_be_False[] = "universal_newlines must be False";
static const char __pyx_k_uvloop_Future_supports_only_uvlo[] = "uvloop.Future supports only uvloop.Loop";
static const char __pyx_k_waiter_is_not_None_in__call_conn[] = "waiter is not None in {}._call_connection_lost";
static const char __pyx_k_yield_from_wasn_t_used_with_futu[] = "yield from wasn't used with future";
static const char __pyx_k_getaddrinfo_returned_empty_list_2[] = "getaddrinfo() returned empty list for local_addr";
static const char __pyx_k_home_travis_build_MagicStack_uv_2[] = "/home/travis/build/MagicStack/uvloop/uvloop/chain_futs.pyx";
static const char __pyx_k_home_travis_build_MagicStack_uv_3[] = "/home/travis/build/MagicStack/uvloop/uvloop/handles/process.pyx";
static const char __pyx_k_yield_was_used_instead_of_yield_2[] = "yield was used instead of yield from for generator in task {!r} with {}";
static const char __pyx_k_Exception_in_default_exception_h_2[] = "Exception in default exception handler while handling an unexpected error in custom exception handler";
static const char __pyx_k_UDPTransport_family_is_undefined_2[] = "UDPTransport.family is undefined; cannot send";
static const char __pyx_k_WriteSubprocessPipeProto_connect_2[] = "WriteSubprocessPipeProto.connection_lost";
static const char __pyx_k_local_addr_must_be_a_tuple_of_ho_2[] = "local_addr must be a tuple of (host, port)";
static PyObject *__pyx_kp_u_0_0_0_0;
static PyObject *__pyx_kp_u_18_7_7_7;
static PyObject *__pyx_kp_u_AF_INET6_address_must_be_tuple;
static PyObject *__pyx_kp_u_AF_INET6_must_be_a_tuple_of_2_4;
static PyObject *__pyx_kp_u_AF_INET_address_must_be_tuple;
static PyObject *__pyx_kp_u_AF_INET_address_must_be_tuple_of;
static PyObject *__pyx_kp_u_AF_UNSPEC_in_DNS_results;
static PyObject *__pyx_kp_u_A_Stream_Socket_was_expected_got;
static PyObject *__pyx_kp_u_A_UDP_Socket_was_expected_got_r;
static PyObject *__pyx_kp_u_A_UNIX_Domain_Stream_Socket_was;
static PyObject *__pyx_kp_u_A_callable_object_or_None_is_exp;
static PyObject *__pyx_kp_u_A_future_is_required_for_destina;
static PyObject *__pyx_kp_u_A_future_is_required_for_source;
static PyObject *__pyx_kp_u_AddrInfoRequest_callback_called;
static PyObject *__pyx_kp_u_AddrInfo_data_is_NULL;
static PyObject *__pyx_kp_u_Address_r_is_already_in_use;
static PyObject *__pyx_kp_u_Already_paused;
static PyObject *__pyx_n_s_AssertionError;
static PyObject *__pyx_n_s_AttributeError;
static PyObject *__pyx_kp_u_Bad_exception_data_from_child_r;
static PyObject *__pyx_n_s_BaseException;
static PyObject *__pyx_n_s_BaseFuture___await;
static PyObject *__pyx_n_s_BaseFuture___iter;
static PyObject *__pyx_n_s_BaseProtocol;
static PyObject *__pyx_n_s_BlockingIOError;
static PyObject *__pyx_n_s_BrokenPipeError;
static PyObject *__pyx_n_u_CANCELLED;
static PyObject *__pyx_kp_u_Callback_handles_8;
static PyObject *__pyx_n_s_CancelledError;
static PyObject *__pyx_kp_u_Cannot_call_write_after_write_eo;
static PyObject *__pyx_kp_u_Cannot_call_writelines_after_wri;
static PyObject *__pyx_kp_u_Cannot_close_a_running_event_loo;
static PyObject *__pyx_kp_u_Cannot_pause_reading_when_closin;
static PyObject *__pyx_kp_u_Cannot_run_the_event_loop_while;
static PyObject *__pyx_kp_u_Connect_call_failed_s;
static PyObject *__pyx_n_s_ConnectionAbortedError;
static PyObject *__pyx_n_s_ConnectionRefusedError;
static PyObject *__pyx_n_s_ConnectionResetError;
static PyObject *__pyx_n_s_Counter;
static PyObject *__pyx_n_s_DEVNULL;
static PyObject *__pyx_n_u_EAI_ADDRFAMILY;
static PyObject *__pyx_n_u_EAI_AGAIN;
static PyObject *__pyx_n_u_EAI_BADFLAGS;
static PyObject *__pyx_n_u_EAI_BADHINTS;
static PyObject *__pyx_n_u_EAI_CANCELED;
static PyObject *__pyx_n_u_EAI_FAIL;
static PyObject *__pyx_n_u_EAI_FAMILY;
static PyObject *__pyx_n_u_EAI_MEMORY;
static PyObject *__pyx_n_u_EAI_NODATA;
static PyObject *__pyx_n_u_EAI_NONAME;
static PyObject *__pyx_n_u_EAI_OVERFLOW;
static PyObject *__pyx_n_u_EAI_PROTOCOL;
static PyObject *__pyx_n_u_EAI_SERVICE;
static PyObject *__pyx_n_u_EAI_SOCKTYPE;
static PyObject *__pyx_kp_u_Errors_logged;
static PyObject *__pyx_kp_u_Event_loop_is_closed;
static PyObject *__pyx_kp_u_Event_loop_stopped_before_Future;
static PyObject *__pyx_kp_u_Exception_in___repr___r_value_ty;
static PyObject *__pyx_kp_u_Exception_in_callback;
static PyObject *__pyx_kp_u_Exception_in_default_exception_h;
static PyObject *__pyx_kp_u_Exception_in_default_exception_h_2;
static PyObject *__pyx_kp_u_Exception_is_not_set;
static PyObject *__pyx_kp_u_Exception_occurred_in_preexec_fn;
static PyObject *__pyx_kp_u_Executing_r_took_3f_seconds;
static PyObject *__pyx_n_u_FINISHED;
static PyObject *__pyx_kp_u_Fatal_error_on_server;
static PyObject *__pyx_kp_u_Fatal_error_on_transport;
static PyObject *__pyx_kp_u_Fatal_write_error_on_datagram_tr;
static PyObject *__pyx_n_s_FileExistsError;
static PyObject *__pyx_n_s_FileNotFoundError;
static PyObject *__pyx_kp_u_File_descriptor_r_is_used_by_tra;
static PyObject *__pyx_n_s_Future;
static PyObject *__pyx_kp_u_Handle_loop_is_None_in_Handle;
static PyObject *__pyx_kp_u_IPv4_sockaddr_must_be_2_tuple;
static PyObject *__pyx_n_s_InterruptedError;
static PyObject *__pyx_n_s_InvalidStateError;
static PyObject *__pyx_kp_u_Invalid_address_must_be_None_or;
static PyObject *__pyx_n_s_IsADirectoryError;
static PyObject *__pyx_n_s_Iterable;
static PyObject *__pyx_n_s_KeyError;
static PyObject *__pyx_kp_u_Listen_errors;
static PyObject *__pyx_n_s_LookupError;
static PyObject *__pyx_n_s_Loop___subprocess_run;
static PyObject *__pyx_n_s_Loop__getaddrinfo_locals_callbac;
static PyObject *__pyx_n_s_Loop__getnameinfo_locals_callbac;
static PyObject *__pyx_kp_u_Loop__read_from_self;
static PyObject *__pyx_kp_u_Loop__sock_accept;
static PyObject *__pyx_kp_u_Loop__sock_connect;
static PyObject *__pyx_n_s_Loop__sock_connect_locals_lambda;
static PyObject *__pyx_kp_u_Loop__sock_recv;
static PyObject *__pyx_kp_u_Loop__sock_sendall;
static PyObject *__pyx_kp_u_Loop__stop;
static PyObject *__pyx_n_s_Loop_connect_accepted_socket;
static PyObject *__pyx_n_s_Loop_connect_read_pipe;
static PyObject *__pyx_n_s_Loop_connect_write_pipe;
static PyObject *__pyx_n_s_Loop_create_connection;
static PyObject *__pyx_n_s_Loop_create_datagram_endpoint;
static PyObject *__pyx_n_s_Loop_create_server;
static PyObject *__pyx_n_s_Loop_create_unix_connection;
static PyObject *__pyx_n_s_Loop_create_unix_server;
static PyObject *__pyx_kp_u_Loop_debug_info;
static PyObject *__pyx_n_s_Loop_getnameinfo;
static PyObject *__pyx_n_s_Loop_shutdown_asyncgens;
static PyObject *__pyx_n_s_Loop_sock_connect;
static PyObject *__pyx_n_s_Loop_sock_sendall;
static PyObject *__pyx_kp_u_Loop_time;
static PyObject *__pyx_n_s_MemoryError;
static PyObject *__pyx_kp_u_Multiple_exceptions;
static PyObject *__pyx_n_s_NSIG;
static PyObject *__pyx_kp_u_Neither_host_port_nor_sock_were;
static PyObject *__pyx_kp_u_Non_thread_safe_operation_invoke;
static PyObject *__pyx_n_s_NotImplementedError;
static PyObject *__pyx_kp_u_Not_paused;
static PyObject *__pyx_kp_u_Number_of_signals;
static PyObject *__pyx_n_s_OSError;
static PyObject *__pyx_n_s_O_RDWR;
static PyObject *__pyx_kp_u_Object_created_at_most_recent_ca;
static PyObject *__pyx_n_s_OverflowError;
static PyObject *__pyx_n_u_PENDING;
static PyObject *__pyx_n_s_PIPE;
static PyObject *__pyx_n_u_PYTHONASYNCIODEBUG;
static PyObject *__pyx_n_s_PermissionError;
static PyObject *__pyx_kp_u_Polls_debug_info;
static PyObject *__pyx_n_s_ProcessLookupError;
static PyObject *__pyx_kp_u_Process_info;
static PyObject *__pyx_kp_u_Process_memory;
static PyObject *__pyx_n_s_Protocol;
static PyObject *__pyx_kp_u_Racing_with_another_loop_to_spaw;
static PyObject *__pyx_n_s_ReadSubprocessPipeProto;
static PyObject *__pyx_n_s_ReadSubprocessPipeProto_data_rec;
static PyObject *__pyx_kp_u_Read_EOF_failed_callbacks;
static PyObject *__pyx_kp_u_Read_EOFs;
static PyObject *__pyx_kp_u_Read_callbacks;
static PyObject *__pyx_kp_u_Read_callbacks_failed;
static PyObject *__pyx_kp_u_Read_errors;
static PyObject *__pyx_kp_u_Read_events;
static PyObject *__pyx_kp_u_Read_failed_callbacks;
static PyObject *__pyx_n_s_ResourceWarning;
static PyObject *__pyx_kp_u_Result_is_not_ready;
static PyObject *__pyx_n_s_RuntimeError;
static PyObject *__pyx_n_s_RuntimeWarning;
static PyObject *__pyx_n_s_SIG_DFL;
static PyObject *__pyx_n_u_SO_REUSEPORT;
static PyObject *__pyx_n_s_SSLContext;
static PyObject *__pyx_n_s_SSLProtocol;
static PyObject *__pyx_n_s_STDOUT;
static PyObject *__pyx_n_s_Server_wait_closed;
static PyObject *__pyx_kp_u_Shutdown_errors;
static PyObject *__pyx_kp_u_Sock_ops_successfull_on_1st_try;
static PyObject *__pyx_kp_u_Socket_try_writes;
static PyObject *__pyx_n_s_StopIteration;
static PyObject *__pyx_kp_u_StopIteration_interacts_badly_wi;
static PyObject *__pyx_kp_u_StreamWriteContext_close_py_buf;
static PyObject *__pyx_kp_u_StreamWriteContext_close_uv_buf;
static PyObject *__pyx_kp_u_Streams_debug_info;
static PyObject *__pyx_n_s_SubprocessError;
static PyObject *__pyx_n_s_Task;
static PyObject *__pyx_kp_u_Task__step;
static PyObject *__pyx_kp_u_Task_got_bad_yield_r;
static PyObject *__pyx_kp_u_Task_r_got_Future_r_attached_to;
static PyObject *__pyx_n_s_ThreadPoolExecutor;
static PyObject *__pyx_n_s_TimeoutError;
static PyObject *__pyx_kp_u_Timer_handles_8;
static PyObject *__pyx_n_s_TypeError;
static PyObject *__pyx_kp_u_UDPTransport_family_is_undefined;
static PyObject *__pyx_kp_u_UDPTransport_family_is_undefined_2;
static PyObject *__pyx_kp_u_UVHandles_python_libuv_total;
static PyObject *__pyx_kp_u_UVProcessTransport__call_connect;
static PyObject *__pyx_kp_u_UVProcess__close_after_spawn_cal;
static PyObject *__pyx_kp_u_UVStream__try_write_called_with;
static PyObject *__pyx_kp_u_UVStream_shutdown_callback_calle;
static PyObject *__pyx_kp_u_UVStream_write_callback_called_w;
static PyObject *__pyx_kp_u_UVTransport__call_connection_los;
static PyObject *__pyx_kp_u_UVTransport__call_connection_mad;
static PyObject *__pyx_kp_u_UVTransport__start_reading;
static PyObject *__pyx_kp_u_Unable_to_deallocate_request_for;
static PyObject *__pyx_kp_u_Unhandled_error_in_exception_han;
static PyObject *__pyx_kp_u_Unhandled_exception_in_event_loo;
static PyObject *__pyx_n_s_ValueError;
static PyObject *__pyx_n_s_WeakSet;
static PyObject *__pyx_n_s_WeakValueDictionary;
static PyObject *__pyx_n_s_WriteSubprocessPipeProto;
static PyObject *__pyx_n_s_WriteSubprocessPipeProto___init;
static PyObject *__pyx_n_s_WriteSubprocessPipeProto___repr;
static PyObject *__pyx_n_s_WriteSubprocessPipeProto_connect;
static PyObject *__pyx_n_s_WriteSubprocessPipeProto_connect_2;
static PyObject *__pyx_n_s_WriteSubprocessPipeProto_pause_w;
static PyObject *__pyx_n_s_WriteSubprocessPipeProto_resume;
static PyObject *__pyx_kp_u_Write_callbacks_failed;
static PyObject *__pyx_kp_u_Write_contexts_8;
static PyObject *__pyx_kp_u_Write_errors;
static PyObject *__pyx_kp_u_Write_events;
static PyObject *__pyx_kp_u_Write_failed_callbacks;
static PyObject *__pyx_kp_u_Write_without_poll;
static PyObject *__pyx_kp_u_You_must_set_server_hostname_whe;
static PyObject *__pyx_kp_u__108;
static PyObject *__pyx_kp_u__109;
static PyObject *__pyx_kp_u__110;
static PyObject *__pyx_kp_u__117;
static PyObject *__pyx_kp_b__143;
static PyObject *__pyx_kp_b__154;
static PyObject *__pyx_n_s__30;
static PyObject *__pyx_kp_b__30;
static PyObject *__pyx_kp_u__30;
static PyObject *__pyx_kp_u__36;
static PyObject *__pyx_kp_u__64;
static PyObject *__pyx_kp_u__75;
static PyObject *__pyx_kp_u__76;
static PyObject *__pyx_kp_u__97;
static PyObject *__pyx_kp_u_abort_init__closed_is_set;
static PyObject *__pyx_kp_u_abort_init__inited_is_set;
static PyObject *__pyx_n_s_accept;
static PyObject *__pyx_n_s_aclose;
static PyObject *__pyx_kp_u_active_TimerHandle_is_deallacati;
static PyObject *__pyx_n_s_add;
static PyObject *__pyx_n_s_add_done_callback;
static PyObject *__pyx_n_s_addr;
static PyObject *__pyx_n_s_address;
static PyObject *__pyx_kp_u_alive_closed;
static PyObject *__pyx_kp_u_all_args_must_be_str_or_bytes;
static PyObject *__pyx_kp_u_all_environment_values_must_be_b;
static PyObject *__pyx_kp_u_all_environment_vars_must_be_byt;
static PyObject *__pyx_n_s_all_tasks;
static PyObject *__pyx_n_s_allow_broadcast;
static PyObject *__pyx_kp_u_an_error_occurred_during_closing;
static PyObject *__pyx_n_s_app_transport;
static PyObject *__pyx_n_s_append;
static PyObject *__pyx_n_s_args;
static PyObject *__pyx_n_u_asyncgen;
static PyObject *__pyx_n_s_asyncgen_finalizer_hook;
static PyObject *__pyx_n_s_asyncgen_firstiter_hook;
static PyObject *__pyx_kp_u_asynchronous_generator_r_was_sch;
static PyObject *__pyx_n_s_asyncio;
static PyObject *__pyx_n_s_asyncio_base_events;
static PyObject *__pyx_n_s_asyncio_coroutines;
static PyObject *__pyx_n_s_asyncio_future_blocking;
static PyObject *__pyx_n_s_asyncio_futures;
static PyObject *__pyx_n_s_asyncio_log;
static PyObject *__pyx_n_s_asyncio_sslproto;
static PyObject *__pyx_n_s_asyncio_tasks;
static PyObject *__pyx_n_s_await;
static PyObject *__pyx_n_u_b;
static PyObject *__pyx_n_s_backlog;
static PyObject *__pyx_kp_b_bin_sh;
static PyObject *__pyx_n_s_bind;
static PyObject *__pyx_n_s_blocking;
static PyObject *__pyx_kp_u_buffer_size_is_not_0_after_a_su;
static PyObject *__pyx_n_s_bufsize;
static PyObject *__pyx_kp_u_bufsize_must_be_0;
static PyObject *__pyx_n_s_builtins;
static PyObject *__pyx_kp_b_c;
static PyObject *__pyx_n_s_call_check_cancel;
static PyObject *__pyx_n_s_call_exception_handler;
static PyObject *__pyx_n_s_call_later;
static PyObject *__pyx_n_s_call_set_state;
static PyObject *__pyx_n_s_call_soon;
static PyObject *__pyx_n_s_call_soon_threadsafe;
static PyObject *__pyx_n_s_callback;
static PyObject *__pyx_kp_u_called_after_destroying_the_UVH;
static PyObject *__pyx_kp_u_called_with_handle_data_NULL;
static PyObject *__pyx_n_s_cancel;
static PyObject *__pyx_kp_u_cancel_request_data_is_NULL;
static PyObject *__pyx_kp_u_cancel_request_data_is_not_UVRe;
static PyObject *__pyx_kp_u_cancel_request_is_NULL;
static PyObject *__pyx_n_s_cancelled;
static PyObject *__pyx_n_u_cancelled;
static PyObject *__pyx_kp_u_cannot_apply_subprocess_STDOUT;
static PyObject *__pyx_kp_u_cannot_convert_sockaddr_into_Pyt;
static PyObject *__pyx_kp_u_cannot_open_a_UDP_handle_invalid;
static PyObject *__pyx_kp_u_cannot_spawn_a_process_args_are;
static PyObject *__pyx_n_s_cast;
static PyObject *__pyx_n_s_cause;
static PyObject *__pyx_n_s_chain;
static PyObject *__pyx_n_s_chain_future_locals__call_check;
static PyObject *__pyx_n_s_chain_future_locals__call_set_s;
static PyObject *__pyx_n_s_chain_future_locals__set_state;
static PyObject *__pyx_n_s_class;
static PyObject *__pyx_n_s_clear;
static PyObject *__pyx_n_s_close;
static PyObject *__pyx_kp_u_close__handle_data_is_NULL;
static PyObject *__pyx_kp_u_close__handle_data_is_not_UVHa;
static PyObject *__pyx_n_s_close_fds;
static PyObject *__pyx_kp_u_close_uv_is_closing_is_true;
static PyObject *__pyx_kp_u_closed_reading_x;
static PyObject *__pyx_kp_u_closed_x;
static PyObject *__pyx_n_s_cmd;
static PyObject *__pyx_n_s_collections;
static PyObject *__pyx_n_s_concurrent;
static PyObject *__pyx_kp_u_concurrent_allocations;
static PyObject *__pyx_n_s_concurrent_futures;
static PyObject *__pyx_kp_u_concurrent_futures_Future_is_exp;
static PyObject *__pyx_n_s_connect;
static PyObject *__pyx_n_s_connect_accepted_socket;
static PyObject *__pyx_kp_u_connect_failed;
static PyObject *__pyx_n_s_connect_read_pipe;
static PyObject *__pyx_n_s_connect_write_pipe;
static PyObject *__pyx_n_s_connection_lost;
static PyObject *__pyx_n_s_connection_made;
static PyObject *__pyx_n_u_context;
static PyObject *__pyx_n_s_copy;
static PyObject *__pyx_n_s_coro;
static PyObject *__pyx_n_s_coroutines;
static PyObject *__pyx_kp_u_coroutines_cannot_be_used_with_a;
static PyObject *__pyx_kp_u_coroutines_cannot_be_used_with_r;
static PyObject *__pyx_kp_u_could_not_bind_to_local_addr;
static PyObject *__pyx_kp_u_could_not_bind_to_remote_addr;
static PyObject *__pyx_kp_u_could_not_close_attached_file_ob;
static PyObject *__pyx_n_s_create_connection;
static PyObject *__pyx_n_s_create_connection_locals_genexpr;
static PyObject *__pyx_n_s_create_datagram_endpoint;
static PyObject *__pyx_n_s_create_datagram_endpoint_locals;
static PyObject *__pyx_n_s_create_future;
static PyObject *__pyx_n_s_create_server;
static PyObject *__pyx_n_s_create_task;
static PyObject *__pyx_n_s_create_unix_connection;
static PyObject *__pyx_n_s_create_unix_server;
static PyObject *__pyx_kp_u_created_at;
static PyObject *__pyx_n_s_creationflags;
static PyObject *__pyx_kp_u_creationflags_is_not_supported;
static PyObject *__pyx_n_s_current_tasks;
static PyObject *__pyx_n_s_cwd;
static PyObject *__pyx_kp_u_cwd_must_be_a_str_or_bytes_objec;
static PyObject *__pyx_n_s_data;
static PyObject *__pyx_n_s_data_received;
static PyObject *__pyx_n_s_datagram_received;
static PyObject *__pyx_kp_u_dealloc____handle_is_NULL__cl;
static PyObject *__pyx_kp_u_deallocating_a_running_event_loo;
static PyObject *__pyx_kp_u_deallocating_an_open_event_loop;
static PyObject *__pyx_n_s_debug_wrapper;
static PyObject *__pyx_n_s_decode;
static PyObject *__pyx_n_s_default;
static PyObject *__pyx_n_s_default_exception_handler;
static PyObject *__pyx_n_s_default_int_handler;
static PyObject *__pyx_n_s_delay;
static PyObject *__pyx_n_s_deque;
static PyObject *__pyx_n_s_destination;
static PyObject *__pyx_n_s_detach;
static PyObject *__pyx_n_s_devnull;
static PyObject *__pyx_n_s_disable;
static PyObject *__pyx_n_s_discard;
static PyObject *__pyx_n_s_disconnected;
static PyObject *__pyx_n_s_doc;
static PyObject *__pyx_n_s_done;
static PyObject *__pyx_n_s_dup;
static PyObject *__pyx_n_s_encode;
static PyObject *__pyx_n_s_ensure_future;
static PyObject *__pyx_n_s_enter;
static PyObject *__pyx_n_s_env;
static PyObject *__pyx_n_s_environ;
static PyObject *__pyx_n_s_eof_received;
static PyObject *__pyx_kp_u_epected_AF_INET_or_AF_INET6_fami;
static PyObject *__pyx_n_s_errno;
static PyObject *__pyx_n_s_error;
static PyObject *__pyx_n_s_error_received;
static PyObject *__pyx_kp_u_error_status_in_uv_stream_t_list;
static PyObject *__pyx_kp_u_error_status_in_uv_stream_t_read;
static PyObject *__pyx_kp_u_error_status_in_uv_stream_t_shut;
static PyObject *__pyx_kp_u_error_status_in_uv_stream_t_writ;
static PyObject *__pyx_kp_u_error_while_attempting_to_bind_o;
static PyObject *__pyx_n_s_ex;
static PyObject *__pyx_n_s_exc;
static PyObject *__pyx_n_s_exc_info;
static PyObject *__pyx_n_s_exception;
static PyObject *__pyx_n_u_exception;
static PyObject *__pyx_n_s_executable;
static PyObject *__pyx_n_s_executor;
static PyObject *__pyx_n_s_exit;
static PyObject *__pyx_n_s_extract_stack;
static PyObject *__pyx_n_s_family;
static PyObject *__pyx_kp_u_fatal_Could_not_advance__StreamW;
static PyObject *__pyx_kp_u_fatal_sent_0_in_advance_uv_buf;
static PyObject *__pyx_n_s_fd;
static PyObject *__pyx_n_s_fileno;
static PyObject *__pyx_n_s_finalizer;
static PyObject *__pyx_n_s_firstiter;
static PyObject *__pyx_n_s_flags;
static PyObject *__pyx_n_s_flush;
static PyObject *__pyx_n_s_force_close;
static PyObject *__pyx_n_s_format;
static PyObject *__pyx_n_s_format_list;
static PyObject *__pyx_n_s_frame;
static PyObject *__pyx_n_s_func;
static PyObject *__pyx_n_s_functools;
static PyObject *__pyx_n_s_fut;
static PyObject *__pyx_n_s_future;
static PyObject *__pyx_n_s_futures;
static PyObject *__pyx_n_s_gaierror;
static PyObject *__pyx_n_s_gather;
static PyObject *__pyx_n_s_gc;
static PyObject *__pyx_n_s_genexpr;
static PyObject *__pyx_n_s_get;
static PyObject *__pyx_n_s_get_asyncgen_hooks;
static PyObject *__pyx_n_u_get_asyncgen_hooks;
static PyObject *__pyx_n_s_get_coroutine_wrapper;
static PyObject *__pyx_n_s_get_debug;
static PyObject *__pyx_n_s_get_event_loop;
static PyObject *__pyx_n_s_get_extra_info;
static PyObject *__pyx_n_s_get_inheritable;
static PyObject *__pyx_n_u_get_running_loop;
static PyObject *__pyx_n_s_getaddrinfo;
static PyObject *__pyx_kp_u_getaddrinfo_returned_empty_list;
static PyObject *__pyx_kp_u_getaddrinfo_returned_empty_list_2;
static PyObject *__pyx_n_s_getframe;
static PyObject *__pyx_n_s_getnameinfo;
static PyObject *__pyx_kp_u_getnameinfo_argument_1_must_be_a;
static PyObject *__pyx_n_s_getpeername;
static PyObject *__pyx_n_s_getservbyname;
static PyObject *__pyx_kp_u_getsockaddrarg_flowinfo_must_be;
static PyObject *__pyx_kp_u_getsockaddrarg_scope_id_must_be;
static PyObject *__pyx_n_s_getsockname;
static PyObject *__pyx_n_s_getsockopt;
static PyObject *__pyx_n_s_gettimeout;
static PyObject *__pyx_n_u_handle;
static PyObject *__pyx_kp_u_handle_data_is_NULL_in___close_a;
static PyObject *__pyx_kp_u_handle_loop_data_is_NULL_in___en;
static PyObject *__pyx_kp_u_handle_loop_is_NULL_in___ensure;
static PyObject *__pyx_n_s_high;
static PyObject *__pyx_kp_u_high_r_must_be_low_r_must_be_0;
static PyObject *__pyx_kp_s_home_travis_build_MagicStack_uv;
static PyObject *__pyx_kp_s_home_travis_build_MagicStack_uv_2;
static PyObject *__pyx_kp_s_home_travis_build_MagicStack_uv_3;
static PyObject *__pyx_n_s_host;
static PyObject *__pyx_kp_u_host_and_port_was_not_specified;
static PyObject *__pyx_kp_u_host_must_be_a_str_or_bytes;
static PyObject *__pyx_kp_u_host_must_be_a_string_or_bytes_o;
static PyObject *__pyx_kp_u_host_port_and_sock_can_not_be_sp;
static PyObject *__pyx_n_s_id;
static PyObject *__pyx_n_s_ident;
static PyObject *__pyx_n_u_idna;
static PyObject *__pyx_n_s_ignore_environment;
static PyObject *__pyx_n_s_import;
static PyObject *__pyx_n_s_init;
static PyObject *__pyx_n_s_inspect;
static PyObject *__pyx_kp_u_integer_argument_expected_got;
static PyObject *__pyx_kp_u_invalid_Handle_cb_type;
static PyObject *__pyx_kp_u_invalid__init_protocol_call;
static PyObject *__pyx_kp_u_invalid_data_in_writebuf_an_inst;
static PyObject *__pyx_kp_u_invalid_socket_family_expected_A;
static PyObject *__pyx_kp_u_invalid_stderr_argument_value_r;
static PyObject *__pyx_kp_u_invalid_stdin_argument_value_r;
static PyObject *__pyx_kp_u_invalid_stdout_argument_value_r;
static PyObject *__pyx_kp_u_invalid_waiter_object_r_expected;
static PyObject *__pyx_kp_u_is_alive_but__handle_data_is_no;
static PyObject *__pyx_kp_u_is_alive_but__handle_is_NULL;
static PyObject *__pyx_kp_u_is_alive_but__handle_loop_is_no;
static PyObject *__pyx_kp_u_is_alive_but__loop_is_None;
static PyObject *__pyx_n_s_is_closed;
static PyObject *__pyx_kp_u_is_not_supposed_to_be_instantia;
static PyObject *__pyx_kp_u_is_open_in___dealloc___with_loo;
static PyObject *__pyx_n_s_is_running;
static PyObject *__pyx_n_s_iscoroutine;
static PyObject *__pyx_n_s_iscoroutinefunction;
static PyObject *__pyx_n_u_isfuture;
static PyObject *__pyx_n_s_isgenerator;
static PyObject *__pyx_n_s_items;
static PyObject *__pyx_n_s_iter;
static PyObject *__pyx_n_s_itertools;
static PyObject *__pyx_n_s_local_addr;
static PyObject *__pyx_kp_u_local_addr_must_be_a_tuple_of_ho;
static PyObject *__pyx_kp_u_local_addr_must_be_a_tuple_of_ho_2;
static PyObject *__pyx_n_s_log;
static PyObject *__pyx_n_s_log_destroy_pending;
static PyObject *__pyx_n_s_logger;
static PyObject *__pyx_n_s_loop;
static PyObject *__pyx_n_s_loop_2;
static PyObject *__pyx_kp_u_loop__exec_queued_writes;
static PyObject *__pyx_kp_u_loop__on_idle;
static PyObject *__pyx_kp_u_loop__queued_streams_are_not_emp;
static PyObject *__pyx_kp_u_loop_set_debug_False_cannot_unse;
static PyObject *__pyx_kp_u_loop_set_debug_True_cannot_set_d;
static PyObject *__pyx_n_s_low;
static PyObject *__pyx_n_s_lower;
static PyObject *__pyx_n_s_main;
static PyObject *__pyx_n_s_main_thread;
static PyObject *__pyx_n_s_memoryview;
static PyObject *__pyx_n_u_message;
static PyObject *__pyx_n_s_metaclass;
static PyObject *__pyx_n_s_module;
static PyObject *__pyx_n_s_monotonic;
static PyObject *__pyx_n_s_n;
static PyObject *__pyx_n_s_name;
static PyObject *__pyx_n_u_name;
static PyObject *__pyx_n_s_name_2;
static PyObject *__pyx_kp_u_new_callbacks_were_queued_during;
static PyObject *__pyx_n_s_new_future;
static PyObject *__pyx_kp_u_new_poll_handles_were_queued_dur;
static PyObject *__pyx_kp_u_new_timers_were_queued_during_lo;
static PyObject *__pyx_kp_u_no_path_and_sock_were_specified;
static PyObject *__pyx_n_s_noop;
static PyObject *__pyx_n_s_noop_2;
static PyObject *__pyx_kp_u_not_holding_the_import_lock;
static PyObject *__pyx_kp_u_object_created_at_most_recent_ca;
static PyObject *__pyx_kp_u_objs_handles;
static PyObject *__pyx_n_s_on_ssl_connected;
static PyObject *__pyx_n_s_open;
static PyObject *__pyx_kp_u_open__StreamWriteContext_is_bein;
static PyObject *__pyx_kp_u_open__UDPSendContext_is_being_de;
static PyObject *__pyx_n_s_os;
static PyObject *__pyx_n_s_other;
static PyObject *__pyx_n_s_partial;
static PyObject *__pyx_n_s_pass_fds;
static PyObject *__pyx_n_s_path;
static PyObject *__pyx_kp_u_path_and_sock_can_not_be_specifi;
static PyObject *__pyx_kp_u_path_was_not_specified_and_no_so;
static PyObject *__pyx_n_s_pause_writing;
static PyObject *__pyx_n_u_peername;
static PyObject *__pyx_n_s_pipe;
static PyObject *__pyx_n_u_pipe;
static PyObject *__pyx_n_s_pipe_connection_lost;
static PyObject *__pyx_n_s_pipe_data_received;
static PyObject *__pyx_n_s_pop;
static PyObject *__pyx_n_s_popleft;
static PyObject *__pyx_n_s_port;
static PyObject *__pyx_kp_u_port_must_be_a_str_bytes_or_int;
static PyObject *__pyx_n_s_preexec_fn;
static PyObject *__pyx_n_s_prepare;
static PyObject *__pyx_n_s_print;
static PyObject *__pyx_n_s_proc;
static PyObject *__pyx_n_s_process_exited;
static PyObject *__pyx_n_s_program;
static PyObject *__pyx_n_s_proto;
static PyObject *__pyx_n_s_proto_factory;
static PyObject *__pyx_n_u_protocol;
static PyObject *__pyx_n_s_protocol_factory;
static PyObject *__pyx_kp_u_protocol_is_not_set_cannot_call;
static PyObject *__pyx_kp_u_protocol_is_required;
static PyObject *__pyx_kp_u_protocol_pause_writing_failed;
static PyObject *__pyx_kp_u_protocol_resume_writing_failed;
static PyObject *__pyx_n_s_pyx_vtable;
static PyObject *__pyx_n_s_qualname;
static PyObject *__pyx_n_u_qualname;
static PyObject *__pyx_kp_u_r;
static PyObject *__pyx_kp_u_r_fileno_returned_non_integer;
static PyObject *__pyx_n_s_range;
static PyObject *__pyx_n_s_read;
static PyObject *__pyx_n_s_recv;
static PyObject *__pyx_n_s_remote_addr;
static PyObject *__pyx_kp_u_remote_addr_must_be_a_tuple_of_h;
static PyObject *__pyx_n_s_remove;
static PyObject *__pyx_n_s_remove_done_callback;
static PyObject *__pyx_n_s_remove_signal_handler;
static PyObject *__pyx_n_s_repr;
static PyObject *__pyx_n_s_restore_signals;
static PyObject *__pyx_n_s_result;
static PyObject *__pyx_n_s_resume_writing;
static PyObject *__pyx_n_s_return_exceptions;
static PyObject *__pyx_n_s_reuse_address;
static PyObject *__pyx_n_s_reuse_port;
static PyObject *__pyx_kp_u_reuse_port_not_supported_by_sock;
static PyObject *__pyx_n_s_rstrip;
static PyObject *__pyx_n_s_run_forever;
static PyObject *__pyx_n_s_run_until_complete_locals_lambda;
static PyObject *__pyx_kp_u_running_closed_debug;
static PyObject *__pyx_kp_u_s_fd_s_pipe_r;
static PyObject *__pyx_kp_u_s_sockets_r;
static PyObject *__pyx_n_s_self;
static PyObject *__pyx_n_s_send;
static PyObject *__pyx_n_s_server_hostname;
static PyObject *__pyx_kp_u_server_hostname_is_only_meaningf;
static PyObject *__pyx_kp_u_service_proto_not_found;
static PyObject *__pyx_n_s_set_asyncgen_hooks;
static PyObject *__pyx_n_s_set_coroutine_wrapper;
static PyObject *__pyx_n_s_set_debug;
static PyObject *__pyx_n_s_set_exception;
static PyObject *__pyx_n_s_set_inheritable;
static PyObject *__pyx_n_s_set_result;
static PyObject *__pyx_n_u_set_running_loop;
static PyObject *__pyx_n_s_set_running_or_notify_cancel;
static PyObject *__pyx_n_s_set_state;
static PyObject *__pyx_n_s_set_wakeup_fd;
static PyObject *__pyx_kp_u_set_wakeup_fd_only_works_in_main;
static PyObject *__pyx_n_s_setblocking;
static PyObject *__pyx_n_s_shell;
static PyObject *__pyx_kp_u_shell_must_be_False;
static PyObject *__pyx_kp_u_shell_must_be_True;
static PyObject *__pyx_n_s_shutdown;
static PyObject *__pyx_n_s_shutdown_asyncgens;
static PyObject *__pyx_n_s_sig;
static PyObject *__pyx_kp_u_sig_cannot_be_caught;
static PyObject *__pyx_kp_u_sig_must_be_an_int_not_r;
static PyObject *__pyx_kp_u_sig_out_of_range_1;
static PyObject *__pyx_n_s_sighandler_noop;
static PyObject *__pyx_n_s_signal;
static PyObject *__pyx_n_s_signum;
static PyObject *__pyx_n_s_sleep;
static PyObject *__pyx_n_s_sock;
static PyObject *__pyx_n_s_sock_connect;
static PyObject *__pyx_n_s_sock_sendall;
static PyObject *__pyx_n_s_sockaddr;
static PyObject *__pyx_kp_u_sockaddr_must_be_a_tuple_of_2_3;
static PyObject *__pyx_kp_u_sockaddr_resolved_to_multiple_ad;
static PyObject *__pyx_n_s_socket;
static PyObject *__pyx_n_u_socket;
static PyObject *__pyx_kp_u_socket_modifier_keyword_argument;
static PyObject *__pyx_n_s_socketpair;
static PyObject *__pyx_n_s_sockets;
static PyObject *__pyx_n_u_sockname;
static PyObject *__pyx_n_s_source;
static PyObject *__pyx_n_u_source_traceback;
static PyObject *__pyx_n_s_split;
static PyObject *__pyx_n_s_ssl;
static PyObject *__pyx_kp_u_ssl_argument_must_be_an_SSLConte;
static PyObject *__pyx_kp_u_ssl_is_expected_to_be_None_or_an;
static PyObject *__pyx_n_s_sslproto;
static PyObject *__pyx_kp_u_start_init_can_only_be_called;
static PyObject *__pyx_n_s_start_new_session;
static PyObject *__pyx_n_s_startupinfo;
static PyObject *__pyx_kp_u_startupinfo_is_not_supported;
static PyObject *__pyx_n_s_std_signal;
static PyObject *__pyx_n_s_stderr;
static PyObject *__pyx_n_s_stdin;
static PyObject *__pyx_n_s_stdio_fut;
static PyObject *__pyx_n_s_stdio_inited;
static PyObject *__pyx_n_s_stdout;
static PyObject *__pyx_kp_u_step_already_done_r_r;
static PyObject *__pyx_n_s_stop;
static PyObject *__pyx_kp_u_stream_is_open_after_UVStream__t;
static PyObject *__pyx_n_s_strerror;
static PyObject *__pyx_n_s_submit;
static PyObject *__pyx_n_s_subprocess;
static PyObject *__pyx_kp_u_subprocess_STDOUT_is_supported_o;
static PyObject *__pyx_n_s_subprocess_run;
static PyObject *__pyx_n_s_subtract;
static PyObject *__pyx_n_s_super;
static PyObject *__pyx_n_s_sys;
static PyObject *__pyx_kp_u_task_factory_must_be_a_callable;
static PyObject *__pyx_n_u_tcp;
static PyObject *__pyx_n_s_test;
static PyObject *__pyx_n_s_test_coroutine_1;
static PyObject *__pyx_kp_u_the_socket_must_be_non_blocking;
static PyObject *__pyx_kp_u_this_event_loop_is_already_runni;
static PyObject *__pyx_n_s_threading;
static PyObject *__pyx_n_s_throw;
static PyObject *__pyx_n_s_time;
static PyObject *__pyx_n_s_timeout;
static PyObject *__pyx_n_s_traceback;
static PyObject *__pyx_n_s_traceback_2;
static PyObject *__pyx_n_s_transport;
static PyObject *__pyx_n_u_transport;
static PyObject *__pyx_kp_u_try_write_sent_all_data_and_ret;
static PyObject *__pyx_n_s_type;
static PyObject *__pyx_n_u_udp;
static PyObject *__pyx_kp_u_unable_to_listen_no_protocol_fac;
static PyObject *__pyx_kp_u_unable_to_perform_operation_on_r;
static PyObject *__pyx_kp_u_unable_to_perform_send_operation;
static PyObject *__pyx_kp_u_unable_to_start_the_loop_it_was;
static PyObject *__pyx_kp_u_unclosed_resource_r;
static PyObject *__pyx_kp_u_unclosed_resource_r_2;
static PyObject *__pyx_kp_u_unexpected_address_family;
static PyObject *__pyx_n_s_universal_newlines;
static PyObject *__pyx_kp_u_universal_newlines_must_be_False;
static PyObject *__pyx_kp_u_unknown_Future_state;
static PyObject *__pyx_kp_u_unopened_TCPServer;
static PyObject *__pyx_n_s_update;
static PyObject *__pyx_kp_u_uv_close_handle_cb_handle_loop;
static PyObject *__pyx_kp_u_uv_handle_t_current_freed_total;
static PyObject *__pyx_kp_u_uv_udp_receive_callback_addr_is;
static PyObject *__pyx_kp_u_uvloop_Future_supports_only_uvlo;
static PyObject *__pyx_n_s_uvloop_loop;
static PyObject *__pyx_n_s_uvloop_sleep_after_fork;
static PyObject *__pyx_n_s_value;
static PyObject *__pyx_n_s_values;
static PyObject *__pyx_n_s_version_info;
static PyObject *__pyx_n_s_wait;
static PyObject *__pyx_n_s_wait_closed;
static PyObject *__pyx_n_s_waiter;
static PyObject *__pyx_kp_u_waiter_is_not_None_in__call_conn;
static PyObject *__pyx_n_s_wakeup;
static PyObject *__pyx_n_s_warn;
static PyObject *__pyx_n_s_warning;
static PyObject *__pyx_n_s_warnings;
static PyObject *__pyx_n_u_wb;
static PyObject *__pyx_n_s_weakref;
static PyObject *__pyx_n_s_when;
static PyObject *__pyx_kp_u_without_no_gc_clear_loop_was_se;
static PyObject *__pyx_n_s_wrap_future;
static PyObject *__pyx_n_s_write;
static PyObject *__pyx_kp_u_yield_from_wasn_t_used_with_futu;
static PyObject *__pyx_kp_u_yield_was_used_instead_of_yield;
static PyObject *__pyx_kp_u_yield_was_used_instead_of_yield_2;
static PyObject *__pyx_n_s_zip;
static int __pyx_pf_6uvloop_4loop_4Loop___cinit__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static int __pyx_pf_6uvloop_4loop_4Loop_2__init__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static void __pyx_pf_6uvloop_4loop_4Loop_4__dealloc__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_12_getaddrinfo_callback(PyObject *__pyx_self, PyObject *__pyx_v_result); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_12_getnameinfo_callback(PyObject *__pyx_self, PyObject *__pyx_v_result); /* proto */
static PyObject *__pyx_lambda_funcdef_lambda(PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_fut); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_6_get_backend_id(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_8print_debug_info(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_10__repr__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_12call_soon(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_14call_soon_threadsafe(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_16call_later(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_delay, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_18call_at(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_when, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_20time(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_22stop(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_24run_forever(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_26close(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_28get_debug(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_30set_debug(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_enabled); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_32is_running(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_34is_closed(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_36create_future(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_38create_task(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_coro); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_40set_task_factory(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_factory); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_42get_task_factory(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_lambda_funcdef_lambda1(PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_fut); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_44run_until_complete(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_future); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_46getaddrinfo(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_host, PyObject *__pyx_v_port, int __pyx_v_family, int __pyx_v_type, int __pyx_v_proto, int __pyx_v_flags); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_48getnameinfo(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sockaddr, int __pyx_v_flags); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_51create_server(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_host, PyObject *__pyx_v_port, int __pyx_v_family, int __pyx_v_flags, PyObject *__pyx_v_sock, PyObject *__pyx_v_backlog, PyObject *__pyx_v_ssl, CYTHON_UNUSED PyObject *__pyx_v_reuse_address, PyObject *__pyx_v_reuse_port); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_17create_connection_genexpr(PyObject *__pyx_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_17create_connection_3genexpr(PyObject *__pyx_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_54create_connection(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_host, PyObject *__pyx_v_port, PyObject *__pyx_v_ssl, PyObject *__pyx_v_family, PyObject *__pyx_v_proto, PyObject *__pyx_v_flags, PyObject *__pyx_v_sock, PyObject *__pyx_v_local_addr, PyObject *__pyx_v_server_hostname); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_57create_unix_server(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_path, PyObject *__pyx_v_backlog, PyObject *__pyx_v_sock, PyObject *__pyx_v_ssl); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_60create_unix_connection(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_path, PyObject *__pyx_v_ssl, PyObject *__pyx_v_sock, PyObject *__pyx_v_server_hostname); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_63default_exception_handler(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_context); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_65get_exception_handler(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_67set_exception_handler(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_handler); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_69call_exception_handler(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_context); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_71add_reader(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fd, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_73remove_reader(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fd); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_75add_writer(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fd, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_77remove_writer(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fd); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_79sock_recv(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sock, PyObject *__pyx_v_n); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_81sock_sendall(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sock, PyObject *__pyx_v_data); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_84sock_accept(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sock); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_86sock_connect(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sock, PyObject *__pyx_v_address); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_89connect_accepted_socket(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_sock, PyObject *__pyx_v_ssl); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_92run_in_executor(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_executor, PyObject *__pyx_v_func, PyObject *__pyx_v_args); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_94set_default_executor(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_executor); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_96__subprocess_run(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_args, PyObject *__pyx_v_stdin, PyObject *__pyx_v_stdout, PyObject *__pyx_v_stderr, PyObject *__pyx_v_universal_newlines, CYTHON_UNUSED PyObject *__pyx_v_shell, PyObject *__pyx_v_bufsize, PyObject *__pyx_v_preexec_fn, CYTHON_UNUSED PyObject *__pyx_v_close_fds, PyObject *__pyx_v_cwd, PyObject *__pyx_v_env, PyObject *__pyx_v_startupinfo, PyObject *__pyx_v_creationflags, PyObject *__pyx_v_restore_signals, PyObject *__pyx_v_start_new_session, PyObject *__pyx_v_executable, PyObject *__pyx_v_pass_fds, PyObject *__pyx_v___uvloop_sleep_after_fork); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_99subprocess_shell(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_cmd, PyObject *__pyx_v_shell, PyObject *__pyx_v_kwargs); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_101subprocess_exec(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_program, PyObject *__pyx_v_shell, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_103connect_read_pipe(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_proto_factory, PyObject *__pyx_v_pipe); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_106connect_write_pipe(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_proto_factory, PyObject *__pyx_v_pipe); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_109add_signal_handler(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sig, PyObject *__pyx_v_callback, PyObject *__pyx_v_args); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_111remove_signal_handler(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sig); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_24create_datagram_endpoint_genexpr(PyObject *__pyx_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_113create_datagram_endpoint(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_local_addr, PyObject *__pyx_v_remote_addr, PyObject *__pyx_v_family, PyObject *__pyx_v_proto, PyObject *__pyx_v_flags, PyObject *__pyx_v_reuse_address, PyObject *__pyx_v_reuse_port, PyObject *__pyx_v_allow_broadcast, PyObject *__pyx_v_sock); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_116_asyncgen_finalizer_hook(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_agen); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_118_asyncgen_firstiter_hook(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_agen); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_120shutdown_asyncgens(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_22slow_callback_duration___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static int __pyx_pf_6uvloop_4loop_4Loop_22slow_callback_duration_2__set__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static int __pyx_pf_6uvloop_4loop_4Loop_22slow_callback_duration_4__del__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_7_closed___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_9_debug_cc___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_20_debug_handles_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_21_debug_handles_closed___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_22_debug_handles_current___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_23_debug_uv_handles_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_23_debug_uv_handles_freed___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_23_debug_cb_handles_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_23_debug_cb_handles_count___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_29_debug_cb_timer_handles_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_29_debug_cb_timer_handles_count___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_35_debug_stream_shutdown_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_33_debug_stream_listen_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_27_debug_stream_read_cb_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_34_debug_stream_read_cb_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_28_debug_stream_read_eof_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_38_debug_stream_read_eof_cb_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_31_debug_stream_read_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_25_debug_stream_write_tries___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_32_debug_stream_write_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_29_debug_stream_write_ctx_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_27_debug_stream_write_ctx_cnt___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_35_debug_stream_write_cb_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_23_poll_read_events_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_26_poll_read_cb_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_24_poll_write_events_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_27_poll_write_cb_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_21_sock_try_write_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_28_debug_exception_handler_cnt___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self); /* proto */
static int __pyx_pf_6uvloop_4loop_6Handle___cinit__(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self); /* proto */
static void __pyx_pf_6uvloop_4loop_6Handle_2__dealloc__(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self); /* proto */
static int __pyx_pf_6uvloop_4loop_6Handle_4__init__(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_6Handle_6__repr__(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_6Handle_8cancel(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_6Handle_17_source_traceback___get__(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self); /* proto */
static int __pyx_pf_6uvloop_4loop_11TimerHandle___cinit__(struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_callback, PyObject *__pyx_v_args, uint64_t __pyx_v_delay); /* proto */
static void __pyx_pf_6uvloop_4loop_11TimerHandle_2__dealloc__(struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_11TimerHandle_4__repr__(struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_11TimerHandle_6cancel(struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_11TimerHandle_17_source_traceback___get__(struct __pyx_obj_6uvloop_4loop_TimerHandle *__pyx_v_self); /* proto */
static int __pyx_pf_6uvloop_4loop_8UVHandle___cinit__(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self); /* proto */
static int __pyx_pf_6uvloop_4loop_8UVHandle_2__init__(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self); /* proto */
static void __pyx_pf_6uvloop_4loop_8UVHandle_4__dealloc__(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_8UVHandle_6__repr__(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_8UVHandle_17_source_traceback___get__(struct __pyx_obj_6uvloop_4loop_UVHandle *__pyx_v_self); /* proto */
static int __pyx_pf_6uvloop_4loop_14UVSocketHandle___cinit__(struct __pyx_obj_6uvloop_4loop_UVSocketHandle *__pyx_v_self); /* proto */
static int __pyx_pf_6uvloop_4loop_15UVBaseTransport___cinit__(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_7_paused___get__(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_2get_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_4set_protocol(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_protocol); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_6_force_close(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_exc); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_8abort(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_10close(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_12is_closing(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_14get_write_buffer_size(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_16set_write_buffer_limits(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_high, PyObject *__pyx_v_low); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_18get_write_buffer_limits(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_20get_extra_info(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_default); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_15UVBaseTransport_8_closing___get__(struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_self); /* proto */
static void __pyx_pf_6uvloop_4loop_19_StreamWriteContext___dealloc__(struct __pyx_obj_6uvloop_4loop__StreamWriteContext *__pyx_v_self); /* proto */
static int __pyx_pf_6uvloop_4loop_8UVStream___cinit__(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_2__repr__(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_4write(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self, PyObject *__pyx_v_buf); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_6writelines(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self, PyObject *__pyx_v_bufs); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_8write_eof(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_10can_write_eof(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_12pause_reading(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_8UVStream_14resume_reading(struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_self); /* proto */
static int __pyx_pf_6uvloop_4loop_14UVStreamServer___cinit__(struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_14UVStreamServer_2__on_ssl_connected(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVStreamServer *__pyx_v_self, PyObject *__pyx_v_transport, PyObject *__pyx_v_fut); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_12TCPTransport_get_extra_info(struct __pyx_obj_6uvloop_4loop_TCPTransport *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_default); /* proto */
static int __pyx_pf_6uvloop_4loop_18_TCPConnectRequest___cinit__(struct __pyx_obj_6uvloop_4loop__TCPConnectRequest *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_loop, PyObject *__pyx_v_transport); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_get_write_buffer_limits(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_2set_write_buffer_limits(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_high, CYTHON_UNUSED PyObject *__pyx_v_low); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_4get_write_buffer_size(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_6write(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_data); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_8writelines(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_list_of_data); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_10write_eof(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_12can_write_eof(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_17ReadUnixTransport_14abort(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_18WriteUnixTransport_pause_reading(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_18WriteUnixTransport_2resume_reading(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *__pyx_v_self); /* proto */
static int __pyx_pf_6uvloop_4loop_19_PipeConnectRequest___cinit__(struct __pyx_obj_6uvloop_4loop__PipeConnectRequest *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_loop, PyObject *__pyx_v_transport); /* proto */
static int __pyx_pf_6uvloop_4loop_9UVProcess___cinit__(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self); /* proto */
static void __pyx_pf_6uvloop_4loop_9UVProcess_2__dealloc__(struct __pyx_obj_6uvloop_4loop_UVProcess *__pyx_v_self); /* proto */
static int __pyx_pf_6uvloop_4loop_18UVProcessTransport___cinit__(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_2__stdio_inited(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, PyObject *__pyx_v_waiter, PyObject *__pyx_v_stdio_fut); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_4get_protocol(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_6set_protocol(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, PyObject *__pyx_v_protocol); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_8get_pid(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_10get_returncode(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_12get_pipe_transport(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, PyObject *__pyx_v_fd); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_14terminate(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_16kill(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_18send_signal(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, int __pyx_v_signal); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_20is_closing(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_22close(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_24get_extra_info(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v_name, PyObject *__pyx_v_default); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_18UVProcessTransport_26_wait(struct __pyx_obj_6uvloop_4loop_UVProcessTransport *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_24WriteSubprocessPipeProto___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_proc, PyObject *__pyx_v_fd); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_24WriteSubprocessPipeProto_2connection_made(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_transport); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_24WriteSubprocessPipeProto_4__repr__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_24WriteSubprocessPipeProto_6connection_lost(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_exc); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_24WriteSubprocessPipeProto_8pause_writing(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_24WriteSubprocessPipeProto_10resume_writing(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_23ReadSubprocessPipeProto_data_received(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_data); /* proto */
static int __pyx_pf_6uvloop_4loop_9UVRequest___cinit__(struct __pyx_obj_6uvloop_4loop_UVRequest *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, CYTHON_UNUSED PyObject *__pyx_v__); /* proto */
static void __pyx_pf_6uvloop_4loop_9UVRequest_2__dealloc__(struct __pyx_obj_6uvloop_4loop_UVRequest *__pyx_v_self); /* proto */
static int __pyx_pf_6uvloop_4loop_8AddrInfo___cinit__(struct __pyx_obj_6uvloop_4loop_AddrInfo *__pyx_v_self); /* proto */
static void __pyx_pf_6uvloop_4loop_8AddrInfo_2__dealloc__(struct __pyx_obj_6uvloop_4loop_AddrInfo *__pyx_v_self); /* proto */
static int __pyx_pf_6uvloop_4loop_15AddrInfoRequest___cinit__(struct __pyx_obj_6uvloop_4loop_AddrInfoRequest *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_host, PyObject *__pyx_v_port, int __pyx_v_family, int __pyx_v_type, int __pyx_v_proto, int __pyx_v_flags, PyObject *__pyx_v_callback); /* proto */
static int __pyx_pf_6uvloop_4loop_15NameInfoRequest___cinit__(struct __pyx_obj_6uvloop_4loop_NameInfoRequest *__pyx_v_self, CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop, PyObject *__pyx_v_callback); /* proto */
static void __pyx_pf_6uvloop_4loop_15_UDPSendContext___dealloc__(struct __pyx_obj_6uvloop_4loop__UDPSendContext *__pyx_v_self); /* proto */
static int __pyx_pf_6uvloop_4loop_12UDPTransport___cinit__(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_12UDPTransport_2sendto(struct __pyx_obj_6uvloop_4loop_UDPTransport *__pyx_v_self, PyObject *__pyx_v_data, PyObject *__pyx_v_addr); /* proto */
static int __pyx_pf_6uvloop_4loop_6Server___cinit__(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_6Server_2__repr__(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_6Server_4wait_closed(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_6Server_7close(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_6Server_7sockets___get__(struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_self); /* proto */
static int __pyx_pf_6uvloop_4loop_10BaseFuture___init__(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_10BaseFuture_24_asyncio_future_blocking___get__(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self); /* proto */
static int __pyx_pf_6uvloop_4loop_10BaseFuture_24_asyncio_future_blocking_2__set__(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_10BaseFuture_6_state___get__(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_10BaseFuture_2cancel(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_10BaseFuture_4cancelled(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_10BaseFuture_6done(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_10BaseFuture_8result(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_10BaseFuture_10exception(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_10BaseFuture_12add_done_callback(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self, PyObject *__pyx_v_fn); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_10BaseFuture_14remove_done_callback(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self, PyObject *__pyx_v_fn); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_10BaseFuture_16set_result(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self, PyObject *__pyx_v_result); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_10BaseFuture_18set_exception(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self, PyObject *__pyx_v_exception); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_10BaseFuture_20__iter__(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_10BaseFuture_23__await__(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_10BaseFuture_5_loop___get__(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_10BaseFuture_10_callbacks___get__(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_10BaseFuture_10_exception___get__(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_10BaseFuture_7_result___get__(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_10BaseFuture_9_blocking___get__(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self); /* proto */
static int __pyx_pf_6uvloop_4loop_10BaseFuture_9_blocking_2__set__(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_10BaseFuture_17_source_traceback___get__(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_10BaseFuture_14_log_traceback___get__(struct __pyx_obj_6uvloop_4loop_BaseFuture *__pyx_v_self); /* proto */
static int __pyx_pf_6uvloop_4loop_8BaseTask___init__(struct __pyx_obj_6uvloop_4loop_BaseTask *__pyx_v_self, PyObject *__pyx_v_coro, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_8BaseTask_2cancel(struct __pyx_obj_6uvloop_4loop_BaseTask *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_8BaseTask_4_step(struct __pyx_obj_6uvloop_4loop_BaseTask *__pyx_v_self, PyObject *__pyx_v_exc); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_8BaseTask_6_wakeup(struct __pyx_obj_6uvloop_4loop_BaseTask *__pyx_v_self, PyObject *__pyx_v_future); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_8BaseTask_5_coro___get__(struct __pyx_obj_6uvloop_4loop_BaseTask *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_8BaseTask_11_fut_waiter___get__(struct __pyx_obj_6uvloop_4loop_BaseTask *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_8BaseTask_12_must_cancel___get__(struct __pyx_obj_6uvloop_4loop_BaseTask *__pyx_v_self); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_8BaseTask_20_log_destroy_pending___get__(struct __pyx_obj_6uvloop_4loop_BaseTask *__pyx_v_self); /* proto */
static int __pyx_pf_6uvloop_4loop_8BaseTask_20_log_destroy_pending_2__set__(struct __pyx_obj_6uvloop_4loop_BaseTask *__pyx_v_self, PyObject *__pyx_v_value); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_13_chain_future__set_state(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_future, PyObject *__pyx_v_other); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_13_chain_future_2_call_check_cancel(PyObject *__pyx_self, PyObject *__pyx_v_destination); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_13_chain_future_4_call_set_state(PyObject *__pyx_self, PyObject *__pyx_v_source); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop__wrap_future(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_future, PyObject *__pyx_v_loop); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_2_sighandler_noop(CYTHON_UNUSED PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_signum, CYTHON_UNUSED PyObject *__pyx_v_frame); /* proto */
static PyObject *__pyx_pf_6uvloop_4loop_4_test_coroutine_1(CYTHON_UNUSED PyObject *__pyx_self); /* proto */
static PyObject *__pyx_tp_new_6uvloop_4loop_UVHandle(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_UVSocketHandle(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_UVAsync(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_UVTimer(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_UVIdle(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_UVBaseTransport(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_Loop(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_Handle(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_TimerHandle(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_UVCheck(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_UVPoll(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_UVStream(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_UVStreamServer(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_TCPServer(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_TCPTransport(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_UnixServer(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_UnixTransport(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_ReadUnixTransport(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_WriteUnixTransport(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_UVProcess(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_UVProcessTransport(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_UVRequest(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_UDPTransport(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_Server(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop__StreamWriteContext(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop__TCPConnectRequest(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop__PipeConnectRequest(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_AddrInfo(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_AddrInfoRequest(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_NameInfoRequest(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop__UDPSendContext(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_BaseFuture(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop_BaseTask(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct___getaddrinfo(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_1__getnameinfo(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_2__sock_connect(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_3_run_until_complete(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_4_getnameinfo(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_5_create_server(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_6_create_connection(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_7_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_8_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_9_create_unix_server(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_10_create_unix_connection(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_11_sock_sendall(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_12_sock_connect(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_13_connect_accepted_socket(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_14___subprocess_run(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_15_connect_read_pipe(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_16_connect_write_pipe(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_17_create_datagram_endpoint(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_18_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_19_shutdown_asyncgens(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_20_wait_closed(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_21___iter__(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_22___await__(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_23___pyx_f_6uvloop_4loop__chain_future(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_24__test_coroutine_1(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/
static PyObject *__pyx_float_0_1;
static PyObject *__pyx_int_0;
static PyObject *__pyx_int_1;
static PyObject *__pyx_int_2;
static PyObject *__pyx_int_3;
static PyObject *__pyx_int_6;
static PyObject *__pyx_int_42;
static PyObject *__pyx_int_100;
static PyObject *__pyx_int_1000;
static PyObject *__pyx_int_4096;
static PyObject *__pyx_int_50000;
static PyObject *__pyx_int_1048575;
static PyObject *__pyx_int_4294967296;
static PyObject *__pyx_int_neg_1;
static int __pyx_k__49;
static int __pyx_k__50;
static PyObject *__pyx_k__86;
static PyObject *__pyx_k__87;
static PyObject *__pyx_k__88;
static PyObject *__pyx_tuple_;
static PyObject *__pyx_tuple__2;
static PyObject *__pyx_tuple__3;
static PyObject *__pyx_tuple__4;
static PyObject *__pyx_tuple__5;
static PyObject *__pyx_tuple__6;
static PyObject *__pyx_tuple__7;
static PyObject *__pyx_tuple__8;
static PyObject *__pyx_tuple__9;
static PyObject *__pyx_tuple__10;
static PyObject *__pyx_tuple__11;
static PyObject *__pyx_tuple__12;
static PyObject *__pyx_tuple__13;
static PyObject *__pyx_tuple__14;
static PyObject *__pyx_tuple__15;
static PyObject *__pyx_tuple__16;
static PyObject *__pyx_tuple__17;
static PyObject *__pyx_tuple__18;
static PyObject *__pyx_tuple__19;
static PyObject *__pyx_tuple__20;
static PyObject *__pyx_tuple__22;
static PyObject *__pyx_tuple__24;
static PyObject *__pyx_tuple__25;
static PyObject *__pyx_tuple__26;
static PyObject *__pyx_tuple__27;
static PyObject *__pyx_tuple__28;
static PyObject *__pyx_tuple__29;
static PyObject *__pyx_tuple__31;
static PyObject *__pyx_tuple__32;
static PyObject *__pyx_tuple__33;
static PyObject *__pyx_tuple__34;
static PyObject *__pyx_tuple__35;
static PyObject *__pyx_tuple__37;
static PyObject *__pyx_tuple__38;
static PyObject *__pyx_tuple__39;
static PyObject *__pyx_tuple__40;
static PyObject *__pyx_tuple__41;
static PyObject *__pyx_tuple__42;
static PyObject *__pyx_tuple__43;
static PyObject *__pyx_tuple__44;
static PyObject *__pyx_tuple__45;
static PyObject *__pyx_tuple__46;
static PyObject *__pyx_tuple__47;
static PyObject *__pyx_tuple__48;
static PyObject *__pyx_tuple__51;
static PyObject *__pyx_tuple__52;
static PyObject *__pyx_tuple__53;
static PyObject *__pyx_tuple__54;
static PyObject *__pyx_tuple__55;
static PyObject *__pyx_tuple__56;
static PyObject *__pyx_tuple__57;
static PyObject *__pyx_tuple__58;
static PyObject *__pyx_tuple__59;
static PyObject *__pyx_tuple__60;
static PyObject *__pyx_tuple__61;
static PyObject *__pyx_tuple__62;
static PyObject *__pyx_tuple__63;
static PyObject *__pyx_tuple__65;
static PyObject *__pyx_tuple__66;
static PyObject *__pyx_tuple__67;
static PyObject *__pyx_tuple__68;
static PyObject *__pyx_tuple__69;
static PyObject *__pyx_tuple__70;
static PyObject *__pyx_tuple__71;
static PyObject *__pyx_tuple__72;
static PyObject *__pyx_tuple__73;
static PyObject *__pyx_tuple__74;
static PyObject *__pyx_tuple__77;
static PyObject *__pyx_tuple__78;
static PyObject *__pyx_tuple__79;
static PyObject *__pyx_tuple__80;
static PyObject *__pyx_tuple__81;
static PyObject *__pyx_tuple__82;
static PyObject *__pyx_tuple__83;
static PyObject *__pyx_tuple__84;
static PyObject *__pyx_tuple__85;
static PyObject *__pyx_tuple__89;
static PyObject *__pyx_tuple__90;
static PyObject *__pyx_tuple__91;
static PyObject *__pyx_tuple__92;
static PyObject *__pyx_tuple__93;
static PyObject *__pyx_tuple__94;
static PyObject *__pyx_tuple__95;
static PyObject *__pyx_tuple__96;
static PyObject *__pyx_tuple__98;
static PyObject *__pyx_tuple__99;
static PyObject *__pyx_tuple__100;
static PyObject *__pyx_tuple__101;
static PyObject *__pyx_tuple__102;
static PyObject *__pyx_tuple__103;
static PyObject *__pyx_tuple__104;
static PyObject *__pyx_tuple__105;
static PyObject *__pyx_tuple__106;
static PyObject *__pyx_tuple__107;
static PyObject *__pyx_tuple__111;
static PyObject *__pyx_tuple__112;
static PyObject *__pyx_tuple__113;
static PyObject *__pyx_tuple__114;
static PyObject *__pyx_tuple__115;
static PyObject *__pyx_tuple__116;
static PyObject *__pyx_tuple__118;
static PyObject *__pyx_tuple__119;
static PyObject *__pyx_tuple__120;
static PyObject *__pyx_tuple__121;
static PyObject *__pyx_tuple__122;
static PyObject *__pyx_tuple__123;
static PyObject *__pyx_tuple__124;
static PyObject *__pyx_tuple__125;
static PyObject *__pyx_tuple__126;
static PyObject *__pyx_tuple__127;
static PyObject *__pyx_tuple__128;
static PyObject *__pyx_tuple__129;
static PyObject *__pyx_tuple__130;
static PyObject *__pyx_tuple__131;
static PyObject *__pyx_tuple__132;
static PyObject *__pyx_tuple__133;
static PyObject *__pyx_tuple__134;
static PyObject *__pyx_tuple__135;
static PyObject *__pyx_tuple__136;
static PyObject *__pyx_tuple__137;
static PyObject *__pyx_tuple__138;
static PyObject *__pyx_tuple__139;
static PyObject *__pyx_tuple__140;
static PyObject *__pyx_tuple__141;
static PyObject *__pyx_tuple__142;
static PyObject *__pyx_tuple__144;
static PyObject *__pyx_tuple__145;
static PyObject *__pyx_tuple__146;
static PyObject *__pyx_tuple__147;
static PyObject *__pyx_tuple__148;
static PyObject *__pyx_tuple__149;
static PyObject *__pyx_tuple__150;
static PyObject *__pyx_tuple__151;
static PyObject *__pyx_tuple__152;
static PyObject *__pyx_tuple__153;
static PyObject *__pyx_tuple__155;
static PyObject *__pyx_tuple__156;
static PyObject *__pyx_tuple__157;
static PyObject *__pyx_tuple__158;
static PyObject *__pyx_tuple__159;
static PyObject *__pyx_tuple__160;
static PyObject *__pyx_tuple__161;
static PyObject *__pyx_tuple__162;
static PyObject *__pyx_tuple__163;
static PyObject *__pyx_tuple__164;
static PyObject *__pyx_tuple__165;
static PyObject *__pyx_tuple__166;
static PyObject *__pyx_tuple__167;
static PyObject *__pyx_tuple__168;
static PyObject *__pyx_tuple__169;
static PyObject *__pyx_tuple__170;
static PyObject *__pyx_tuple__171;
static PyObject *__pyx_tuple__172;
static PyObject *__pyx_tuple__173;
static PyObject *__pyx_tuple__174;
static PyObject *__pyx_tuple__175;
static PyObject *__pyx_tuple__176;
static PyObject *__pyx_tuple__177;
static PyObject *__pyx_tuple__178;
static PyObject *__pyx_tuple__179;
static PyObject *__pyx_tuple__180;
static PyObject *__pyx_tuple__181;
static PyObject *__pyx_tuple__182;
static PyObject *__pyx_tuple__183;
static PyObject *__pyx_tuple__184;
static PyObject *__pyx_tuple__185;
static PyObject *__pyx_tuple__186;
static PyObject *__pyx_tuple__187;
static PyObject *__pyx_tuple__188;
static PyObject *__pyx_tuple__190;
static PyObject *__pyx_tuple__192;
static PyObject *__pyx_tuple__194;
static PyObject *__pyx_tuple__196;
static PyObject *__pyx_tuple__198;
static PyObject *__pyx_tuple__200;
static PyObject *__pyx_tuple__202;
static PyObject *__pyx_tuple__204;
static PyObject *__pyx_tuple__206;
static PyObject *__pyx_tuple__208;
static PyObject *__pyx_tuple__209;
static PyObject *__pyx_tuple__211;
static PyObject *__pyx_codeobj__21;
static PyObject *__pyx_codeobj__23;
static PyObject *__pyx_codeobj__189;
static PyObject *__pyx_codeobj__191;
static PyObject *__pyx_codeobj__193;
static PyObject *__pyx_codeobj__195;
static PyObject *__pyx_codeobj__197;
static PyObject *__pyx_codeobj__199;
static PyObject *__pyx_codeobj__201;
static PyObject *__pyx_codeobj__203;
static PyObject *__pyx_codeobj__205;
static PyObject *__pyx_codeobj__207;
static PyObject *__pyx_codeobj__210;
static PyObject *__pyx_codeobj__212;
static PyObject *__pyx_codeobj__213;
/* "uvloop/errors.pyx":1
* cdef str __strerr(int errno): # <<<<<<<<<<<<<<
* return strerror(errno).decode()
*
*/
static PyObject *__pyx_f_6uvloop_4loop___strerr(int __pyx_v_errno) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
char *__pyx_t_1;
PyObject *__pyx_t_2 = NULL;
__Pyx_RefNannySetupContext("__strerr", 0);
/* "uvloop/errors.pyx":2
* cdef str __strerr(int errno):
* return strerror(errno).decode() # <<<<<<<<<<<<<<
*
*
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = strerror(__pyx_v_errno);
__pyx_t_2 = __Pyx_decode_c_string(__pyx_t_1, 0, strlen(__pyx_t_1), NULL, NULL, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (!(likely(PyUnicode_CheckExact(__pyx_t_2))||((__pyx_t_2) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "unicode", Py_TYPE(__pyx_t_2)->tp_name), 0))) __PYX_ERR(0, 2, __pyx_L1_error)
__Pyx_INCREF(__pyx_t_2);
__pyx_r = ((PyObject*)__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
goto __pyx_L0;
/* "uvloop/errors.pyx":1
* cdef str __strerr(int errno): # <<<<<<<<<<<<<<
* return strerror(errno).decode()
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_AddTraceback("uvloop.loop.__strerr", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/errors.pyx":5
*
*
* cdef __convert_python_error(int uverr): # <<<<<<<<<<<<<<
* # XXX Won't work for Windows:
* # From libuv docs:
*/
static PyObject *__pyx_f_6uvloop_4loop___convert_python_error(int __pyx_v_uverr) {
int __pyx_v_oserr;
PyObject *__pyx_v_exc = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
__Pyx_RefNannySetupContext("__convert_python_error", 0);
/* "uvloop/errors.pyx":11
* # negated errno (or -errno), while on Windows they
* # are defined by libuv to arbitrary negative numbers.
* cdef int oserr = -uverr # <<<<<<<<<<<<<<
*
* exc = OSError
*/
__pyx_v_oserr = (-__pyx_v_uverr);
/* "uvloop/errors.pyx":13
* cdef int oserr = -uverr
*
* exc = OSError # <<<<<<<<<<<<<<
*
* if uverr in (uv.UV_EACCES, uv.UV_EPERM):
*/
__Pyx_INCREF(__pyx_builtin_OSError);
__pyx_v_exc = __pyx_builtin_OSError;
/* "uvloop/errors.pyx":15
* exc = OSError
*
* if uverr in (uv.UV_EACCES, uv.UV_EPERM): # <<<<<<<<<<<<<<
* exc = PermissionError
*
*/
__pyx_t_1 = __pyx_v_uverr;
__pyx_t_3 = ((__pyx_t_1 == UV_EACCES) != 0);
if (!__pyx_t_3) {
} else {
__pyx_t_2 = __pyx_t_3;
goto __pyx_L4_bool_binop_done;
}
__pyx_t_3 = ((__pyx_t_1 == UV_EPERM) != 0);
__pyx_t_2 = __pyx_t_3;
__pyx_L4_bool_binop_done:;
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
/* "uvloop/errors.pyx":16
*
* if uverr in (uv.UV_EACCES, uv.UV_EPERM):
* exc = PermissionError # <<<<<<<<<<<<<<
*
* elif uverr in (uv.UV_EAGAIN, uv.UV_EALREADY):
*/
__Pyx_INCREF(__pyx_builtin_PermissionError);
__Pyx_DECREF_SET(__pyx_v_exc, __pyx_builtin_PermissionError);
/* "uvloop/errors.pyx":15
* exc = OSError
*
* if uverr in (uv.UV_EACCES, uv.UV_EPERM): # <<<<<<<<<<<<<<
* exc = PermissionError
*
*/
goto __pyx_L3;
}
/* "uvloop/errors.pyx":18
* exc = PermissionError
*
* elif uverr in (uv.UV_EAGAIN, uv.UV_EALREADY): # <<<<<<<<<<<<<<
* exc = BlockingIOError
*
*/
__pyx_t_1 = __pyx_v_uverr;
__pyx_t_2 = ((__pyx_t_1 == UV_EAGAIN) != 0);
if (!__pyx_t_2) {
} else {
__pyx_t_3 = __pyx_t_2;
goto __pyx_L6_bool_binop_done;
}
__pyx_t_2 = ((__pyx_t_1 == UV_EALREADY) != 0);
__pyx_t_3 = __pyx_t_2;
__pyx_L6_bool_binop_done:;
__pyx_t_2 = (__pyx_t_3 != 0);
if (__pyx_t_2) {
/* "uvloop/errors.pyx":19
*
* elif uverr in (uv.UV_EAGAIN, uv.UV_EALREADY):
* exc = BlockingIOError # <<<<<<<<<<<<<<
*
* elif uverr in (uv.UV_EPIPE, uv.UV_ESHUTDOWN):
*/
__Pyx_INCREF(__pyx_builtin_BlockingIOError);
__Pyx_DECREF_SET(__pyx_v_exc, __pyx_builtin_BlockingIOError);
/* "uvloop/errors.pyx":18
* exc = PermissionError
*
* elif uverr in (uv.UV_EAGAIN, uv.UV_EALREADY): # <<<<<<<<<<<<<<
* exc = BlockingIOError
*
*/
goto __pyx_L3;
}
/* "uvloop/errors.pyx":21
* exc = BlockingIOError
*
* elif uverr in (uv.UV_EPIPE, uv.UV_ESHUTDOWN): # <<<<<<<<<<<<<<
* exc = BrokenPipeError
*
*/
__pyx_t_1 = __pyx_v_uverr;
__pyx_t_3 = ((__pyx_t_1 == UV_EPIPE) != 0);
if (!__pyx_t_3) {
} else {
__pyx_t_2 = __pyx_t_3;
goto __pyx_L8_bool_binop_done;
}
__pyx_t_3 = ((__pyx_t_1 == UV_ESHUTDOWN) != 0);
__pyx_t_2 = __pyx_t_3;
__pyx_L8_bool_binop_done:;
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
/* "uvloop/errors.pyx":22
*
* elif uverr in (uv.UV_EPIPE, uv.UV_ESHUTDOWN):
* exc = BrokenPipeError # <<<<<<<<<<<<<<
*
* elif uverr == uv.UV_ECONNABORTED:
*/
__Pyx_INCREF(__pyx_builtin_BrokenPipeError);
__Pyx_DECREF_SET(__pyx_v_exc, __pyx_builtin_BrokenPipeError);
/* "uvloop/errors.pyx":21
* exc = BlockingIOError
*
* elif uverr in (uv.UV_EPIPE, uv.UV_ESHUTDOWN): # <<<<<<<<<<<<<<
* exc = BrokenPipeError
*
*/
goto __pyx_L3;
}
/* "uvloop/errors.pyx":24
* exc = BrokenPipeError
*
* elif uverr == uv.UV_ECONNABORTED: # <<<<<<<<<<<<<<
* exc = ConnectionAbortedError
*
*/
__pyx_t_3 = ((__pyx_v_uverr == UV_ECONNABORTED) != 0);
if (__pyx_t_3) {
/* "uvloop/errors.pyx":25
*
* elif uverr == uv.UV_ECONNABORTED:
* exc = ConnectionAbortedError # <<<<<<<<<<<<<<
*
* elif uverr == uv.UV_ECONNREFUSED:
*/
__Pyx_INCREF(__pyx_builtin_ConnectionAbortedError);
__Pyx_DECREF_SET(__pyx_v_exc, __pyx_builtin_ConnectionAbortedError);
/* "uvloop/errors.pyx":24
* exc = BrokenPipeError
*
* elif uverr == uv.UV_ECONNABORTED: # <<<<<<<<<<<<<<
* exc = ConnectionAbortedError
*
*/
goto __pyx_L3;
}
/* "uvloop/errors.pyx":27
* exc = ConnectionAbortedError
*
* elif uverr == uv.UV_ECONNREFUSED: # <<<<<<<<<<<<<<
* exc = ConnectionRefusedError
*
*/
__pyx_t_3 = ((__pyx_v_uverr == UV_ECONNREFUSED) != 0);
if (__pyx_t_3) {
/* "uvloop/errors.pyx":28
*
* elif uverr == uv.UV_ECONNREFUSED:
* exc = ConnectionRefusedError # <<<<<<<<<<<<<<
*
* elif uverr == uv.UV_ECONNRESET:
*/
__Pyx_INCREF(__pyx_builtin_ConnectionRefusedError);
__Pyx_DECREF_SET(__pyx_v_exc, __pyx_builtin_ConnectionRefusedError);
/* "uvloop/errors.pyx":27
* exc = ConnectionAbortedError
*
* elif uverr == uv.UV_ECONNREFUSED: # <<<<<<<<<<<<<<
* exc = ConnectionRefusedError
*
*/
goto __pyx_L3;
}
/* "uvloop/errors.pyx":30
* exc = ConnectionRefusedError
*
* elif uverr == uv.UV_ECONNRESET: # <<<<<<<<<<<<<<
* exc = ConnectionResetError
*
*/
__pyx_t_3 = ((__pyx_v_uverr == UV_ECONNRESET) != 0);
if (__pyx_t_3) {
/* "uvloop/errors.pyx":31
*
* elif uverr == uv.UV_ECONNRESET:
* exc = ConnectionResetError # <<<<<<<<<<<<<<
*
* elif uverr == uv.UV_EEXIST:
*/
__Pyx_INCREF(__pyx_builtin_ConnectionResetError);
__Pyx_DECREF_SET(__pyx_v_exc, __pyx_builtin_ConnectionResetError);
/* "uvloop/errors.pyx":30
* exc = ConnectionRefusedError
*
* elif uverr == uv.UV_ECONNRESET: # <<<<<<<<<<<<<<
* exc = ConnectionResetError
*
*/
goto __pyx_L3;
}
/* "uvloop/errors.pyx":33
* exc = ConnectionResetError
*
* elif uverr == uv.UV_EEXIST: # <<<<<<<<<<<<<<
* exc = FileExistsError
*
*/
__pyx_t_3 = ((__pyx_v_uverr == UV_EEXIST) != 0);
if (__pyx_t_3) {
/* "uvloop/errors.pyx":34
*
* elif uverr == uv.UV_EEXIST:
* exc = FileExistsError # <<<<<<<<<<<<<<
*
* elif uverr == uv.UV_ENOENT:
*/
__Pyx_INCREF(__pyx_builtin_FileExistsError);
__Pyx_DECREF_SET(__pyx_v_exc, __pyx_builtin_FileExistsError);
/* "uvloop/errors.pyx":33
* exc = ConnectionResetError
*
* elif uverr == uv.UV_EEXIST: # <<<<<<<<<<<<<<
* exc = FileExistsError
*
*/
goto __pyx_L3;
}
/* "uvloop/errors.pyx":36
* exc = FileExistsError
*
* elif uverr == uv.UV_ENOENT: # <<<<<<<<<<<<<<
* exc = FileNotFoundError
*
*/
__pyx_t_3 = ((__pyx_v_uverr == UV_ENOENT) != 0);
if (__pyx_t_3) {
/* "uvloop/errors.pyx":37
*
* elif uverr == uv.UV_ENOENT:
* exc = FileNotFoundError # <<<<<<<<<<<<<<
*
* elif uverr == uv.UV_EINTR:
*/
__Pyx_INCREF(__pyx_builtin_FileNotFoundError);
__Pyx_DECREF_SET(__pyx_v_exc, __pyx_builtin_FileNotFoundError);
/* "uvloop/errors.pyx":36
* exc = FileExistsError
*
* elif uverr == uv.UV_ENOENT: # <<<<<<<<<<<<<<
* exc = FileNotFoundError
*
*/
goto __pyx_L3;
}
/* "uvloop/errors.pyx":39
* exc = FileNotFoundError
*
* elif uverr == uv.UV_EINTR: # <<<<<<<<<<<<<<
* exc = InterruptedError
*
*/
__pyx_t_3 = ((__pyx_v_uverr == UV_EINTR) != 0);
if (__pyx_t_3) {
/* "uvloop/errors.pyx":40
*
* elif uverr == uv.UV_EINTR:
* exc = InterruptedError # <<<<<<<<<<<<<<
*
* elif uverr == uv.UV_EISDIR:
*/
__Pyx_INCREF(__pyx_builtin_InterruptedError);
__Pyx_DECREF_SET(__pyx_v_exc, __pyx_builtin_InterruptedError);
/* "uvloop/errors.pyx":39
* exc = FileNotFoundError
*
* elif uverr == uv.UV_EINTR: # <<<<<<<<<<<<<<
* exc = InterruptedError
*
*/
goto __pyx_L3;
}
/* "uvloop/errors.pyx":42
* exc = InterruptedError
*
* elif uverr == uv.UV_EISDIR: # <<<<<<<<<<<<<<
* exc = IsADirectoryError
*
*/
__pyx_t_3 = ((__pyx_v_uverr == UV_EISDIR) != 0);
if (__pyx_t_3) {
/* "uvloop/errors.pyx":43
*
* elif uverr == uv.UV_EISDIR:
* exc = IsADirectoryError # <<<<<<<<<<<<<<
*
* elif uverr == uv.UV_ESRCH:
*/
__Pyx_INCREF(__pyx_builtin_IsADirectoryError);
__Pyx_DECREF_SET(__pyx_v_exc, __pyx_builtin_IsADirectoryError);
/* "uvloop/errors.pyx":42
* exc = InterruptedError
*
* elif uverr == uv.UV_EISDIR: # <<<<<<<<<<<<<<
* exc = IsADirectoryError
*
*/
goto __pyx_L3;
}
/* "uvloop/errors.pyx":45
* exc = IsADirectoryError
*
* elif uverr == uv.UV_ESRCH: # <<<<<<<<<<<<<<
* exc = ProcessLookupError
*
*/
__pyx_t_3 = ((__pyx_v_uverr == UV_ESRCH) != 0);
if (__pyx_t_3) {
/* "uvloop/errors.pyx":46
*
* elif uverr == uv.UV_ESRCH:
* exc = ProcessLookupError # <<<<<<<<<<<<<<
*
* elif uverr == uv.UV_ETIMEDOUT:
*/
__Pyx_INCREF(__pyx_builtin_ProcessLookupError);
__Pyx_DECREF_SET(__pyx_v_exc, __pyx_builtin_ProcessLookupError);
/* "uvloop/errors.pyx":45
* exc = IsADirectoryError
*
* elif uverr == uv.UV_ESRCH: # <<<<<<<<<<<<<<
* exc = ProcessLookupError
*
*/
goto __pyx_L3;
}
/* "uvloop/errors.pyx":48
* exc = ProcessLookupError
*
* elif uverr == uv.UV_ETIMEDOUT: # <<<<<<<<<<<<<<
* exc = TimeoutError
*
*/
__pyx_t_3 = ((__pyx_v_uverr == UV_ETIMEDOUT) != 0);
if (__pyx_t_3) {
/* "uvloop/errors.pyx":49
*
* elif uverr == uv.UV_ETIMEDOUT:
* exc = TimeoutError # <<<<<<<<<<<<<<
*
* return exc(oserr, __strerr(oserr))
*/
__Pyx_INCREF(__pyx_builtin_TimeoutError);
__Pyx_DECREF_SET(__pyx_v_exc, __pyx_builtin_TimeoutError);
/* "uvloop/errors.pyx":48
* exc = ProcessLookupError
*
* elif uverr == uv.UV_ETIMEDOUT: # <<<<<<<<<<<<<<
* exc = TimeoutError
*
*/
}
__pyx_L3:;
/* "uvloop/errors.pyx":51
* exc = TimeoutError
*
* return exc(oserr, __strerr(oserr)) # <<<<<<<<<<<<<<
*
*
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_oserr); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 51, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = __pyx_f_6uvloop_4loop___strerr(__pyx_v_oserr); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 51, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_v_exc);
__pyx_t_7 = __pyx_v_exc; __pyx_t_8 = NULL;
__pyx_t_1 = 0;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
__pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_8)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_8);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_7, function);
__pyx_t_1 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_7)) {
PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_5, __pyx_t_6};
__pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_1, 2+__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 51, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_5, __pyx_t_6};
__pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_1, 2+__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 51, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else
#endif
{
__pyx_t_9 = PyTuple_New(2+__pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 51, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
if (__pyx_t_8) {
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL;
}
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_1, __pyx_t_5);
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_1, __pyx_t_6);
__pyx_t_5 = 0;
__pyx_t_6 = 0;
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 51, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_r = __pyx_t_4;
__pyx_t_4 = 0;
goto __pyx_L0;
/* "uvloop/errors.pyx":5
*
*
* cdef __convert_python_error(int uverr): # <<<<<<<<<<<<<<
* # XXX Won't work for Windows:
* # From libuv docs:
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_XDECREF(__pyx_t_9);
__Pyx_AddTraceback("uvloop.loop.__convert_python_error", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_exc);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/errors.pyx":54
*
*
* cdef int __convert_socket_error(int uverr): # <<<<<<<<<<<<<<
* cdef int sock_err = 0
*
*/
static int __pyx_f_6uvloop_4loop___convert_socket_error(int __pyx_v_uverr) {
int __pyx_v_sock_err;
int __pyx_r;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
__Pyx_RefNannySetupContext("__convert_socket_error", 0);
/* "uvloop/errors.pyx":55
*
* cdef int __convert_socket_error(int uverr):
* cdef int sock_err = 0 # <<<<<<<<<<<<<<
*
* if uverr == uv.UV_EAI_ADDRFAMILY:
*/
__pyx_v_sock_err = 0;
/* "uvloop/errors.pyx":57
* cdef int sock_err = 0
*
* if uverr == uv.UV_EAI_ADDRFAMILY: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_ADDRFAMILY
*
*/
__pyx_t_1 = ((__pyx_v_uverr == UV_EAI_ADDRFAMILY) != 0);
if (__pyx_t_1) {
/* "uvloop/errors.pyx":58
*
* if uverr == uv.UV_EAI_ADDRFAMILY:
* sock_err = socket_EAI_ADDRFAMILY # <<<<<<<<<<<<<<
*
* elif uverr == uv.UV_EAI_AGAIN:
*/
__pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_ADDRFAMILY;
/* "uvloop/errors.pyx":57
* cdef int sock_err = 0
*
* if uverr == uv.UV_EAI_ADDRFAMILY: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_ADDRFAMILY
*
*/
goto __pyx_L3;
}
/* "uvloop/errors.pyx":60
* sock_err = socket_EAI_ADDRFAMILY
*
* elif uverr == uv.UV_EAI_AGAIN: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_AGAIN
*
*/
__pyx_t_1 = ((__pyx_v_uverr == UV_EAI_AGAIN) != 0);
if (__pyx_t_1) {
/* "uvloop/errors.pyx":61
*
* elif uverr == uv.UV_EAI_AGAIN:
* sock_err = socket_EAI_AGAIN # <<<<<<<<<<<<<<
*
* elif uverr == uv.UV_EAI_BADFLAGS:
*/
__pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_AGAIN;
/* "uvloop/errors.pyx":60
* sock_err = socket_EAI_ADDRFAMILY
*
* elif uverr == uv.UV_EAI_AGAIN: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_AGAIN
*
*/
goto __pyx_L3;
}
/* "uvloop/errors.pyx":63
* sock_err = socket_EAI_AGAIN
*
* elif uverr == uv.UV_EAI_BADFLAGS: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_BADFLAGS
*
*/
__pyx_t_1 = ((__pyx_v_uverr == UV_EAI_BADFLAGS) != 0);
if (__pyx_t_1) {
/* "uvloop/errors.pyx":64
*
* elif uverr == uv.UV_EAI_BADFLAGS:
* sock_err = socket_EAI_BADFLAGS # <<<<<<<<<<<<<<
*
* elif uverr == uv.UV_EAI_BADHINTS:
*/
__pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_BADFLAGS;
/* "uvloop/errors.pyx":63
* sock_err = socket_EAI_AGAIN
*
* elif uverr == uv.UV_EAI_BADFLAGS: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_BADFLAGS
*
*/
goto __pyx_L3;
}
/* "uvloop/errors.pyx":66
* sock_err = socket_EAI_BADFLAGS
*
* elif uverr == uv.UV_EAI_BADHINTS: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_BADHINTS
*
*/
__pyx_t_1 = ((__pyx_v_uverr == UV_EAI_BADHINTS) != 0);
if (__pyx_t_1) {
/* "uvloop/errors.pyx":67
*
* elif uverr == uv.UV_EAI_BADHINTS:
* sock_err = socket_EAI_BADHINTS # <<<<<<<<<<<<<<
*
* elif uverr == uv.UV_EAI_CANCELED:
*/
__pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_BADHINTS;
/* "uvloop/errors.pyx":66
* sock_err = socket_EAI_BADFLAGS
*
* elif uverr == uv.UV_EAI_BADHINTS: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_BADHINTS
*
*/
goto __pyx_L3;
}
/* "uvloop/errors.pyx":69
* sock_err = socket_EAI_BADHINTS
*
* elif uverr == uv.UV_EAI_CANCELED: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_CANCELED
*
*/
__pyx_t_1 = ((__pyx_v_uverr == UV_EAI_CANCELED) != 0);
if (__pyx_t_1) {
/* "uvloop/errors.pyx":70
*
* elif uverr == uv.UV_EAI_CANCELED:
* sock_err = socket_EAI_CANCELED # <<<<<<<<<<<<<<
*
* elif uverr == uv.UV_EAI_FAIL:
*/
__pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_CANCELED;
/* "uvloop/errors.pyx":69
* sock_err = socket_EAI_BADHINTS
*
* elif uverr == uv.UV_EAI_CANCELED: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_CANCELED
*
*/
goto __pyx_L3;
}
/* "uvloop/errors.pyx":72
* sock_err = socket_EAI_CANCELED
*
* elif uverr == uv.UV_EAI_FAIL: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_FAIL
*
*/
__pyx_t_1 = ((__pyx_v_uverr == UV_EAI_FAIL) != 0);
if (__pyx_t_1) {
/* "uvloop/errors.pyx":73
*
* elif uverr == uv.UV_EAI_FAIL:
* sock_err = socket_EAI_FAIL # <<<<<<<<<<<<<<
*
* elif uverr == uv.UV_EAI_FAMILY:
*/
__pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_FAIL;
/* "uvloop/errors.pyx":72
* sock_err = socket_EAI_CANCELED
*
* elif uverr == uv.UV_EAI_FAIL: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_FAIL
*
*/
goto __pyx_L3;
}
/* "uvloop/errors.pyx":75
* sock_err = socket_EAI_FAIL
*
* elif uverr == uv.UV_EAI_FAMILY: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_FAMILY
*
*/
__pyx_t_1 = ((__pyx_v_uverr == UV_EAI_FAMILY) != 0);
if (__pyx_t_1) {
/* "uvloop/errors.pyx":76
*
* elif uverr == uv.UV_EAI_FAMILY:
* sock_err = socket_EAI_FAMILY # <<<<<<<<<<<<<<
*
* elif uverr == uv.UV_EAI_MEMORY:
*/
__pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_FAMILY;
/* "uvloop/errors.pyx":75
* sock_err = socket_EAI_FAIL
*
* elif uverr == uv.UV_EAI_FAMILY: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_FAMILY
*
*/
goto __pyx_L3;
}
/* "uvloop/errors.pyx":78
* sock_err = socket_EAI_FAMILY
*
* elif uverr == uv.UV_EAI_MEMORY: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_MEMORY
*
*/
__pyx_t_1 = ((__pyx_v_uverr == UV_EAI_MEMORY) != 0);
if (__pyx_t_1) {
/* "uvloop/errors.pyx":79
*
* elif uverr == uv.UV_EAI_MEMORY:
* sock_err = socket_EAI_MEMORY # <<<<<<<<<<<<<<
*
* elif uverr == uv.UV_EAI_NODATA:
*/
__pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_MEMORY;
/* "uvloop/errors.pyx":78
* sock_err = socket_EAI_FAMILY
*
* elif uverr == uv.UV_EAI_MEMORY: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_MEMORY
*
*/
goto __pyx_L3;
}
/* "uvloop/errors.pyx":81
* sock_err = socket_EAI_MEMORY
*
* elif uverr == uv.UV_EAI_NODATA: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_NODATA
*
*/
__pyx_t_1 = ((__pyx_v_uverr == UV_EAI_NODATA) != 0);
if (__pyx_t_1) {
/* "uvloop/errors.pyx":82
*
* elif uverr == uv.UV_EAI_NODATA:
* sock_err = socket_EAI_NODATA # <<<<<<<<<<<<<<
*
* elif uverr == uv.UV_EAI_NONAME:
*/
__pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_NODATA;
/* "uvloop/errors.pyx":81
* sock_err = socket_EAI_MEMORY
*
* elif uverr == uv.UV_EAI_NODATA: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_NODATA
*
*/
goto __pyx_L3;
}
/* "uvloop/errors.pyx":84
* sock_err = socket_EAI_NODATA
*
* elif uverr == uv.UV_EAI_NONAME: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_NONAME
*
*/
__pyx_t_1 = ((__pyx_v_uverr == UV_EAI_NONAME) != 0);
if (__pyx_t_1) {
/* "uvloop/errors.pyx":85
*
* elif uverr == uv.UV_EAI_NONAME:
* sock_err = socket_EAI_NONAME # <<<<<<<<<<<<<<
*
* elif uverr == uv.UV_EAI_OVERFLOW:
*/
__pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_NONAME;
/* "uvloop/errors.pyx":84
* sock_err = socket_EAI_NODATA
*
* elif uverr == uv.UV_EAI_NONAME: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_NONAME
*
*/
goto __pyx_L3;
}
/* "uvloop/errors.pyx":87
* sock_err = socket_EAI_NONAME
*
* elif uverr == uv.UV_EAI_OVERFLOW: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_OVERFLOW
*
*/
__pyx_t_1 = ((__pyx_v_uverr == UV_EAI_OVERFLOW) != 0);
if (__pyx_t_1) {
/* "uvloop/errors.pyx":88
*
* elif uverr == uv.UV_EAI_OVERFLOW:
* sock_err = socket_EAI_OVERFLOW # <<<<<<<<<<<<<<
*
* elif uverr == uv.UV_EAI_PROTOCOL:
*/
__pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_OVERFLOW;
/* "uvloop/errors.pyx":87
* sock_err = socket_EAI_NONAME
*
* elif uverr == uv.UV_EAI_OVERFLOW: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_OVERFLOW
*
*/
goto __pyx_L3;
}
/* "uvloop/errors.pyx":90
* sock_err = socket_EAI_OVERFLOW
*
* elif uverr == uv.UV_EAI_PROTOCOL: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_PROTOCOL
*
*/
__pyx_t_1 = ((__pyx_v_uverr == UV_EAI_PROTOCOL) != 0);
if (__pyx_t_1) {
/* "uvloop/errors.pyx":91
*
* elif uverr == uv.UV_EAI_PROTOCOL:
* sock_err = socket_EAI_PROTOCOL # <<<<<<<<<<<<<<
*
* elif uverr == uv.UV_EAI_SERVICE:
*/
__pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_PROTOCOL;
/* "uvloop/errors.pyx":90
* sock_err = socket_EAI_OVERFLOW
*
* elif uverr == uv.UV_EAI_PROTOCOL: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_PROTOCOL
*
*/
goto __pyx_L3;
}
/* "uvloop/errors.pyx":93
* sock_err = socket_EAI_PROTOCOL
*
* elif uverr == uv.UV_EAI_SERVICE: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_SERVICE
*
*/
__pyx_t_1 = ((__pyx_v_uverr == UV_EAI_SERVICE) != 0);
if (__pyx_t_1) {
/* "uvloop/errors.pyx":94
*
* elif uverr == uv.UV_EAI_SERVICE:
* sock_err = socket_EAI_SERVICE # <<<<<<<<<<<<<<
*
* elif uverr == uv.UV_EAI_SOCKTYPE:
*/
__pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_SERVICE;
/* "uvloop/errors.pyx":93
* sock_err = socket_EAI_PROTOCOL
*
* elif uverr == uv.UV_EAI_SERVICE: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_SERVICE
*
*/
goto __pyx_L3;
}
/* "uvloop/errors.pyx":96
* sock_err = socket_EAI_SERVICE
*
* elif uverr == uv.UV_EAI_SOCKTYPE: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_SOCKTYPE
*
*/
__pyx_t_1 = ((__pyx_v_uverr == UV_EAI_SOCKTYPE) != 0);
if (__pyx_t_1) {
/* "uvloop/errors.pyx":97
*
* elif uverr == uv.UV_EAI_SOCKTYPE:
* sock_err = socket_EAI_SOCKTYPE # <<<<<<<<<<<<<<
*
* return sock_err
*/
__pyx_v_sock_err = __pyx_v_6uvloop_4loop_socket_EAI_SOCKTYPE;
/* "uvloop/errors.pyx":96
* sock_err = socket_EAI_SERVICE
*
* elif uverr == uv.UV_EAI_SOCKTYPE: # <<<<<<<<<<<<<<
* sock_err = socket_EAI_SOCKTYPE
*
*/
}
__pyx_L3:;
/* "uvloop/errors.pyx":99
* sock_err = socket_EAI_SOCKTYPE
*
* return sock_err # <<<<<<<<<<<<<<
*
*
*/
__pyx_r = __pyx_v_sock_err;
goto __pyx_L0;
/* "uvloop/errors.pyx":54
*
*
* cdef int __convert_socket_error(int uverr): # <<<<<<<<<<<<<<
* cdef int sock_err = 0
*
*/
/* function exit code */
__pyx_L0:;
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/errors.pyx":102
*
*
* cdef convert_error(int uverr): # <<<<<<<<<<<<<<
* cdef int sock_err
*
*/
static PyObject *__pyx_f_6uvloop_4loop_convert_error(int __pyx_v_uverr) {
int __pyx_v_sock_err;
PyObject *__pyx_v_msg = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
char const *__pyx_t_5;
PyObject *__pyx_t_6 = NULL;
int __pyx_t_7;
PyObject *__pyx_t_8 = NULL;
__Pyx_RefNannySetupContext("convert_error", 0);
/* "uvloop/errors.pyx":105
* cdef int sock_err
*
* if uverr == uv.UV_ECANCELED: # <<<<<<<<<<<<<<
* return aio_CancelledError()
*
*/
__pyx_t_1 = ((__pyx_v_uverr == UV_ECANCELED) != 0);
if (__pyx_t_1) {
/* "uvloop/errors.pyx":106
*
* if uverr == uv.UV_ECANCELED:
* return aio_CancelledError() # <<<<<<<<<<<<<<
*
* sock_err = __convert_socket_error(uverr)
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_CancelledError);
__pyx_t_3 = __pyx_v_6uvloop_4loop_aio_CancelledError; __pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (__pyx_t_4) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
__pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 106, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
/* "uvloop/errors.pyx":105
* cdef int sock_err
*
* if uverr == uv.UV_ECANCELED: # <<<<<<<<<<<<<<
* return aio_CancelledError()
*
*/
}
/* "uvloop/errors.pyx":108
* return aio_CancelledError()
*
* sock_err = __convert_socket_error(uverr) # <<<<<<<<<<<<<<
* if sock_err:
* msg = system.gai_strerror(sock_err).decode('utf-8')
*/
__pyx_v_sock_err = __pyx_f_6uvloop_4loop___convert_socket_error(__pyx_v_uverr);
/* "uvloop/errors.pyx":109
*
* sock_err = __convert_socket_error(uverr)
* if sock_err: # <<<<<<<<<<<<<<
* msg = system.gai_strerror(sock_err).decode('utf-8')
* return socket_gaierror(sock_err, msg)
*/
__pyx_t_1 = (__pyx_v_sock_err != 0);
if (__pyx_t_1) {
/* "uvloop/errors.pyx":110
* sock_err = __convert_socket_error(uverr)
* if sock_err:
* msg = system.gai_strerror(sock_err).decode('utf-8') # <<<<<<<<<<<<<<
* return socket_gaierror(sock_err, msg)
*
*/
__pyx_t_5 = gai_strerror(__pyx_v_sock_err);
__pyx_t_2 = __Pyx_decode_c_string(__pyx_t_5, 0, strlen(__pyx_t_5), NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 110, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_t_2);
__pyx_v_msg = __pyx_t_2;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/errors.pyx":111
* if sock_err:
* msg = system.gai_strerror(sock_err).decode('utf-8')
* return socket_gaierror(sock_err, msg) # <<<<<<<<<<<<<<
*
* return __convert_python_error(uverr)
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_sock_err); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 111, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_v_6uvloop_4loop_socket_gaierror);
__pyx_t_4 = __pyx_v_6uvloop_4loop_socket_gaierror; __pyx_t_6 = NULL;
__pyx_t_7 = 0;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
__pyx_t_7 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_v_msg};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 111, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_v_msg};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 111, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else
#endif
{
__pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 111, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
if (__pyx_t_6) {
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL;
}
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_3);
__Pyx_INCREF(__pyx_v_msg);
__Pyx_GIVEREF(__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_msg);
__pyx_t_3 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 111, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
/* "uvloop/errors.pyx":109
*
* sock_err = __convert_socket_error(uverr)
* if sock_err: # <<<<<<<<<<<<<<
* msg = system.gai_strerror(sock_err).decode('utf-8')
* return socket_gaierror(sock_err, msg)
*/
}
/* "uvloop/errors.pyx":113
* return socket_gaierror(sock_err, msg)
*
* return __convert_python_error(uverr) # <<<<<<<<<<<<<<
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_2 = __pyx_f_6uvloop_4loop___convert_python_error(__pyx_v_uverr); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 113, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
/* "uvloop/errors.pyx":102
*
*
* cdef convert_error(int uverr): # <<<<<<<<<<<<<<
* cdef int sock_err
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_AddTraceback("uvloop.loop.convert_error", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_msg);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":41
*
*
* cdef _is_sock_stream(sock_type): # <<<<<<<<<<<<<<
* # Linux's socket.type is a bitmask that can include extra info
* # about socket, therefore we can't do simple
*/
static PyObject *__pyx_f_6uvloop_4loop__is_sock_stream(PyObject *__pyx_v_sock_type) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
__Pyx_RefNannySetupContext("_is_sock_stream", 0);
/* "uvloop/loop.pyx":45
* # about socket, therefore we can't do simple
* # `sock_type == socket.SOCK_STREAM`.
* return (sock_type & uv.SOCK_STREAM) == uv.SOCK_STREAM # <<<<<<<<<<<<<<
*
*
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_int(SOCK_STREAM); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 45, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = PyNumber_And(__pyx_v_sock_type, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 45, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = __Pyx_PyInt_From_int(SOCK_STREAM); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 45, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_3 = PyObject_RichCompare(__pyx_t_2, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 45, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_r = __pyx_t_3;
__pyx_t_3 = 0;
goto __pyx_L0;
/* "uvloop/loop.pyx":41
*
*
* cdef _is_sock_stream(sock_type): # <<<<<<<<<<<<<<
* # Linux's socket.type is a bitmask that can include extra info
* # about socket, therefore we can't do simple
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_AddTraceback("uvloop.loop._is_sock_stream", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":48
*
*
* cdef _is_sock_dgram(sock_type): # <<<<<<<<<<<<<<
* # Linux's socket.type is a bitmask that can include extra info
* # about socket, therefore we can't do simple
*/
static PyObject *__pyx_f_6uvloop_4loop__is_sock_dgram(PyObject *__pyx_v_sock_type) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
__Pyx_RefNannySetupContext("_is_sock_dgram", 0);
/* "uvloop/loop.pyx":52
* # about socket, therefore we can't do simple
* # `sock_type == socket.SOCK_DGRAM`.
* return (sock_type & uv.SOCK_DGRAM) == uv.SOCK_DGRAM # <<<<<<<<<<<<<<
*
*
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_int(SOCK_DGRAM); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 52, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = PyNumber_And(__pyx_v_sock_type, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 52, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = __Pyx_PyInt_From_int(SOCK_DGRAM); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 52, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_3 = PyObject_RichCompare(__pyx_t_2, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 52, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_r = __pyx_t_3;
__pyx_t_3 = 0;
goto __pyx_L0;
/* "uvloop/loop.pyx":48
*
*
* cdef _is_sock_dgram(sock_type): # <<<<<<<<<<<<<<
* # Linux's socket.type is a bitmask that can include extra info
* # about socket, therefore we can't do simple
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_AddTraceback("uvloop.loop._is_sock_dgram", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":55
*
*
* cdef isfuture(obj): # <<<<<<<<<<<<<<
* if aio_isfuture is None:
* return isinstance(obj, aio_Future)
*/
static PyObject *__pyx_f_6uvloop_4loop_isfuture(PyObject *__pyx_v_obj) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
__Pyx_RefNannySetupContext("isfuture", 0);
/* "uvloop/loop.pyx":56
*
* cdef isfuture(obj):
* if aio_isfuture is None: # <<<<<<<<<<<<<<
* return isinstance(obj, aio_Future)
* else:
*/
__pyx_t_1 = (__pyx_v_6uvloop_4loop_aio_isfuture == Py_None);
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":57
* cdef isfuture(obj):
* if aio_isfuture is None:
* return isinstance(obj, aio_Future) # <<<<<<<<<<<<<<
* else:
* return aio_isfuture(obj)
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_3 = __pyx_v_6uvloop_4loop_aio_Future;
__Pyx_INCREF(__pyx_t_3);
__pyx_t_2 = PyObject_IsInstance(__pyx_v_obj, __pyx_t_3); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(1, 57, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = __Pyx_PyBool_FromLong(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 57, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_r = __pyx_t_3;
__pyx_t_3 = 0;
goto __pyx_L0;
/* "uvloop/loop.pyx":56
*
* cdef isfuture(obj):
* if aio_isfuture is None: # <<<<<<<<<<<<<<
* return isinstance(obj, aio_Future)
* else:
*/
}
/* "uvloop/loop.pyx":59
* return isinstance(obj, aio_Future)
* else:
* return aio_isfuture(obj) # <<<<<<<<<<<<<<
*
*
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_isfuture);
__pyx_t_4 = __pyx_v_6uvloop_4loop_aio_isfuture; __pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (!__pyx_t_5) {
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_obj); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 59, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_v_obj};
__pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 59, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_v_obj};
__pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 59, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else
#endif
{
__pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 59, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_INCREF(__pyx_v_obj);
__Pyx_GIVEREF(__pyx_v_obj);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_obj);
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 59, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_r = __pyx_t_3;
__pyx_t_3 = 0;
goto __pyx_L0;
}
/* "uvloop/loop.pyx":55
*
*
* cdef isfuture(obj): # <<<<<<<<<<<<<<
* if aio_isfuture is None:
* return isinstance(obj, aio_Future)
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_AddTraceback("uvloop.loop.isfuture", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":64
* @cython.no_gc_clear
* cdef class Loop:
* def __cinit__(self): # <<<<<<<<<<<<<<
* cdef int err
*
*/
/* Python wrapper */
static int __pyx_pw_6uvloop_4loop_4Loop_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_6uvloop_4loop_4Loop_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
int __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
__Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop___cinit__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static int __pyx_pf_6uvloop_4loop_4Loop___cinit__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
int __pyx_v_err;
int __pyx_r;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
int __pyx_t_5;
__Pyx_RefNannySetupContext("__cinit__", 0);
/* "uvloop/loop.pyx":68
*
* # Install PyMem* memory allocators if they aren't installed yet.
* __install_pymem() # <<<<<<<<<<<<<<
*
* # Install pthread_atfork handlers
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop___install_pymem(); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 68, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":71
*
* # Install pthread_atfork handlers
* __install_atfork() # <<<<<<<<<<<<<<
*
* self.uvloop = \
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop___install_atfork(); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 71, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":73
* __install_atfork()
*
* self.uvloop = \ # <<<<<<<<<<<<<<
* PyMem_RawMalloc(sizeof(uv.uv_loop_t))
* if self.uvloop is NULL:
*/
__pyx_v_self->uvloop = ((uv_loop_t *)PyMem_RawMalloc((sizeof(uv_loop_t))));
/* "uvloop/loop.pyx":75
* self.uvloop = \
* PyMem_RawMalloc(sizeof(uv.uv_loop_t))
* if self.uvloop is NULL: # <<<<<<<<<<<<<<
* raise MemoryError()
*
*/
__pyx_t_2 = ((__pyx_v_self->uvloop == NULL) != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":76
* PyMem_RawMalloc(sizeof(uv.uv_loop_t))
* if self.uvloop is NULL:
* raise MemoryError() # <<<<<<<<<<<<<<
*
* self.slow_callback_duration = 0.1
*/
PyErr_NoMemory(); __PYX_ERR(1, 76, __pyx_L1_error)
/* "uvloop/loop.pyx":75
* self.uvloop = \
* PyMem_RawMalloc(sizeof(uv.uv_loop_t))
* if self.uvloop is NULL: # <<<<<<<<<<<<<<
* raise MemoryError()
*
*/
}
/* "uvloop/loop.pyx":78
* raise MemoryError()
*
* self.slow_callback_duration = 0.1 # <<<<<<<<<<<<<<
*
* self._closed = 0
*/
__Pyx_INCREF(__pyx_float_0_1);
__Pyx_GIVEREF(__pyx_float_0_1);
__Pyx_GOTREF(__pyx_v_self->slow_callback_duration);
__Pyx_DECREF(__pyx_v_self->slow_callback_duration);
__pyx_v_self->slow_callback_duration = __pyx_float_0_1;
/* "uvloop/loop.pyx":80
* self.slow_callback_duration = 0.1
*
* self._closed = 0 # <<<<<<<<<<<<<<
* self._debug = 0
* self._thread_is_main = 0
*/
__pyx_v_self->_closed = 0;
/* "uvloop/loop.pyx":81
*
* self._closed = 0
* self._debug = 0 # <<<<<<<<<<<<<<
* self._thread_is_main = 0
* self._thread_id = 0
*/
__pyx_v_self->_debug = 0;
/* "uvloop/loop.pyx":82
* self._closed = 0
* self._debug = 0
* self._thread_is_main = 0 # <<<<<<<<<<<<<<
* self._thread_id = 0
* self._running = 0
*/
__pyx_v_self->_thread_is_main = 0;
/* "uvloop/loop.pyx":83
* self._debug = 0
* self._thread_is_main = 0
* self._thread_id = 0 # <<<<<<<<<<<<<<
* self._running = 0
* self._stopping = 0
*/
__pyx_v_self->_thread_id = 0;
/* "uvloop/loop.pyx":84
* self._thread_is_main = 0
* self._thread_id = 0
* self._running = 0 # <<<<<<<<<<<<<<
* self._stopping = 0
*
*/
__pyx_v_self->_running = 0;
/* "uvloop/loop.pyx":85
* self._thread_id = 0
* self._running = 0
* self._stopping = 0 # <<<<<<<<<<<<<<
*
* self._transports = weakref_WeakValueDictionary()
*/
__pyx_v_self->_stopping = 0;
/* "uvloop/loop.pyx":87
* self._stopping = 0
*
* self._transports = weakref_WeakValueDictionary() # <<<<<<<<<<<<<<
*
* self._timers = set()
*/
__Pyx_INCREF(__pyx_v_6uvloop_4loop_weakref_WeakValueDictionary);
__pyx_t_3 = __pyx_v_6uvloop_4loop_weakref_WeakValueDictionary; __pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (__pyx_t_4) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 87, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 87, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GIVEREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_v_self->_transports);
__Pyx_DECREF(__pyx_v_self->_transports);
__pyx_v_self->_transports = __pyx_t_1;
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":89
* self._transports = weakref_WeakValueDictionary()
*
* self._timers = set() # <<<<<<<<<<<<<<
* self._polls = dict()
*
*/
__pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 89, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_v_self->_timers);
__Pyx_DECREF(__pyx_v_self->_timers);
__pyx_v_self->_timers = ((PyObject*)__pyx_t_1);
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":90
*
* self._timers = set()
* self._polls = dict() # <<<<<<<<<<<<<<
*
* self._recv_buffer_in_use = 0
*/
__pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 90, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_v_self->_polls);
__Pyx_DECREF(__pyx_v_self->_polls);
__pyx_v_self->_polls = ((PyObject*)__pyx_t_1);
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":92
* self._polls = dict()
*
* self._recv_buffer_in_use = 0 # <<<<<<<<<<<<<<
*
* err = uv.uv_loop_init(self.uvloop)
*/
__pyx_v_self->_recv_buffer_in_use = 0;
/* "uvloop/loop.pyx":94
* self._recv_buffer_in_use = 0
*
* err = uv.uv_loop_init(self.uvloop) # <<<<<<<<<<<<<<
* if err < 0:
* raise convert_error(err)
*/
__pyx_v_err = uv_loop_init(__pyx_v_self->uvloop);
/* "uvloop/loop.pyx":95
*
* err = uv.uv_loop_init(self.uvloop)
* if err < 0: # <<<<<<<<<<<<<<
* raise convert_error(err)
* self.uvloop.data = self
*/
__pyx_t_2 = ((__pyx_v_err < 0) != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":96
* err = uv.uv_loop_init(self.uvloop)
* if err < 0:
* raise convert_error(err) # <<<<<<<<<<<<<<
* self.uvloop.data = self
*
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 96, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__PYX_ERR(1, 96, __pyx_L1_error)
/* "uvloop/loop.pyx":95
*
* err = uv.uv_loop_init(self.uvloop)
* if err < 0: # <<<<<<<<<<<<<<
* raise convert_error(err)
* self.uvloop.data = self
*/
}
/* "uvloop/loop.pyx":97
* if err < 0:
* raise convert_error(err)
* self.uvloop.data = self # <<<<<<<<<<<<<<
*
* self._init_debug_fields()
*/
__pyx_v_self->uvloop->data = ((void *)__pyx_v_self);
/* "uvloop/loop.pyx":99
* self.uvloop.data = self
*
* self._init_debug_fields() # <<<<<<<<<<<<<<
*
* self.active_process_handler = None
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_init_debug_fields(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 99, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":101
* self._init_debug_fields()
*
* self.active_process_handler = None # <<<<<<<<<<<<<<
*
* self._last_error = None
*/
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__Pyx_GOTREF(__pyx_v_self->active_process_handler);
__Pyx_DECREF(((PyObject *)__pyx_v_self->active_process_handler));
__pyx_v_self->active_process_handler = ((struct __pyx_obj_6uvloop_4loop_UVProcess *)Py_None);
/* "uvloop/loop.pyx":103
* self.active_process_handler = None
*
* self._last_error = None # <<<<<<<<<<<<<<
*
* self._task_factory = None
*/
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__Pyx_GOTREF(__pyx_v_self->_last_error);
__Pyx_DECREF(__pyx_v_self->_last_error);
__pyx_v_self->_last_error = Py_None;
/* "uvloop/loop.pyx":105
* self._last_error = None
*
* self._task_factory = None # <<<<<<<<<<<<<<
* self._exception_handler = None
* self._default_executor = None
*/
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__Pyx_GOTREF(__pyx_v_self->_task_factory);
__Pyx_DECREF(__pyx_v_self->_task_factory);
__pyx_v_self->_task_factory = Py_None;
/* "uvloop/loop.pyx":106
*
* self._task_factory = None
* self._exception_handler = None # <<<<<<<<<<<<<<
* self._default_executor = None
*
*/
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__Pyx_GOTREF(__pyx_v_self->_exception_handler);
__Pyx_DECREF(__pyx_v_self->_exception_handler);
__pyx_v_self->_exception_handler = Py_None;
/* "uvloop/loop.pyx":107
* self._task_factory = None
* self._exception_handler = None
* self._default_executor = None # <<<<<<<<<<<<<<
*
* self._queued_streams = set()
*/
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__Pyx_GOTREF(__pyx_v_self->_default_executor);
__Pyx_DECREF(__pyx_v_self->_default_executor);
__pyx_v_self->_default_executor = Py_None;
/* "uvloop/loop.pyx":109
* self._default_executor = None
*
* self._queued_streams = set() # <<<<<<<<<<<<<<
* self._ready = col_deque()
* self._ready_len = 0
*/
__pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 109, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_v_self->_queued_streams);
__Pyx_DECREF(__pyx_v_self->_queued_streams);
__pyx_v_self->_queued_streams = ((PyObject*)__pyx_t_1);
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":110
*
* self._queued_streams = set()
* self._ready = col_deque() # <<<<<<<<<<<<<<
* self._ready_len = 0
*
*/
__Pyx_INCREF(__pyx_v_6uvloop_4loop_col_deque);
__pyx_t_3 = __pyx_v_6uvloop_4loop_col_deque; __pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (__pyx_t_4) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 110, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 110, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GIVEREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_v_self->_ready);
__Pyx_DECREF(__pyx_v_self->_ready);
__pyx_v_self->_ready = __pyx_t_1;
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":111
* self._queued_streams = set()
* self._ready = col_deque()
* self._ready_len = 0 # <<<<<<<<<<<<<<
*
* self.handler_async = UVAsync.new(
*/
__pyx_v_self->_ready_len = 0;
/* "uvloop/loop.pyx":113
* self._ready_len = 0
*
* self.handler_async = UVAsync.new( # <<<<<<<<<<<<<<
* self, self._on_wake, self)
*
*/
__pyx_t_1 = ((PyObject *)__pyx_f_6uvloop_4loop_7UVAsync_new(__pyx_v_self, ((__pyx_t_6uvloop_4loop_method_t)((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_on_wake), ((PyObject *)__pyx_v_self))); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 113, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_v_self->handler_async);
__Pyx_DECREF(((PyObject *)__pyx_v_self->handler_async));
__pyx_v_self->handler_async = ((struct __pyx_obj_6uvloop_4loop_UVAsync *)__pyx_t_1);
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":118
* self.handler_idle = UVIdle.new(
* self,
* new_MethodHandle( # <<<<<<<<<<<<<<
* self, "loop._on_idle", self._on_idle, self))
*
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_new_MethodHandle(__pyx_v_self, __pyx_kp_u_loop__on_idle, ((__pyx_t_6uvloop_4loop_method_t)((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_on_idle), ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 118, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(1, 118, __pyx_L1_error)
/* "uvloop/loop.pyx":116
* self, self._on_wake, self)
*
* self.handler_idle = UVIdle.new( # <<<<<<<<<<<<<<
* self,
* new_MethodHandle(
*/
__pyx_t_3 = ((PyObject *)__pyx_f_6uvloop_4loop_6UVIdle_new(__pyx_v_self, ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_1))); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 116, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_GIVEREF(__pyx_t_3);
__Pyx_GOTREF(__pyx_v_self->handler_idle);
__Pyx_DECREF(((PyObject *)__pyx_v_self->handler_idle));
__pyx_v_self->handler_idle = ((struct __pyx_obj_6uvloop_4loop_UVIdle *)__pyx_t_3);
__pyx_t_3 = 0;
/* "uvloop/loop.pyx":125
* self.handler_check__exec_writes = UVCheck.new(
* self,
* new_MethodHandle( # <<<<<<<<<<<<<<
* self, "loop._exec_queued_writes",
* self._exec_queued_writes, self))
*/
__pyx_t_3 = __pyx_f_6uvloop_4loop_new_MethodHandle(__pyx_v_self, __pyx_kp_u_loop__exec_queued_writes, ((__pyx_t_6uvloop_4loop_method_t)((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_exec_queued_writes), ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 125, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(1, 125, __pyx_L1_error)
/* "uvloop/loop.pyx":123
* # Needed to call `UVStream._exec_write` for writes scheduled
* # during `Protocol.data_received`.
* self.handler_check__exec_writes = UVCheck.new( # <<<<<<<<<<<<<<
* self,
* new_MethodHandle(
*/
__pyx_t_1 = ((PyObject *)__pyx_f_6uvloop_4loop_7UVCheck_new(__pyx_v_self, ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_3))); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 123, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GIVEREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_v_self->handler_check__exec_writes);
__Pyx_DECREF(((PyObject *)__pyx_v_self->handler_check__exec_writes));
__pyx_v_self->handler_check__exec_writes = ((struct __pyx_obj_6uvloop_4loop_UVCheck *)__pyx_t_1);
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":129
* self._exec_queued_writes, self))
*
* self._ssock = self._csock = None # <<<<<<<<<<<<<<
* self._signal_handlers = None
*
*/
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__Pyx_GOTREF(__pyx_v_self->_ssock);
__Pyx_DECREF(__pyx_v_self->_ssock);
__pyx_v_self->_ssock = Py_None;
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__Pyx_GOTREF(__pyx_v_self->_csock);
__Pyx_DECREF(__pyx_v_self->_csock);
__pyx_v_self->_csock = Py_None;
/* "uvloop/loop.pyx":130
*
* self._ssock = self._csock = None
* self._signal_handlers = None # <<<<<<<<<<<<<<
*
* self._coroutine_wrapper_set = False
*/
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__Pyx_GOTREF(__pyx_v_self->_signal_handlers);
__Pyx_DECREF(__pyx_v_self->_signal_handlers);
__pyx_v_self->_signal_handlers = ((PyObject*)Py_None);
/* "uvloop/loop.pyx":132
* self._signal_handlers = None
*
* self._coroutine_wrapper_set = False # <<<<<<<<<<<<<<
*
* if hasattr(sys, 'get_asyncgen_hooks'):
*/
__pyx_v_self->_coroutine_wrapper_set = 0;
/* "uvloop/loop.pyx":134
* self._coroutine_wrapper_set = False
*
* if hasattr(sys, 'get_asyncgen_hooks'): # <<<<<<<<<<<<<<
* # Python >= 3.6
* # A weak set of all asynchronous generators that are
*/
__pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 134, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = PyObject_HasAttr(__pyx_t_1, __pyx_n_u_get_asyncgen_hooks); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(1, 134, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_5 = (__pyx_t_2 != 0);
if (__pyx_t_5) {
/* "uvloop/loop.pyx":138
* # A weak set of all asynchronous generators that are
* # being iterated by the loop.
* self._asyncgens = weakref_WeakSet() # <<<<<<<<<<<<<<
* else:
* self._asyncgens = None
*/
__Pyx_INCREF(__pyx_v_6uvloop_4loop_weakref_WeakSet);
__pyx_t_3 = __pyx_v_6uvloop_4loop_weakref_WeakSet; __pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (__pyx_t_4) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 138, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 138, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GIVEREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_v_self->_asyncgens);
__Pyx_DECREF(__pyx_v_self->_asyncgens);
__pyx_v_self->_asyncgens = __pyx_t_1;
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":134
* self._coroutine_wrapper_set = False
*
* if hasattr(sys, 'get_asyncgen_hooks'): # <<<<<<<<<<<<<<
* # Python >= 3.6
* # A weak set of all asynchronous generators that are
*/
goto __pyx_L5;
}
/* "uvloop/loop.pyx":140
* self._asyncgens = weakref_WeakSet()
* else:
* self._asyncgens = None # <<<<<<<<<<<<<<
*
* # Set to True when `loop.shutdown_asyncgens` is called.
*/
/*else*/ {
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__Pyx_GOTREF(__pyx_v_self->_asyncgens);
__Pyx_DECREF(__pyx_v_self->_asyncgens);
__pyx_v_self->_asyncgens = Py_None;
}
__pyx_L5:;
/* "uvloop/loop.pyx":143
*
* # Set to True when `loop.shutdown_asyncgens` is called.
* self._asyncgens_shutdown_called = False # <<<<<<<<<<<<<<
*
* def __init__(self):
*/
__pyx_v_self->_asyncgens_shutdown_called = 0;
/* "uvloop/loop.pyx":64
* @cython.no_gc_clear
* cdef class Loop:
* def __cinit__(self): # <<<<<<<<<<<<<<
* cdef int err
*
*/
/* function exit code */
__pyx_r = 0;
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_AddTraceback("uvloop.loop.Loop.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = -1;
__pyx_L0:;
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":145
* self._asyncgens_shutdown_called = False
*
* def __init__(self): # <<<<<<<<<<<<<<
* self.set_debug((not sys_ignore_environment
* and bool(os_environ.get('PYTHONASYNCIODEBUG'))))
*/
/* Python wrapper */
static int __pyx_pw_6uvloop_4loop_4Loop_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_6uvloop_4loop_4Loop_3__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
int __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
__Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1;
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_2__init__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static int __pyx_pf_6uvloop_4loop_4Loop_2__init__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
int __pyx_r;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
int __pyx_t_4;
int __pyx_t_5;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
__Pyx_RefNannySetupContext("__init__", 0);
/* "uvloop/loop.pyx":146
*
* def __init__(self):
* self.set_debug((not sys_ignore_environment # <<<<<<<<<<<<<<
* and bool(os_environ.get('PYTHONASYNCIODEBUG'))))
*
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_debug); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 146, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
/* "uvloop/loop.pyx":147
* def __init__(self):
* self.set_debug((not sys_ignore_environment
* and bool(os_environ.get('PYTHONASYNCIODEBUG')))) # <<<<<<<<<<<<<<
*
* def __dealloc__(self):
*/
__pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_6uvloop_4loop_sys_ignore_environment); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 147, __pyx_L1_error)
/* "uvloop/loop.pyx":146
*
* def __init__(self):
* self.set_debug((not sys_ignore_environment # <<<<<<<<<<<<<<
* and bool(os_environ.get('PYTHONASYNCIODEBUG'))))
*
*/
__pyx_t_5 = (!__pyx_t_4);
if (__pyx_t_5) {
} else {
__pyx_t_6 = __Pyx_PyBool_FromLong(__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 146, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_3 = __pyx_t_6;
__pyx_t_6 = 0;
goto __pyx_L3_bool_binop_done;
}
/* "uvloop/loop.pyx":147
* def __init__(self):
* self.set_debug((not sys_ignore_environment
* and bool(os_environ.get('PYTHONASYNCIODEBUG')))) # <<<<<<<<<<<<<<
*
* def __dealloc__(self):
*/
__pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_os_environ, __pyx_n_s_get); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 147, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 147, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(1, 147, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_7 = __Pyx_PyBool_FromLong((!(!__pyx_t_5))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 147, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_INCREF(__pyx_t_7);
__pyx_t_3 = __pyx_t_7;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_L3_bool_binop_done:;
__pyx_t_7 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_7)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_7);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (!__pyx_t_7) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 146, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_3};
__pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 146, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_3};
__pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 146, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else
#endif
{
__pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 146, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7); __pyx_t_7 = NULL;
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3);
__pyx_t_3 = 0;
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 146, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":145
* self._asyncgens_shutdown_called = False
*
* def __init__(self): # <<<<<<<<<<<<<<
* self.set_debug((not sys_ignore_environment
* and bool(os_environ.get('PYTHONASYNCIODEBUG'))))
*/
/* function exit code */
__pyx_r = 0;
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_AddTraceback("uvloop.loop.Loop.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = -1;
__pyx_L0:;
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":149
* and bool(os_environ.get('PYTHONASYNCIODEBUG'))))
*
* def __dealloc__(self): # <<<<<<<<<<<<<<
* if self._running == 1:
* raise RuntimeError('deallocating a running event loop!')
*/
/* Python wrapper */
static void __pyx_pw_6uvloop_4loop_4Loop_5__dealloc__(PyObject *__pyx_v_self); /*proto*/
static void __pyx_pw_6uvloop_4loop_4Loop_5__dealloc__(PyObject *__pyx_v_self) {
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
__pyx_pf_6uvloop_4loop_4Loop_4__dealloc__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
}
static void __pyx_pf_6uvloop_4loop_4Loop_4__dealloc__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
__Pyx_RefNannySetupContext("__dealloc__", 0);
/* "uvloop/loop.pyx":150
*
* def __dealloc__(self):
* if self._running == 1: # <<<<<<<<<<<<<<
* raise RuntimeError('deallocating a running event loop!')
* if self._closed == 0:
*/
__pyx_t_1 = ((__pyx_v_self->_running == 1) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":151
* def __dealloc__(self):
* if self._running == 1:
* raise RuntimeError('deallocating a running event loop!') # <<<<<<<<<<<<<<
* if self._closed == 0:
* aio_logger.error("deallocating an open event loop")
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 151, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__PYX_ERR(1, 151, __pyx_L1_error)
/* "uvloop/loop.pyx":150
*
* def __dealloc__(self):
* if self._running == 1: # <<<<<<<<<<<<<<
* raise RuntimeError('deallocating a running event loop!')
* if self._closed == 0:
*/
}
/* "uvloop/loop.pyx":152
* if self._running == 1:
* raise RuntimeError('deallocating a running event loop!')
* if self._closed == 0: # <<<<<<<<<<<<<<
* aio_logger.error("deallocating an open event loop")
* return
*/
__pyx_t_1 = ((__pyx_v_self->_closed == 0) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":153
* raise RuntimeError('deallocating a running event loop!')
* if self._closed == 0:
* aio_logger.error("deallocating an open event loop") # <<<<<<<<<<<<<<
* return
* PyMem_RawFree(self.uvloop)
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_error); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 153, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 153, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":154
* if self._closed == 0:
* aio_logger.error("deallocating an open event loop")
* return # <<<<<<<<<<<<<<
* PyMem_RawFree(self.uvloop)
* self.uvloop = NULL
*/
goto __pyx_L0;
/* "uvloop/loop.pyx":152
* if self._running == 1:
* raise RuntimeError('deallocating a running event loop!')
* if self._closed == 0: # <<<<<<<<<<<<<<
* aio_logger.error("deallocating an open event loop")
* return
*/
}
/* "uvloop/loop.pyx":155
* aio_logger.error("deallocating an open event loop")
* return
* PyMem_RawFree(self.uvloop) # <<<<<<<<<<<<<<
* self.uvloop = NULL
*
*/
PyMem_RawFree(__pyx_v_self->uvloop);
/* "uvloop/loop.pyx":156
* return
* PyMem_RawFree(self.uvloop)
* self.uvloop = NULL # <<<<<<<<<<<<<<
*
* cdef _init_debug_fields(self):
*/
__pyx_v_self->uvloop = NULL;
/* "uvloop/loop.pyx":149
* and bool(os_environ.get('PYTHONASYNCIODEBUG'))))
*
* def __dealloc__(self): # <<<<<<<<<<<<<<
* if self._running == 1:
* raise RuntimeError('deallocating a running event loop!')
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_WriteUnraisable("uvloop.loop.Loop.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
__pyx_L0:;
__Pyx_RefNannyFinishContext();
}
/* "uvloop/loop.pyx":158
* self.uvloop = NULL
*
* cdef _init_debug_fields(self): # <<<<<<<<<<<<<<
* self._debug_cc = bool(UVLOOP_DEBUG)
*
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__init_debug_fields(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
__Pyx_RefNannySetupContext("_init_debug_fields", 0);
/* "uvloop/loop.pyx":159
*
* cdef _init_debug_fields(self):
* self._debug_cc = bool(UVLOOP_DEBUG) # <<<<<<<<<<<<<<
*
* if UVLOOP_DEBUG:
*/
__pyx_t_1 = __Pyx_PyInt_From_int(UVLOOP_DEBUG); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 159, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 159, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_self->_debug_cc = (!(!__pyx_t_2));
/* "uvloop/loop.pyx":161
* self._debug_cc = bool(UVLOOP_DEBUG)
*
* if UVLOOP_DEBUG: # <<<<<<<<<<<<<<
* self._debug_handles_current = col_Counter()
* self._debug_handles_closed = col_Counter()
*/
__pyx_t_2 = (UVLOOP_DEBUG != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":162
*
* if UVLOOP_DEBUG:
* self._debug_handles_current = col_Counter() # <<<<<<<<<<<<<<
* self._debug_handles_closed = col_Counter()
* self._debug_handles_total = col_Counter()
*/
__Pyx_INCREF(__pyx_v_6uvloop_4loop_col_Counter);
__pyx_t_3 = __pyx_v_6uvloop_4loop_col_Counter; __pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (__pyx_t_4) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 162, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 162, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GIVEREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_v_self->_debug_handles_current);
__Pyx_DECREF(__pyx_v_self->_debug_handles_current);
__pyx_v_self->_debug_handles_current = __pyx_t_1;
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":163
* if UVLOOP_DEBUG:
* self._debug_handles_current = col_Counter()
* self._debug_handles_closed = col_Counter() # <<<<<<<<<<<<<<
* self._debug_handles_total = col_Counter()
* else:
*/
__Pyx_INCREF(__pyx_v_6uvloop_4loop_col_Counter);
__pyx_t_3 = __pyx_v_6uvloop_4loop_col_Counter; __pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (__pyx_t_4) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 163, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 163, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GIVEREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_v_self->_debug_handles_closed);
__Pyx_DECREF(__pyx_v_self->_debug_handles_closed);
__pyx_v_self->_debug_handles_closed = __pyx_t_1;
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":164
* self._debug_handles_current = col_Counter()
* self._debug_handles_closed = col_Counter()
* self._debug_handles_total = col_Counter() # <<<<<<<<<<<<<<
* else:
* self._debug_handles_current = None
*/
__Pyx_INCREF(__pyx_v_6uvloop_4loop_col_Counter);
__pyx_t_3 = __pyx_v_6uvloop_4loop_col_Counter; __pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (__pyx_t_4) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 164, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 164, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GIVEREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_v_self->_debug_handles_total);
__Pyx_DECREF(__pyx_v_self->_debug_handles_total);
__pyx_v_self->_debug_handles_total = __pyx_t_1;
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":161
* self._debug_cc = bool(UVLOOP_DEBUG)
*
* if UVLOOP_DEBUG: # <<<<<<<<<<<<<<
* self._debug_handles_current = col_Counter()
* self._debug_handles_closed = col_Counter()
*/
goto __pyx_L3;
}
/* "uvloop/loop.pyx":166
* self._debug_handles_total = col_Counter()
* else:
* self._debug_handles_current = None # <<<<<<<<<<<<<<
* self._debug_handles_closed = None
* self._debug_handles_total = None
*/
/*else*/ {
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__Pyx_GOTREF(__pyx_v_self->_debug_handles_current);
__Pyx_DECREF(__pyx_v_self->_debug_handles_current);
__pyx_v_self->_debug_handles_current = Py_None;
/* "uvloop/loop.pyx":167
* else:
* self._debug_handles_current = None
* self._debug_handles_closed = None # <<<<<<<<<<<<<<
* self._debug_handles_total = None
*
*/
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__Pyx_GOTREF(__pyx_v_self->_debug_handles_closed);
__Pyx_DECREF(__pyx_v_self->_debug_handles_closed);
__pyx_v_self->_debug_handles_closed = Py_None;
/* "uvloop/loop.pyx":168
* self._debug_handles_current = None
* self._debug_handles_closed = None
* self._debug_handles_total = None # <<<<<<<<<<<<<<
*
* self._debug_uv_handles_total = 0
*/
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__Pyx_GOTREF(__pyx_v_self->_debug_handles_total);
__Pyx_DECREF(__pyx_v_self->_debug_handles_total);
__pyx_v_self->_debug_handles_total = Py_None;
}
__pyx_L3:;
/* "uvloop/loop.pyx":170
* self._debug_handles_total = None
*
* self._debug_uv_handles_total = 0 # <<<<<<<<<<<<<<
* self._debug_uv_handles_freed = 0
*
*/
__pyx_v_self->_debug_uv_handles_total = 0;
/* "uvloop/loop.pyx":171
*
* self._debug_uv_handles_total = 0
* self._debug_uv_handles_freed = 0 # <<<<<<<<<<<<<<
*
* self._debug_stream_read_cb_total = 0
*/
__pyx_v_self->_debug_uv_handles_freed = 0;
/* "uvloop/loop.pyx":173
* self._debug_uv_handles_freed = 0
*
* self._debug_stream_read_cb_total = 0 # <<<<<<<<<<<<<<
* self._debug_stream_read_eof_total = 0
* self._debug_stream_read_errors_total = 0
*/
__pyx_v_self->_debug_stream_read_cb_total = 0;
/* "uvloop/loop.pyx":174
*
* self._debug_stream_read_cb_total = 0
* self._debug_stream_read_eof_total = 0 # <<<<<<<<<<<<<<
* self._debug_stream_read_errors_total = 0
* self._debug_stream_read_cb_errors_total = 0
*/
__pyx_v_self->_debug_stream_read_eof_total = 0;
/* "uvloop/loop.pyx":175
* self._debug_stream_read_cb_total = 0
* self._debug_stream_read_eof_total = 0
* self._debug_stream_read_errors_total = 0 # <<<<<<<<<<<<<<
* self._debug_stream_read_cb_errors_total = 0
* self._debug_stream_read_eof_cb_errors_total = 0
*/
__pyx_v_self->_debug_stream_read_errors_total = 0;
/* "uvloop/loop.pyx":176
* self._debug_stream_read_eof_total = 0
* self._debug_stream_read_errors_total = 0
* self._debug_stream_read_cb_errors_total = 0 # <<<<<<<<<<<<<<
* self._debug_stream_read_eof_cb_errors_total = 0
*
*/
__pyx_v_self->_debug_stream_read_cb_errors_total = 0;
/* "uvloop/loop.pyx":177
* self._debug_stream_read_errors_total = 0
* self._debug_stream_read_cb_errors_total = 0
* self._debug_stream_read_eof_cb_errors_total = 0 # <<<<<<<<<<<<<<
*
* self._debug_stream_shutdown_errors_total = 0
*/
__pyx_v_self->_debug_stream_read_eof_cb_errors_total = 0;
/* "uvloop/loop.pyx":179
* self._debug_stream_read_eof_cb_errors_total = 0
*
* self._debug_stream_shutdown_errors_total = 0 # <<<<<<<<<<<<<<
* self._debug_stream_listen_errors_total = 0
*
*/
__pyx_v_self->_debug_stream_shutdown_errors_total = 0;
/* "uvloop/loop.pyx":180
*
* self._debug_stream_shutdown_errors_total = 0
* self._debug_stream_listen_errors_total = 0 # <<<<<<<<<<<<<<
*
* self._debug_stream_write_tries = 0
*/
__pyx_v_self->_debug_stream_listen_errors_total = 0;
/* "uvloop/loop.pyx":182
* self._debug_stream_listen_errors_total = 0
*
* self._debug_stream_write_tries = 0 # <<<<<<<<<<<<<<
* self._debug_stream_write_errors_total = 0
* self._debug_stream_write_ctx_total = 0
*/
__pyx_v_self->_debug_stream_write_tries = 0;
/* "uvloop/loop.pyx":183
*
* self._debug_stream_write_tries = 0
* self._debug_stream_write_errors_total = 0 # <<<<<<<<<<<<<<
* self._debug_stream_write_ctx_total = 0
* self._debug_stream_write_ctx_cnt = 0
*/
__pyx_v_self->_debug_stream_write_errors_total = 0;
/* "uvloop/loop.pyx":184
* self._debug_stream_write_tries = 0
* self._debug_stream_write_errors_total = 0
* self._debug_stream_write_ctx_total = 0 # <<<<<<<<<<<<<<
* self._debug_stream_write_ctx_cnt = 0
* self._debug_stream_write_cb_errors_total = 0
*/
__pyx_v_self->_debug_stream_write_ctx_total = 0;
/* "uvloop/loop.pyx":185
* self._debug_stream_write_errors_total = 0
* self._debug_stream_write_ctx_total = 0
* self._debug_stream_write_ctx_cnt = 0 # <<<<<<<<<<<<<<
* self._debug_stream_write_cb_errors_total = 0
*
*/
__pyx_v_self->_debug_stream_write_ctx_cnt = 0;
/* "uvloop/loop.pyx":186
* self._debug_stream_write_ctx_total = 0
* self._debug_stream_write_ctx_cnt = 0
* self._debug_stream_write_cb_errors_total = 0 # <<<<<<<<<<<<<<
*
* self._debug_cb_handles_total = 0
*/
__pyx_v_self->_debug_stream_write_cb_errors_total = 0;
/* "uvloop/loop.pyx":188
* self._debug_stream_write_cb_errors_total = 0
*
* self._debug_cb_handles_total = 0 # <<<<<<<<<<<<<<
* self._debug_cb_handles_count = 0
*
*/
__pyx_v_self->_debug_cb_handles_total = 0;
/* "uvloop/loop.pyx":189
*
* self._debug_cb_handles_total = 0
* self._debug_cb_handles_count = 0 # <<<<<<<<<<<<<<
*
* self._debug_cb_timer_handles_total = 0
*/
__pyx_v_self->_debug_cb_handles_count = 0;
/* "uvloop/loop.pyx":191
* self._debug_cb_handles_count = 0
*
* self._debug_cb_timer_handles_total = 0 # <<<<<<<<<<<<<<
* self._debug_cb_timer_handles_count = 0
*
*/
__pyx_v_self->_debug_cb_timer_handles_total = 0;
/* "uvloop/loop.pyx":192
*
* self._debug_cb_timer_handles_total = 0
* self._debug_cb_timer_handles_count = 0 # <<<<<<<<<<<<<<
*
* self._poll_read_events_total = 0
*/
__pyx_v_self->_debug_cb_timer_handles_count = 0;
/* "uvloop/loop.pyx":194
* self._debug_cb_timer_handles_count = 0
*
* self._poll_read_events_total = 0 # <<<<<<<<<<<<<<
* self._poll_read_cb_errors_total = 0
* self._poll_write_events_total = 0
*/
__pyx_v_self->_poll_read_events_total = 0;
/* "uvloop/loop.pyx":195
*
* self._poll_read_events_total = 0
* self._poll_read_cb_errors_total = 0 # <<<<<<<<<<<<<<
* self._poll_write_events_total = 0
* self._poll_write_cb_errors_total = 0
*/
__pyx_v_self->_poll_read_cb_errors_total = 0;
/* "uvloop/loop.pyx":196
* self._poll_read_events_total = 0
* self._poll_read_cb_errors_total = 0
* self._poll_write_events_total = 0 # <<<<<<<<<<<<<<
* self._poll_write_cb_errors_total = 0
*
*/
__pyx_v_self->_poll_write_events_total = 0;
/* "uvloop/loop.pyx":197
* self._poll_read_cb_errors_total = 0
* self._poll_write_events_total = 0
* self._poll_write_cb_errors_total = 0 # <<<<<<<<<<<<<<
*
* self._sock_try_write_total = 0
*/
__pyx_v_self->_poll_write_cb_errors_total = 0;
/* "uvloop/loop.pyx":199
* self._poll_write_cb_errors_total = 0
*
* self._sock_try_write_total = 0 # <<<<<<<<<<<<<<
*
* self._debug_exception_handler_cnt = 0
*/
__pyx_v_self->_sock_try_write_total = 0;
/* "uvloop/loop.pyx":201
* self._sock_try_write_total = 0
*
* self._debug_exception_handler_cnt = 0 # <<<<<<<<<<<<<<
*
* cdef _setup_signals(self):
*/
__pyx_v_self->_debug_exception_handler_cnt = 0;
/* "uvloop/loop.pyx":158
* self.uvloop = NULL
*
* cdef _init_debug_fields(self): # <<<<<<<<<<<<<<
* self._debug_cc = bool(UVLOOP_DEBUG)
*
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_AddTraceback("uvloop.loop.Loop._init_debug_fields", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":203
* self._debug_exception_handler_cnt = 0
*
* cdef _setup_signals(self): # <<<<<<<<<<<<<<
* self._ssock, self._csock = socket_socketpair()
* self._ssock.setblocking(False)
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__setup_signals(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *(*__pyx_t_5)(PyObject *);
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
int __pyx_t_10;
PyObject *__pyx_t_11 = NULL;
__Pyx_RefNannySetupContext("_setup_signals", 0);
/* "uvloop/loop.pyx":204
*
* cdef _setup_signals(self):
* self._ssock, self._csock = socket_socketpair() # <<<<<<<<<<<<<<
* self._ssock.setblocking(False)
* self._csock.setblocking(False)
*/
__Pyx_INCREF(__pyx_v_6uvloop_4loop_socket_socketpair);
__pyx_t_2 = __pyx_v_6uvloop_4loop_socket_socketpair; __pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (__pyx_t_3) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 204, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 204, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
PyObject* sequence = __pyx_t_1;
#if !CYTHON_COMPILING_IN_PYPY
Py_ssize_t size = Py_SIZE(sequence);
#else
Py_ssize_t size = PySequence_Size(sequence);
#endif
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
__PYX_ERR(1, 204, __pyx_L1_error)
}
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
if (likely(PyTuple_CheckExact(sequence))) {
__pyx_t_2 = PyTuple_GET_ITEM(sequence, 0);
__pyx_t_3 = PyTuple_GET_ITEM(sequence, 1);
} else {
__pyx_t_2 = PyList_GET_ITEM(sequence, 0);
__pyx_t_3 = PyList_GET_ITEM(sequence, 1);
}
__Pyx_INCREF(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
#else
__pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 204, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 204, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
Py_ssize_t index = -1;
__pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 204, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_5 = Py_TYPE(__pyx_t_4)->tp_iternext;
index = 0; __pyx_t_2 = __pyx_t_5(__pyx_t_4); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed;
__Pyx_GOTREF(__pyx_t_2);
index = 1; __pyx_t_3 = __pyx_t_5(__pyx_t_4); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed;
__Pyx_GOTREF(__pyx_t_3);
if (__Pyx_IternextUnpackEndCheck(__pyx_t_5(__pyx_t_4), 2) < 0) __PYX_ERR(1, 204, __pyx_L1_error)
__pyx_t_5 = NULL;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
goto __pyx_L4_unpacking_done;
__pyx_L3_unpacking_failed:;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_5 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
__PYX_ERR(1, 204, __pyx_L1_error)
__pyx_L4_unpacking_done:;
}
__Pyx_GIVEREF(__pyx_t_2);
__Pyx_GOTREF(__pyx_v_self->_ssock);
__Pyx_DECREF(__pyx_v_self->_ssock);
__pyx_v_self->_ssock = __pyx_t_2;
__pyx_t_2 = 0;
__Pyx_GIVEREF(__pyx_t_3);
__Pyx_GOTREF(__pyx_v_self->_csock);
__Pyx_DECREF(__pyx_v_self->_csock);
__pyx_v_self->_csock = __pyx_t_3;
__pyx_t_3 = 0;
/* "uvloop/loop.pyx":205
* cdef _setup_signals(self):
* self._ssock, self._csock = socket_socketpair()
* self._ssock.setblocking(False) # <<<<<<<<<<<<<<
* self._csock.setblocking(False)
* try:
*/
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_ssock, __pyx_n_s_setblocking); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 205, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 205, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":206
* self._ssock, self._csock = socket_socketpair()
* self._ssock.setblocking(False)
* self._csock.setblocking(False) # <<<<<<<<<<<<<<
* try:
* signal_set_wakeup_fd(self._csock.fileno())
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_csock, __pyx_n_s_setblocking); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 206, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 206, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":207
* self._ssock.setblocking(False)
* self._csock.setblocking(False)
* try: # <<<<<<<<<<<<<<
* signal_set_wakeup_fd(self._csock.fileno())
* except ValueError:
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8);
__Pyx_XGOTREF(__pyx_t_6);
__Pyx_XGOTREF(__pyx_t_7);
__Pyx_XGOTREF(__pyx_t_8);
/*try:*/ {
/* "uvloop/loop.pyx":208
* self._csock.setblocking(False)
* try:
* signal_set_wakeup_fd(self._csock.fileno()) # <<<<<<<<<<<<<<
* except ValueError:
* # Not the main thread
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_csock, __pyx_n_s_fileno); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 208, __pyx_L5_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (__pyx_t_4) {
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 208, __pyx_L5_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
__pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 208, __pyx_L5_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_INCREF(__pyx_v_6uvloop_4loop_signal_set_wakeup_fd);
__pyx_t_2 = __pyx_v_6uvloop_4loop_signal_set_wakeup_fd; __pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (!__pyx_t_4) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 208, __pyx_L5_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
__pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 208, __pyx_L5_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_3};
__pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 208, __pyx_L5_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else
#endif
{
__pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 208, __pyx_L5_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_4); __pyx_t_4 = NULL;
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_t_3);
__pyx_t_3 = 0;
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 208, __pyx_L5_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
}
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":207
* self._ssock.setblocking(False)
* self._csock.setblocking(False)
* try: # <<<<<<<<<<<<<<
* signal_set_wakeup_fd(self._csock.fileno())
* except ValueError:
*/
}
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
goto __pyx_L12_try_end;
__pyx_L5_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":209
* try:
* signal_set_wakeup_fd(self._csock.fileno())
* except ValueError: # <<<<<<<<<<<<<<
* # Not the main thread
* self._ssock.close()
*/
__pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ValueError);
if (__pyx_t_10) {
__Pyx_AddTraceback("uvloop.loop.Loop._setup_signals", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_9) < 0) __PYX_ERR(1, 209, __pyx_L7_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GOTREF(__pyx_t_9);
/* "uvloop/loop.pyx":211
* except ValueError:
* # Not the main thread
* self._ssock.close() # <<<<<<<<<<<<<<
* self._csock.close()
* self._ssock = self._csock = None
*/
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_ssock, __pyx_n_s_close); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 211, __pyx_L7_except_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_11 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_11 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_11)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_11);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (__pyx_t_11) {
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 211, __pyx_L7_except_error)
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
} else {
__pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 211, __pyx_L7_except_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":212
* # Not the main thread
* self._ssock.close()
* self._csock.close() # <<<<<<<<<<<<<<
* self._ssock = self._csock = None
* return
*/
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_csock, __pyx_n_s_close); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 212, __pyx_L7_except_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_11 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_11 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_11)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_11);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (__pyx_t_11) {
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_11); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 212, __pyx_L7_except_error)
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
} else {
__pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 212, __pyx_L7_except_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":213
* self._ssock.close()
* self._csock.close()
* self._ssock = self._csock = None # <<<<<<<<<<<<<<
* return
*
*/
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__Pyx_GOTREF(__pyx_v_self->_ssock);
__Pyx_DECREF(__pyx_v_self->_ssock);
__pyx_v_self->_ssock = Py_None;
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__Pyx_GOTREF(__pyx_v_self->_csock);
__Pyx_DECREF(__pyx_v_self->_csock);
__pyx_v_self->_csock = Py_None;
/* "uvloop/loop.pyx":214
* self._csock.close()
* self._ssock = self._csock = None
* return # <<<<<<<<<<<<<<
*
* self._add_reader(
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
goto __pyx_L8_except_return;
}
goto __pyx_L7_except_error;
__pyx_L7_except_error:;
/* "uvloop/loop.pyx":207
* self._ssock.setblocking(False)
* self._csock.setblocking(False)
* try: # <<<<<<<<<<<<<<
* signal_set_wakeup_fd(self._csock.fileno())
* except ValueError:
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
goto __pyx_L1_error;
__pyx_L8_except_return:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
goto __pyx_L0;
__pyx_L12_try_end:;
}
/* "uvloop/loop.pyx":217
*
* self._add_reader(
* self._ssock.fileno(), # <<<<<<<<<<<<<<
* new_MethodHandle(
* self,
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_ssock, __pyx_n_s_fileno); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 217, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_1 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_1)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_1);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (__pyx_t_1) {
__pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 217, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
__pyx_t_9 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 217, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":218
* self._add_reader(
* self._ssock.fileno(),
* new_MethodHandle( # <<<<<<<<<<<<<<
* self,
* "Loop._read_from_self",
*/
__pyx_t_2 = __pyx_f_6uvloop_4loop_new_MethodHandle(__pyx_v_self, __pyx_kp_u_Loop__read_from_self, ((__pyx_t_6uvloop_4loop_method_t)((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_read_from_self), ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 218, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(1, 218, __pyx_L1_error)
/* "uvloop/loop.pyx":216
* return
*
* self._add_reader( # <<<<<<<<<<<<<<
* self._ssock.fileno(),
* new_MethodHandle(
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__add_reader(__pyx_v_self, __pyx_t_9, ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_2)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 216, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":224
* self))
*
* self._signal_handlers = {} # <<<<<<<<<<<<<<
*
* cdef _shutdown_signals(self):
*/
__pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 224, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_v_self->_signal_handlers);
__Pyx_DECREF(__pyx_v_self->_signal_handlers);
__pyx_v_self->_signal_handlers = ((PyObject*)__pyx_t_1);
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":203
* self._debug_exception_handler_cnt = 0
*
* cdef _setup_signals(self): # <<<<<<<<<<<<<<
* self._ssock, self._csock = socket_socketpair()
* self._ssock.setblocking(False)
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_9);
__Pyx_XDECREF(__pyx_t_11);
__Pyx_AddTraceback("uvloop.loop.Loop._setup_signals", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":226
* self._signal_handlers = {}
*
* cdef _shutdown_signals(self): # <<<<<<<<<<<<<<
* if self._signal_handlers is None:
* return
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__shutdown_signals(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_v_sig = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
Py_ssize_t __pyx_t_5;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
__Pyx_RefNannySetupContext("_shutdown_signals", 0);
/* "uvloop/loop.pyx":227
*
* cdef _shutdown_signals(self):
* if self._signal_handlers is None: # <<<<<<<<<<<<<<
* return
* for sig in list(self._signal_handlers):
*/
__pyx_t_1 = (__pyx_v_self->_signal_handlers == ((PyObject*)Py_None));
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":228
* cdef _shutdown_signals(self):
* if self._signal_handlers is None:
* return # <<<<<<<<<<<<<<
* for sig in list(self._signal_handlers):
* self.remove_signal_handler(sig)
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
/* "uvloop/loop.pyx":227
*
* cdef _shutdown_signals(self):
* if self._signal_handlers is None: # <<<<<<<<<<<<<<
* return
* for sig in list(self._signal_handlers):
*/
}
/* "uvloop/loop.pyx":229
* if self._signal_handlers is None:
* return
* for sig in list(self._signal_handlers): # <<<<<<<<<<<<<<
* self.remove_signal_handler(sig)
* signal_set_wakeup_fd(-1)
*/
__pyx_t_3 = PySequence_List(__pyx_v_self->_signal_handlers); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 229, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = __pyx_t_3; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
for (;;) {
if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_4)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_3 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_3); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 229, __pyx_L1_error)
#else
__pyx_t_3 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 229, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
__Pyx_XDECREF_SET(__pyx_v_sig, __pyx_t_3);
__pyx_t_3 = 0;
/* "uvloop/loop.pyx":230
* return
* for sig in list(self._signal_handlers):
* self.remove_signal_handler(sig) # <<<<<<<<<<<<<<
* signal_set_wakeup_fd(-1)
* self._remove_reader(self._ssock.fileno())
*/
__pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_remove_signal_handler); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 230, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_7 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
__pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
if (likely(__pyx_t_7)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
__Pyx_INCREF(__pyx_t_7);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_6, function);
}
}
if (!__pyx_t_7) {
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_sig); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 230, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_6)) {
PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_sig};
__pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 230, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_sig};
__pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 230, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else
#endif
{
__pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 230, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
__Pyx_INCREF(__pyx_v_sig);
__Pyx_GIVEREF(__pyx_v_sig);
PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_v_sig);
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 230, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
}
}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":229
* if self._signal_handlers is None:
* return
* for sig in list(self._signal_handlers): # <<<<<<<<<<<<<<
* self.remove_signal_handler(sig)
* signal_set_wakeup_fd(-1)
*/
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":231
* for sig in list(self._signal_handlers):
* self.remove_signal_handler(sig)
* signal_set_wakeup_fd(-1) # <<<<<<<<<<<<<<
* self._remove_reader(self._ssock.fileno())
* self._ssock.close()
*/
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_v_6uvloop_4loop_signal_set_wakeup_fd, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 231, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":232
* self.remove_signal_handler(sig)
* signal_set_wakeup_fd(-1)
* self._remove_reader(self._ssock.fileno()) # <<<<<<<<<<<<<<
* self._ssock.close()
* self._csock.close()
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_ssock, __pyx_n_s_fileno); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 232, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (__pyx_t_6) {
__pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 232, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
__pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 232, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = __pyx_f_6uvloop_4loop_4Loop__remove_reader(__pyx_v_self, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 232, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":233
* signal_set_wakeup_fd(-1)
* self._remove_reader(self._ssock.fileno())
* self._ssock.close() # <<<<<<<<<<<<<<
* self._csock.close()
*
*/
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_ssock, __pyx_n_s_close); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 233, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (__pyx_t_6) {
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 233, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
__pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 233, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":234
* self._remove_reader(self._ssock.fileno())
* self._ssock.close()
* self._csock.close() # <<<<<<<<<<<<<<
*
* cdef _read_from_self(self):
*/
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_csock, __pyx_n_s_close); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 234, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (__pyx_t_6) {
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 234, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
__pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 234, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":226
* self._signal_handlers = {}
*
* cdef _shutdown_signals(self): # <<<<<<<<<<<<<<
* if self._signal_handlers is None:
* return
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_AddTraceback("uvloop.loop.Loop._shutdown_signals", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_sig);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":236
* self._csock.close()
*
* cdef _read_from_self(self): # <<<<<<<<<<<<<<
* while True:
* try:
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__read_from_self(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_v_data = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_t_6;
int __pyx_t_7;
int __pyx_t_8;
PyObject *__pyx_t_9 = NULL;
__Pyx_RefNannySetupContext("_read_from_self", 0);
/* "uvloop/loop.pyx":237
*
* cdef _read_from_self(self):
* while True: # <<<<<<<<<<<<<<
* try:
* data = self._ssock.recv(4096)
*/
while (1) {
/* "uvloop/loop.pyx":238
* cdef _read_from_self(self):
* while True:
* try: # <<<<<<<<<<<<<<
* data = self._ssock.recv(4096)
* if not data:
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
__Pyx_XGOTREF(__pyx_t_1);
__Pyx_XGOTREF(__pyx_t_2);
__Pyx_XGOTREF(__pyx_t_3);
/*try:*/ {
/* "uvloop/loop.pyx":239
* while True:
* try:
* data = self._ssock.recv(4096) # <<<<<<<<<<<<<<
* if not data:
* break
*/
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_ssock, __pyx_n_s_recv); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 239, __pyx_L5_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 239, __pyx_L5_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF_SET(__pyx_v_data, __pyx_t_5);
__pyx_t_5 = 0;
/* "uvloop/loop.pyx":240
* try:
* data = self._ssock.recv(4096)
* if not data: # <<<<<<<<<<<<<<
* break
* self._process_self_data(data)
*/
__pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_v_data); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 240, __pyx_L5_error)
__pyx_t_7 = ((!__pyx_t_6) != 0);
if (__pyx_t_7) {
/* "uvloop/loop.pyx":241
* data = self._ssock.recv(4096)
* if not data:
* break # <<<<<<<<<<<<<<
* self._process_self_data(data)
* except InterruptedError:
*/
goto __pyx_L10_try_break;
/* "uvloop/loop.pyx":240
* try:
* data = self._ssock.recv(4096)
* if not data: # <<<<<<<<<<<<<<
* break
* self._process_self_data(data)
*/
}
/* "uvloop/loop.pyx":242
* if not data:
* break
* self._process_self_data(data) # <<<<<<<<<<<<<<
* except InterruptedError:
* continue
*/
__pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_process_self_data(__pyx_v_self, __pyx_v_data); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 242, __pyx_L5_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":238
* cdef _read_from_self(self):
* while True:
* try: # <<<<<<<<<<<<<<
* data = self._ssock.recv(4096)
* if not data:
*/
}
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
goto __pyx_L12_try_end;
__pyx_L5_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":243
* break
* self._process_self_data(data)
* except InterruptedError: # <<<<<<<<<<<<<<
* continue
* except BlockingIOError:
*/
__pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_InterruptedError);
if (__pyx_t_8) {
__Pyx_AddTraceback("uvloop.loop.Loop._read_from_self", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_9) < 0) __PYX_ERR(1, 243, __pyx_L7_except_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GOTREF(__pyx_t_9);
/* "uvloop/loop.pyx":244
* self._process_self_data(data)
* except InterruptedError:
* continue # <<<<<<<<<<<<<<
* except BlockingIOError:
* break
*/
goto __pyx_L15_except_continue;
__pyx_L15_except_continue:;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
goto __pyx_L11_try_continue;
}
/* "uvloop/loop.pyx":245
* except InterruptedError:
* continue
* except BlockingIOError: # <<<<<<<<<<<<<<
* break
*
*/
__pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BlockingIOError);
if (__pyx_t_8) {
__Pyx_AddTraceback("uvloop.loop.Loop._read_from_self", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_4, &__pyx_t_5) < 0) __PYX_ERR(1, 245, __pyx_L7_except_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GOTREF(__pyx_t_5);
/* "uvloop/loop.pyx":246
* continue
* except BlockingIOError:
* break # <<<<<<<<<<<<<<
*
* cdef _process_self_data(self, data):
*/
goto __pyx_L16_except_break;
__pyx_L16_except_break:;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
goto __pyx_L10_try_break;
}
goto __pyx_L7_except_error;
__pyx_L7_except_error:;
/* "uvloop/loop.pyx":238
* cdef _read_from_self(self):
* while True:
* try: # <<<<<<<<<<<<<<
* data = self._ssock.recv(4096)
* if not data:
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_1);
__Pyx_XGIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
goto __pyx_L1_error;
__pyx_L10_try_break:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_1);
__Pyx_XGIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
goto __pyx_L4_break;
__pyx_L11_try_continue:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_1);
__Pyx_XGIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
goto __pyx_L3_continue;
__pyx_L12_try_end:;
}
__pyx_L3_continue:;
}
__pyx_L4_break:;
/* "uvloop/loop.pyx":236
* self._csock.close()
*
* cdef _read_from_self(self): # <<<<<<<<<<<<<<
* while True:
* try:
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_9);
__Pyx_AddTraceback("uvloop.loop.Loop._read_from_self", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_data);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":248
* break
*
* cdef _process_self_data(self, data): # <<<<<<<<<<<<<<
* for signum in data:
* if not signum:
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__process_self_data(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_data) {
PyObject *__pyx_v_signum = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
Py_ssize_t __pyx_t_2;
PyObject *(*__pyx_t_3)(PyObject *);
PyObject *__pyx_t_4 = NULL;
int __pyx_t_5;
int __pyx_t_6;
__Pyx_RefNannySetupContext("_process_self_data", 0);
/* "uvloop/loop.pyx":249
*
* cdef _process_self_data(self, data):
* for signum in data: # <<<<<<<<<<<<<<
* if not signum:
* # ignore null bytes written by _write_to_self()
*/
if (likely(PyList_CheckExact(__pyx_v_data)) || PyTuple_CheckExact(__pyx_v_data)) {
__pyx_t_1 = __pyx_v_data; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
__pyx_t_3 = NULL;
} else {
__pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 249, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 249, __pyx_L1_error)
}
for (;;) {
if (likely(!__pyx_t_3)) {
if (likely(PyList_CheckExact(__pyx_t_1))) {
if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 249, __pyx_L1_error)
#else
__pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 249, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
} else {
if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 249, __pyx_L1_error)
#else
__pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 249, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
}
} else {
__pyx_t_4 = __pyx_t_3(__pyx_t_1);
if (unlikely(!__pyx_t_4)) {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(1, 249, __pyx_L1_error)
}
break;
}
__Pyx_GOTREF(__pyx_t_4);
}
__Pyx_XDECREF_SET(__pyx_v_signum, __pyx_t_4);
__pyx_t_4 = 0;
/* "uvloop/loop.pyx":250
* cdef _process_self_data(self, data):
* for signum in data:
* if not signum: # <<<<<<<<<<<<<<
* # ignore null bytes written by _write_to_self()
* continue
*/
__pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_v_signum); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(1, 250, __pyx_L1_error)
__pyx_t_6 = ((!__pyx_t_5) != 0);
if (__pyx_t_6) {
/* "uvloop/loop.pyx":252
* if not signum:
* # ignore null bytes written by _write_to_self()
* continue # <<<<<<<<<<<<<<
* self._handle_signal(signum)
*
*/
goto __pyx_L3_continue;
/* "uvloop/loop.pyx":250
* cdef _process_self_data(self, data):
* for signum in data:
* if not signum: # <<<<<<<<<<<<<<
* # ignore null bytes written by _write_to_self()
* continue
*/
}
/* "uvloop/loop.pyx":253
* # ignore null bytes written by _write_to_self()
* continue
* self._handle_signal(signum) # <<<<<<<<<<<<<<
*
* cdef _handle_signal(self, sig):
*/
__pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_handle_signal(__pyx_v_self, __pyx_v_signum); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 253, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":249
*
* cdef _process_self_data(self, data):
* for signum in data: # <<<<<<<<<<<<<<
* if not signum:
* # ignore null bytes written by _write_to_self()
*/
__pyx_L3_continue:;
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":248
* break
*
* cdef _process_self_data(self, data): # <<<<<<<<<<<<<<
* for signum in data:
* if not signum:
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_AddTraceback("uvloop.loop.Loop._process_self_data", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_signum);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":255
* self._handle_signal(signum)
*
* cdef _handle_signal(self, sig): # <<<<<<<<<<<<<<
* cdef Handle handle
*
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__handle_signal(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sig) {
struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle = 0;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_t_6;
PyObject *__pyx_t_7 = NULL;
int __pyx_t_8;
int __pyx_t_9;
PyObject *__pyx_t_10 = NULL;
__Pyx_RefNannySetupContext("_handle_signal", 0);
/* "uvloop/loop.pyx":258
* cdef Handle handle
*
* try: # <<<<<<<<<<<<<<
* handle = (self._signal_handlers[sig])
* except KeyError:
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
__Pyx_XGOTREF(__pyx_t_1);
__Pyx_XGOTREF(__pyx_t_2);
__Pyx_XGOTREF(__pyx_t_3);
/*try:*/ {
/* "uvloop/loop.pyx":259
*
* try:
* handle = (self._signal_handlers[sig]) # <<<<<<<<<<<<<<
* except KeyError:
* handle = None
*/
if (unlikely(__pyx_v_self->_signal_handlers == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
__PYX_ERR(1, 259, __pyx_L3_error)
}
__pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_self->_signal_handlers, __pyx_v_sig); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 259, __pyx_L3_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = __pyx_t_4;
__Pyx_INCREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_5);
__pyx_t_5 = 0;
/* "uvloop/loop.pyx":258
* cdef Handle handle
*
* try: # <<<<<<<<<<<<<<
* handle = (self._signal_handlers[sig])
* except KeyError:
*/
}
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
goto __pyx_L10_try_end;
__pyx_L3_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":260
* try:
* handle = (self._signal_handlers[sig])
* except KeyError: # <<<<<<<<<<<<<<
* handle = None
*
*/
__pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
if (__pyx_t_6) {
__Pyx_AddTraceback("uvloop.loop.Loop._handle_signal", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_4, &__pyx_t_7) < 0) __PYX_ERR(1, 260, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GOTREF(__pyx_t_7);
/* "uvloop/loop.pyx":261
* handle = (self._signal_handlers[sig])
* except KeyError:
* handle = None # <<<<<<<<<<<<<<
*
* if handle is None:
*/
__Pyx_INCREF(Py_None);
__Pyx_XDECREF_SET(__pyx_v_handle, ((struct __pyx_obj_6uvloop_4loop_Handle *)Py_None));
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
goto __pyx_L4_exception_handled;
}
goto __pyx_L5_except_error;
__pyx_L5_except_error:;
/* "uvloop/loop.pyx":258
* cdef Handle handle
*
* try: # <<<<<<<<<<<<<<
* handle = (self._signal_handlers[sig])
* except KeyError:
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_1);
__Pyx_XGIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
goto __pyx_L1_error;
__pyx_L4_exception_handled:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_1);
__Pyx_XGIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
__pyx_L10_try_end:;
}
/* "uvloop/loop.pyx":263
* handle = None
*
* if handle is None: # <<<<<<<<<<<<<<
* # Some signal that we aren't listening through
* # add_signal_handler. Invoke CPython eval loop
*/
__pyx_t_8 = (((PyObject *)__pyx_v_handle) == Py_None);
__pyx_t_9 = (__pyx_t_8 != 0);
if (__pyx_t_9) {
/* "uvloop/loop.pyx":267
* # add_signal_handler. Invoke CPython eval loop
* # to let it being processed.
* PyErr_CheckSignals() # <<<<<<<<<<<<<<
* _noop.noop()
* return
*/
__pyx_t_6 = PyErr_CheckSignals(); if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(1, 267, __pyx_L1_error)
/* "uvloop/loop.pyx":268
* # to let it being processed.
* PyErr_CheckSignals()
* _noop.noop() # <<<<<<<<<<<<<<
* return
*
*/
__pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_noop); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 268, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_noop_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 268, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_5, function);
}
}
if (__pyx_t_4) {
__pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 268, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
__pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 268, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "uvloop/loop.pyx":269
* PyErr_CheckSignals()
* _noop.noop()
* return # <<<<<<<<<<<<<<
*
* if handle.cancelled:
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
/* "uvloop/loop.pyx":263
* handle = None
*
* if handle is None: # <<<<<<<<<<<<<<
* # Some signal that we aren't listening through
* # add_signal_handler. Invoke CPython eval loop
*/
}
/* "uvloop/loop.pyx":271
* return
*
* if handle.cancelled: # <<<<<<<<<<<<<<
* self.remove_signal_handler(sig) # Remove it properly.
* else:
*/
__pyx_t_9 = (__pyx_v_handle->cancelled != 0);
if (__pyx_t_9) {
/* "uvloop/loop.pyx":272
*
* if handle.cancelled:
* self.remove_signal_handler(sig) # Remove it properly. # <<<<<<<<<<<<<<
* else:
* self._call_soon_handle(handle)
*/
__pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_remove_signal_handler); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 272, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_5, function);
}
}
if (!__pyx_t_4) {
__pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_sig); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 272, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_5)) {
PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_sig};
__pyx_t_7 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 272, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_7);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_sig};
__pyx_t_7 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 272, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_7);
} else
#endif
{
__pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 272, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_4); __pyx_t_4 = NULL;
__Pyx_INCREF(__pyx_v_sig);
__Pyx_GIVEREF(__pyx_v_sig);
PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_v_sig);
__pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_10, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 272, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
}
}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "uvloop/loop.pyx":271
* return
*
* if handle.cancelled: # <<<<<<<<<<<<<<
* self.remove_signal_handler(sig) # Remove it properly.
* else:
*/
goto __pyx_L14;
}
/* "uvloop/loop.pyx":274
* self.remove_signal_handler(sig) # Remove it properly.
* else:
* self._call_soon_handle(handle) # <<<<<<<<<<<<<<
* self.handler_async.send()
*
*/
/*else*/ {
__pyx_t_7 = __pyx_f_6uvloop_4loop_4Loop__call_soon_handle(__pyx_v_self, __pyx_v_handle); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 274, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "uvloop/loop.pyx":275
* else:
* self._call_soon_handle(handle)
* self.handler_async.send() # <<<<<<<<<<<<<<
*
* cdef _on_wake(self):
*/
__pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVAsync *)__pyx_v_self->handler_async->__pyx_base.__pyx_vtab)->send(__pyx_v_self->handler_async); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 275, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
__pyx_L14:;
/* "uvloop/loop.pyx":255
* self._handle_signal(signum)
*
* cdef _handle_signal(self, sig): # <<<<<<<<<<<<<<
* cdef Handle handle
*
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_10);
__Pyx_AddTraceback("uvloop.loop.Loop._handle_signal", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_handle);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":277
* self.handler_async.send()
*
* cdef _on_wake(self): # <<<<<<<<<<<<<<
* if (self._ready_len > 0 or self._stopping) \
* and not self.handler_idle.running:
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__on_wake(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
__Pyx_RefNannySetupContext("_on_wake", 0);
/* "uvloop/loop.pyx":278
*
* cdef _on_wake(self):
* if (self._ready_len > 0 or self._stopping) \ # <<<<<<<<<<<<<<
* and not self.handler_idle.running:
* self.handler_idle.start()
*/
__pyx_t_2 = ((__pyx_v_self->_ready_len > 0) != 0);
if (!__pyx_t_2) {
} else {
goto __pyx_L5_next_and;
}
__pyx_t_2 = (__pyx_v_self->_stopping != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L4_bool_binop_done;
}
__pyx_L5_next_and:;
/* "uvloop/loop.pyx":279
* cdef _on_wake(self):
* if (self._ready_len > 0 or self._stopping) \
* and not self.handler_idle.running: # <<<<<<<<<<<<<<
* self.handler_idle.start()
*
*/
__pyx_t_2 = ((!(__pyx_v_self->handler_idle->running != 0)) != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L4_bool_binop_done:;
/* "uvloop/loop.pyx":278
*
* cdef _on_wake(self):
* if (self._ready_len > 0 or self._stopping) \ # <<<<<<<<<<<<<<
* and not self.handler_idle.running:
* self.handler_idle.start()
*/
if (__pyx_t_1) {
/* "uvloop/loop.pyx":280
* if (self._ready_len > 0 or self._stopping) \
* and not self.handler_idle.running:
* self.handler_idle.start() # <<<<<<<<<<<<<<
*
* cdef _on_idle(self):
*/
__pyx_t_3 = __pyx_f_6uvloop_4loop_6UVIdle_start(__pyx_v_self->handler_idle); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 280, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":278
*
* cdef _on_wake(self):
* if (self._ready_len > 0 or self._stopping) \ # <<<<<<<<<<<<<<
* and not self.handler_idle.running:
* self.handler_idle.start()
*/
}
/* "uvloop/loop.pyx":277
* self.handler_async.send()
*
* cdef _on_wake(self): # <<<<<<<<<<<<<<
* if (self._ready_len > 0 or self._stopping) \
* and not self.handler_idle.running:
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_AddTraceback("uvloop.loop.Loop._on_wake", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":282
* self.handler_idle.start()
*
* cdef _on_idle(self): # <<<<<<<<<<<<<<
* cdef:
* int i, ntodo
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__on_idle(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
CYTHON_UNUSED int __pyx_v_i;
int __pyx_v_ntodo;
PyObject *__pyx_v_popleft = 0;
struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handler = 0;
PyObject *__pyx_v_started = NULL;
PyObject *__pyx_v_ex = NULL;
PyObject *__pyx_v_delta = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
Py_ssize_t __pyx_t_2;
int __pyx_t_3;
int __pyx_t_4;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
int __pyx_t_10;
PyObject *__pyx_t_11 = NULL;
int __pyx_t_12;
char const *__pyx_t_13;
PyObject *__pyx_t_14 = NULL;
PyObject *__pyx_t_15 = NULL;
PyObject *__pyx_t_16 = NULL;
PyObject *__pyx_t_17 = NULL;
PyObject *__pyx_t_18 = NULL;
PyObject *__pyx_t_19 = NULL;
char const *__pyx_t_20;
int __pyx_t_21;
__Pyx_RefNannySetupContext("_on_idle", 0);
/* "uvloop/loop.pyx":285
* cdef:
* int i, ntodo
* object popleft = self._ready.popleft # <<<<<<<<<<<<<<
* Handle handler
*
*/
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_ready, __pyx_n_s_popleft); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 285, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_popleft = __pyx_t_1;
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":288
* Handle handler
*
* ntodo = len(self._ready) # <<<<<<<<<<<<<<
* if self._debug:
* for i from 0 <= i < ntodo:
*/
__pyx_t_1 = __pyx_v_self->_ready;
__Pyx_INCREF(__pyx_t_1);
__pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(1, 288, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_ntodo = __pyx_t_2;
/* "uvloop/loop.pyx":289
*
* ntodo = len(self._ready)
* if self._debug: # <<<<<<<<<<<<<<
* for i from 0 <= i < ntodo:
* handler = popleft()
*/
__pyx_t_3 = (__pyx_v_self->_debug != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":290
* ntodo = len(self._ready)
* if self._debug:
* for i from 0 <= i < ntodo: # <<<<<<<<<<<<<<
* handler = popleft()
* if handler.cancelled == 0:
*/
__pyx_t_4 = __pyx_v_ntodo;
for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_4; __pyx_v_i++) {
/* "uvloop/loop.pyx":291
* if self._debug:
* for i from 0 <= i < ntodo:
* handler = popleft() # <<<<<<<<<<<<<<
* if handler.cancelled == 0:
* try:
*/
__Pyx_INCREF(__pyx_v_popleft);
__pyx_t_5 = __pyx_v_popleft; __pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_5, function);
}
}
if (__pyx_t_6) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 291, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 291, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_5 = __pyx_t_1;
__Pyx_INCREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF_SET(__pyx_v_handler, ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_5));
__pyx_t_5 = 0;
/* "uvloop/loop.pyx":292
* for i from 0 <= i < ntodo:
* handler = popleft()
* if handler.cancelled == 0: # <<<<<<<<<<<<<<
* try:
* started = time_monotonic()
*/
__pyx_t_3 = ((__pyx_v_handler->cancelled == 0) != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":293
* handler = popleft()
* if handler.cancelled == 0:
* try: # <<<<<<<<<<<<<<
* started = time_monotonic()
* handler._run()
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9);
__Pyx_XGOTREF(__pyx_t_7);
__Pyx_XGOTREF(__pyx_t_8);
__Pyx_XGOTREF(__pyx_t_9);
/*try:*/ {
/* "uvloop/loop.pyx":294
* if handler.cancelled == 0:
* try:
* started = time_monotonic() # <<<<<<<<<<<<<<
* handler._run()
* except BaseException as ex:
*/
__Pyx_INCREF(__pyx_v_6uvloop_4loop_time_monotonic);
__pyx_t_1 = __pyx_v_6uvloop_4loop_time_monotonic; __pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_1, function);
}
}
if (__pyx_t_6) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 294, __pyx_L7_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
__pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 294, __pyx_L7_error)
}
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF_SET(__pyx_v_started, __pyx_t_5);
__pyx_t_5 = 0;
/* "uvloop/loop.pyx":295
* try:
* started = time_monotonic()
* handler._run() # <<<<<<<<<<<<<<
* except BaseException as ex:
* self._stop(ex)
*/
__pyx_t_5 = __pyx_f_6uvloop_4loop_6Handle__run(__pyx_v_handler); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 295, __pyx_L7_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":293
* handler = popleft()
* if handler.cancelled == 0:
* try: # <<<<<<<<<<<<<<
* started = time_monotonic()
* handler._run()
*/
}
/* "uvloop/loop.pyx":300
* return
* else:
* delta = time_monotonic() - started # <<<<<<<<<<<<<<
* if delta > self.slow_callback_duration:
* aio_logger.warning(
*/
/*else:*/ {
__Pyx_INCREF(__pyx_v_6uvloop_4loop_time_monotonic);
__pyx_t_1 = __pyx_v_6uvloop_4loop_time_monotonic; __pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_1, function);
}
}
if (__pyx_t_6) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 300, __pyx_L9_except_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
__pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 300, __pyx_L9_except_error)
}
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = PyNumber_Subtract(__pyx_t_5, __pyx_v_started); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 300, __pyx_L9_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF_SET(__pyx_v_delta, __pyx_t_1);
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":301
* else:
* delta = time_monotonic() - started
* if delta > self.slow_callback_duration: # <<<<<<<<<<<<<<
* aio_logger.warning(
* 'Executing %r took %.3f seconds',
*/
__pyx_t_1 = PyObject_RichCompare(__pyx_v_delta, __pyx_v_self->slow_callback_duration, Py_GT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 301, __pyx_L9_except_error)
__pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(1, 301, __pyx_L9_except_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_3) {
/* "uvloop/loop.pyx":302
* delta = time_monotonic() - started
* if delta > self.slow_callback_duration:
* aio_logger.warning( # <<<<<<<<<<<<<<
* 'Executing %r took %.3f seconds',
* handler, delta)
*/
__pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_warning); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 302, __pyx_L9_except_error)
__Pyx_GOTREF(__pyx_t_5);
/* "uvloop/loop.pyx":304
* aio_logger.warning(
* 'Executing %r took %.3f seconds',
* handler, delta) # <<<<<<<<<<<<<<
*
* else:
*/
__pyx_t_6 = NULL;
__pyx_t_10 = 0;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_5, function);
__pyx_t_10 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_5)) {
PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_kp_u_Executing_r_took_3f_seconds, ((PyObject *)__pyx_v_handler), __pyx_v_delta};
__pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 302, __pyx_L9_except_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
PyObject *__pyx_temp[4] = {__pyx_t_6, __pyx_kp_u_Executing_r_took_3f_seconds, ((PyObject *)__pyx_v_handler), __pyx_v_delta};
__pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 302, __pyx_L9_except_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else
#endif
{
__pyx_t_11 = PyTuple_New(3+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 302, __pyx_L9_except_error)
__Pyx_GOTREF(__pyx_t_11);
if (__pyx_t_6) {
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_6); __pyx_t_6 = NULL;
}
__Pyx_INCREF(__pyx_kp_u_Executing_r_took_3f_seconds);
__Pyx_GIVEREF(__pyx_kp_u_Executing_r_took_3f_seconds);
PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_10, __pyx_kp_u_Executing_r_took_3f_seconds);
__Pyx_INCREF(((PyObject *)__pyx_v_handler));
__Pyx_GIVEREF(((PyObject *)__pyx_v_handler));
PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, ((PyObject *)__pyx_v_handler));
__Pyx_INCREF(__pyx_v_delta);
__Pyx_GIVEREF(__pyx_v_delta);
PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_10, __pyx_v_delta);
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 302, __pyx_L9_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":301
* else:
* delta = time_monotonic() - started
* if delta > self.slow_callback_duration: # <<<<<<<<<<<<<<
* aio_logger.warning(
* 'Executing %r took %.3f seconds',
*/
}
}
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
goto __pyx_L14_try_end;
__pyx_L7_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":296
* started = time_monotonic()
* handler._run()
* except BaseException as ex: # <<<<<<<<<<<<<<
* self._stop(ex)
* return
*/
__pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
if (__pyx_t_10) {
__Pyx_AddTraceback("uvloop.loop.Loop._on_idle", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_5, &__pyx_t_11) < 0) __PYX_ERR(1, 296, __pyx_L9_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_t_11);
__Pyx_INCREF(__pyx_t_5);
__pyx_v_ex = __pyx_t_5;
/*try:*/ {
/* "uvloop/loop.pyx":297
* handler._run()
* except BaseException as ex:
* self._stop(ex) # <<<<<<<<<<<<<<
* return
* else:
*/
__pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_stop(__pyx_v_self, __pyx_v_ex); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 297, __pyx_L21_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "uvloop/loop.pyx":298
* except BaseException as ex:
* self._stop(ex)
* return # <<<<<<<<<<<<<<
* else:
* delta = time_monotonic() - started
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
goto __pyx_L20_return;
}
/* "uvloop/loop.pyx":296
* started = time_monotonic()
* handler._run()
* except BaseException as ex: # <<<<<<<<<<<<<<
* self._stop(ex)
* return
*/
/*finally:*/ {
/*exception exit:*/{
__Pyx_PyThreadState_declare
__pyx_L21_error:;
__pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19);
if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16) < 0)) __Pyx_ErrFetch(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16);
__Pyx_XGOTREF(__pyx_t_14);
__Pyx_XGOTREF(__pyx_t_15);
__Pyx_XGOTREF(__pyx_t_16);
__Pyx_XGOTREF(__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_18);
__Pyx_XGOTREF(__pyx_t_19);
__pyx_t_10 = __pyx_lineno; __pyx_t_12 = __pyx_clineno; __pyx_t_13 = __pyx_filename;
{
__Pyx_DECREF(__pyx_v_ex);
__pyx_v_ex = NULL;
}
__Pyx_PyThreadState_assign
if (PY_MAJOR_VERSION >= 3) {
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_XGIVEREF(__pyx_t_19);
__Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19);
}
__Pyx_XGIVEREF(__pyx_t_14);
__Pyx_XGIVEREF(__pyx_t_15);
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_ErrRestore(__pyx_t_14, __pyx_t_15, __pyx_t_16);
__pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0;
__pyx_lineno = __pyx_t_10; __pyx_clineno = __pyx_t_12; __pyx_filename = __pyx_t_13;
goto __pyx_L9_except_error;
}
__pyx_L20_return: {
__pyx_t_19 = __pyx_r;
__pyx_r = 0;
__Pyx_DECREF(__pyx_v_ex);
__pyx_v_ex = NULL;
__pyx_r = __pyx_t_19;
__pyx_t_19 = 0;
goto __pyx_L10_except_return;
}
}
}
goto __pyx_L9_except_error;
__pyx_L9_except_error:;
/* "uvloop/loop.pyx":293
* handler = popleft()
* if handler.cancelled == 0:
* try: # <<<<<<<<<<<<<<
* started = time_monotonic()
* handler._run()
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9);
goto __pyx_L1_error;
__pyx_L10_except_return:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9);
goto __pyx_L0;
__pyx_L14_try_end:;
}
/* "uvloop/loop.pyx":292
* for i from 0 <= i < ntodo:
* handler = popleft()
* if handler.cancelled == 0: # <<<<<<<<<<<<<<
* try:
* started = time_monotonic()
*/
}
}
/* "uvloop/loop.pyx":289
*
* ntodo = len(self._ready)
* if self._debug: # <<<<<<<<<<<<<<
* for i from 0 <= i < ntodo:
* handler = popleft()
*/
goto __pyx_L3;
}
/* "uvloop/loop.pyx":307
*
* else:
* for i from 0 <= i < ntodo: # <<<<<<<<<<<<<<
* handler = popleft()
* if handler.cancelled == 0:
*/
/*else*/ {
__pyx_t_4 = __pyx_v_ntodo;
for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_4; __pyx_v_i++) {
/* "uvloop/loop.pyx":308
* else:
* for i from 0 <= i < ntodo:
* handler = popleft() # <<<<<<<<<<<<<<
* if handler.cancelled == 0:
* try:
*/
__Pyx_INCREF(__pyx_v_popleft);
__pyx_t_5 = __pyx_v_popleft; __pyx_t_1 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
__pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5);
if (likely(__pyx_t_1)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
__Pyx_INCREF(__pyx_t_1);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_5, function);
}
}
if (__pyx_t_1) {
__pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_1); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 308, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
__pyx_t_11 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 308, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_5 = __pyx_t_11;
__Pyx_INCREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_XDECREF_SET(__pyx_v_handler, ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_5));
__pyx_t_5 = 0;
/* "uvloop/loop.pyx":309
* for i from 0 <= i < ntodo:
* handler = popleft()
* if handler.cancelled == 0: # <<<<<<<<<<<<<<
* try:
* handler._run()
*/
__pyx_t_3 = ((__pyx_v_handler->cancelled == 0) != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":310
* handler = popleft()
* if handler.cancelled == 0:
* try: # <<<<<<<<<<<<<<
* handler._run()
* except BaseException as ex:
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_8, &__pyx_t_7);
__Pyx_XGOTREF(__pyx_t_9);
__Pyx_XGOTREF(__pyx_t_8);
__Pyx_XGOTREF(__pyx_t_7);
/*try:*/ {
/* "uvloop/loop.pyx":311
* if handler.cancelled == 0:
* try:
* handler._run() # <<<<<<<<<<<<<<
* except BaseException as ex:
* self._stop(ex)
*/
__pyx_t_5 = __pyx_f_6uvloop_4loop_6Handle__run(__pyx_v_handler); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 311, __pyx_L30_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":310
* handler = popleft()
* if handler.cancelled == 0:
* try: # <<<<<<<<<<<<<<
* handler._run()
* except BaseException as ex:
*/
}
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
goto __pyx_L37_try_end;
__pyx_L30_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":312
* try:
* handler._run()
* except BaseException as ex: # <<<<<<<<<<<<<<
* self._stop(ex)
* return
*/
__pyx_t_12 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BaseException);
if (__pyx_t_12) {
__Pyx_AddTraceback("uvloop.loop.Loop._on_idle", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_11, &__pyx_t_1) < 0) __PYX_ERR(1, 312, __pyx_L32_except_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_t_11);
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_t_11);
__pyx_v_ex = __pyx_t_11;
/*try:*/ {
/* "uvloop/loop.pyx":313
* handler._run()
* except BaseException as ex:
* self._stop(ex) # <<<<<<<<<<<<<<
* return
*
*/
__pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_stop(__pyx_v_self, __pyx_v_ex); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 313, __pyx_L43_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "uvloop/loop.pyx":314
* except BaseException as ex:
* self._stop(ex)
* return # <<<<<<<<<<<<<<
*
* if len(self._queued_streams):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
goto __pyx_L42_return;
}
/* "uvloop/loop.pyx":312
* try:
* handler._run()
* except BaseException as ex: # <<<<<<<<<<<<<<
* self._stop(ex)
* return
*/
/*finally:*/ {
/*exception exit:*/{
__Pyx_PyThreadState_declare
__pyx_L43_error:;
__pyx_t_19 = 0; __pyx_t_18 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_t_14 = 0;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_16, &__pyx_t_15, &__pyx_t_14);
if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_19, &__pyx_t_18, &__pyx_t_17) < 0)) __Pyx_ErrFetch(&__pyx_t_19, &__pyx_t_18, &__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_19);
__Pyx_XGOTREF(__pyx_t_18);
__Pyx_XGOTREF(__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_16);
__Pyx_XGOTREF(__pyx_t_15);
__Pyx_XGOTREF(__pyx_t_14);
__pyx_t_12 = __pyx_lineno; __pyx_t_10 = __pyx_clineno; __pyx_t_20 = __pyx_filename;
{
__Pyx_DECREF(__pyx_v_ex);
__pyx_v_ex = NULL;
}
__Pyx_PyThreadState_assign
if (PY_MAJOR_VERSION >= 3) {
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_XGIVEREF(__pyx_t_15);
__Pyx_XGIVEREF(__pyx_t_14);
__Pyx_ExceptionReset(__pyx_t_16, __pyx_t_15, __pyx_t_14);
}
__Pyx_XGIVEREF(__pyx_t_19);
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_ErrRestore(__pyx_t_19, __pyx_t_18, __pyx_t_17);
__pyx_t_19 = 0; __pyx_t_18 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_t_14 = 0;
__pyx_lineno = __pyx_t_12; __pyx_clineno = __pyx_t_10; __pyx_filename = __pyx_t_20;
goto __pyx_L32_except_error;
}
__pyx_L42_return: {
__pyx_t_14 = __pyx_r;
__pyx_r = 0;
__Pyx_DECREF(__pyx_v_ex);
__pyx_v_ex = NULL;
__pyx_r = __pyx_t_14;
__pyx_t_14 = 0;
goto __pyx_L33_except_return;
}
}
}
goto __pyx_L32_except_error;
__pyx_L32_except_error:;
/* "uvloop/loop.pyx":310
* handler = popleft()
* if handler.cancelled == 0:
* try: # <<<<<<<<<<<<<<
* handler._run()
* except BaseException as ex:
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_ExceptionReset(__pyx_t_9, __pyx_t_8, __pyx_t_7);
goto __pyx_L1_error;
__pyx_L33_except_return:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_ExceptionReset(__pyx_t_9, __pyx_t_8, __pyx_t_7);
goto __pyx_L0;
__pyx_L37_try_end:;
}
/* "uvloop/loop.pyx":309
* for i from 0 <= i < ntodo:
* handler = popleft()
* if handler.cancelled == 0: # <<<<<<<<<<<<<<
* try:
* handler._run()
*/
}
}
}
__pyx_L3:;
/* "uvloop/loop.pyx":316
* return
*
* if len(self._queued_streams): # <<<<<<<<<<<<<<
* self._exec_queued_writes()
*
*/
__pyx_t_1 = __pyx_v_self->_queued_streams;
__Pyx_INCREF(__pyx_t_1);
if (unlikely(__pyx_t_1 == Py_None)) {
PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
__PYX_ERR(1, 316, __pyx_L1_error)
}
__pyx_t_2 = PySet_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(1, 316, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":317
*
* if len(self._queued_streams):
* self._exec_queued_writes() # <<<<<<<<<<<<<<
*
* self._ready_len = len(self._ready)
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_exec_queued_writes(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 317, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":316
* return
*
* if len(self._queued_streams): # <<<<<<<<<<<<<<
* self._exec_queued_writes()
*
*/
}
/* "uvloop/loop.pyx":319
* self._exec_queued_writes()
*
* self._ready_len = len(self._ready) # <<<<<<<<<<<<<<
* if self._ready_len == 0 and self.handler_idle.running:
* self.handler_idle.stop()
*/
__pyx_t_1 = __pyx_v_self->_ready;
__Pyx_INCREF(__pyx_t_1);
__pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(1, 319, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_self->_ready_len = __pyx_t_2;
/* "uvloop/loop.pyx":320
*
* self._ready_len = len(self._ready)
* if self._ready_len == 0 and self.handler_idle.running: # <<<<<<<<<<<<<<
* self.handler_idle.stop()
*
*/
__pyx_t_21 = ((__pyx_v_self->_ready_len == 0) != 0);
if (__pyx_t_21) {
} else {
__pyx_t_3 = __pyx_t_21;
goto __pyx_L51_bool_binop_done;
}
__pyx_t_21 = (__pyx_v_self->handler_idle->running != 0);
__pyx_t_3 = __pyx_t_21;
__pyx_L51_bool_binop_done:;
if (__pyx_t_3) {
/* "uvloop/loop.pyx":321
* self._ready_len = len(self._ready)
* if self._ready_len == 0 and self.handler_idle.running:
* self.handler_idle.stop() # <<<<<<<<<<<<<<
*
* if self._stopping:
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_6UVIdle_stop(__pyx_v_self->handler_idle); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 321, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":320
*
* self._ready_len = len(self._ready)
* if self._ready_len == 0 and self.handler_idle.running: # <<<<<<<<<<<<<<
* self.handler_idle.stop()
*
*/
}
/* "uvloop/loop.pyx":323
* self.handler_idle.stop()
*
* if self._stopping: # <<<<<<<<<<<<<<
* uv.uv_stop(self.uvloop) # void
*
*/
__pyx_t_3 = (__pyx_v_self->_stopping != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":324
*
* if self._stopping:
* uv.uv_stop(self.uvloop) # void # <<<<<<<<<<<<<<
*
* cdef _stop(self, exc):
*/
uv_stop(__pyx_v_self->uvloop);
/* "uvloop/loop.pyx":323
* self.handler_idle.stop()
*
* if self._stopping: # <<<<<<<<<<<<<<
* uv.uv_stop(self.uvloop) # void
*
*/
}
/* "uvloop/loop.pyx":282
* self.handler_idle.start()
*
* cdef _on_idle(self): # <<<<<<<<<<<<<<
* cdef:
* int i, ntodo
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_11);
__Pyx_AddTraceback("uvloop.loop.Loop._on_idle", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_popleft);
__Pyx_XDECREF((PyObject *)__pyx_v_handler);
__Pyx_XDECREF(__pyx_v_started);
__Pyx_XDECREF(__pyx_v_ex);
__Pyx_XDECREF(__pyx_v_delta);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":326
* uv.uv_stop(self.uvloop) # void
*
* cdef _stop(self, exc): # <<<<<<<<<<<<<<
* if exc is not None:
* self._last_error = exc
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__stop(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_exc) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
__Pyx_RefNannySetupContext("_stop", 0);
/* "uvloop/loop.pyx":327
*
* cdef _stop(self, exc):
* if exc is not None: # <<<<<<<<<<<<<<
* self._last_error = exc
* if self._stopping == 1:
*/
__pyx_t_1 = (__pyx_v_exc != Py_None);
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":328
* cdef _stop(self, exc):
* if exc is not None:
* self._last_error = exc # <<<<<<<<<<<<<<
* if self._stopping == 1:
* return
*/
__Pyx_INCREF(__pyx_v_exc);
__Pyx_GIVEREF(__pyx_v_exc);
__Pyx_GOTREF(__pyx_v_self->_last_error);
__Pyx_DECREF(__pyx_v_self->_last_error);
__pyx_v_self->_last_error = __pyx_v_exc;
/* "uvloop/loop.pyx":327
*
* cdef _stop(self, exc):
* if exc is not None: # <<<<<<<<<<<<<<
* self._last_error = exc
* if self._stopping == 1:
*/
}
/* "uvloop/loop.pyx":329
* if exc is not None:
* self._last_error = exc
* if self._stopping == 1: # <<<<<<<<<<<<<<
* return
* self._stopping = 1
*/
__pyx_t_2 = ((__pyx_v_self->_stopping == 1) != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":330
* self._last_error = exc
* if self._stopping == 1:
* return # <<<<<<<<<<<<<<
* self._stopping = 1
* if not self.handler_idle.running:
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
/* "uvloop/loop.pyx":329
* if exc is not None:
* self._last_error = exc
* if self._stopping == 1: # <<<<<<<<<<<<<<
* return
* self._stopping = 1
*/
}
/* "uvloop/loop.pyx":331
* if self._stopping == 1:
* return
* self._stopping = 1 # <<<<<<<<<<<<<<
* if not self.handler_idle.running:
* self.handler_idle.start()
*/
__pyx_v_self->_stopping = 1;
/* "uvloop/loop.pyx":332
* return
* self._stopping = 1
* if not self.handler_idle.running: # <<<<<<<<<<<<<<
* self.handler_idle.start()
*
*/
__pyx_t_2 = ((!(__pyx_v_self->handler_idle->running != 0)) != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":333
* self._stopping = 1
* if not self.handler_idle.running:
* self.handler_idle.start() # <<<<<<<<<<<<<<
*
* cdef __run(self, uv.uv_run_mode mode):
*/
__pyx_t_3 = __pyx_f_6uvloop_4loop_6UVIdle_start(__pyx_v_self->handler_idle); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 333, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":332
* return
* self._stopping = 1
* if not self.handler_idle.running: # <<<<<<<<<<<<<<
* self.handler_idle.start()
*
*/
}
/* "uvloop/loop.pyx":326
* uv.uv_stop(self.uvloop) # void
*
* cdef _stop(self, exc): # <<<<<<<<<<<<<<
* if exc is not None:
* self._last_error = exc
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_AddTraceback("uvloop.loop.Loop._stop", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":335
* self.handler_idle.start()
*
* cdef __run(self, uv.uv_run_mode mode): # <<<<<<<<<<<<<<
* # Although every UVHandle holds a reference to the loop,
* # we want to do everything to ensure that the loop will
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop___run(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, uv_run_mode __pyx_v_mode) {
int __pyx_v_err;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
__Pyx_RefNannySetupContext("__run", 0);
/* "uvloop/loop.pyx":340
* # never deallocate during the run -- so we do some
* # manual refs management.
* Py_INCREF(self) # <<<<<<<<<<<<<<
* with nogil:
* err = uv.uv_run(self.uvloop, mode)
*/
Py_INCREF(((PyObject *)__pyx_v_self));
/* "uvloop/loop.pyx":341
* # manual refs management.
* Py_INCREF(self)
* with nogil: # <<<<<<<<<<<<<<
* err = uv.uv_run(self.uvloop, mode)
* Py_DECREF(self)
*/
{
#ifdef WITH_THREAD
PyThreadState *_save;
Py_UNBLOCK_THREADS
#endif
/*try:*/ {
/* "uvloop/loop.pyx":342
* Py_INCREF(self)
* with nogil:
* err = uv.uv_run(self.uvloop, mode) # <<<<<<<<<<<<<<
* Py_DECREF(self)
*
*/
__pyx_v_err = uv_run(__pyx_v_self->uvloop, __pyx_v_mode);
}
/* "uvloop/loop.pyx":341
* # manual refs management.
* Py_INCREF(self)
* with nogil: # <<<<<<<<<<<<<<
* err = uv.uv_run(self.uvloop, mode)
* Py_DECREF(self)
*/
/*finally:*/ {
/*normal exit:*/{
#ifdef WITH_THREAD
Py_BLOCK_THREADS
#endif
goto __pyx_L5;
}
__pyx_L5:;
}
}
/* "uvloop/loop.pyx":343
* with nogil:
* err = uv.uv_run(self.uvloop, mode)
* Py_DECREF(self) # <<<<<<<<<<<<<<
*
* if err < 0:
*/
Py_DECREF(((PyObject *)__pyx_v_self));
/* "uvloop/loop.pyx":345
* Py_DECREF(self)
*
* if err < 0: # <<<<<<<<<<<<<<
* raise convert_error(err)
*
*/
__pyx_t_1 = ((__pyx_v_err < 0) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":346
*
* if err < 0:
* raise convert_error(err) # <<<<<<<<<<<<<<
*
* cdef _run(self, uv.uv_run_mode mode):
*/
__pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 346, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__PYX_ERR(1, 346, __pyx_L1_error)
/* "uvloop/loop.pyx":345
* Py_DECREF(self)
*
* if err < 0: # <<<<<<<<<<<<<<
* raise convert_error(err)
*
*/
}
/* "uvloop/loop.pyx":335
* self.handler_idle.start()
*
* cdef __run(self, uv.uv_run_mode mode): # <<<<<<<<<<<<<<
* # Although every UVHandle holds a reference to the loop,
* # we want to do everything to ensure that the loop will
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_AddTraceback("uvloop.loop.Loop.__run", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":348
* raise convert_error(err)
*
* cdef _run(self, uv.uv_run_mode mode): # <<<<<<<<<<<<<<
* cdef int err
*
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__run(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, uv_run_mode __pyx_v_mode) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
int __pyx_t_3;
int __pyx_t_4;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
int __pyx_t_8;
int __pyx_t_9;
char const *__pyx_t_10;
PyObject *__pyx_t_11 = NULL;
PyObject *__pyx_t_12 = NULL;
PyObject *__pyx_t_13 = NULL;
PyObject *__pyx_t_14 = NULL;
PyObject *__pyx_t_15 = NULL;
PyObject *__pyx_t_16 = NULL;
__Pyx_RefNannySetupContext("_run", 0);
/* "uvloop/loop.pyx":351
* cdef int err
*
* if self._closed == 1: # <<<<<<<<<<<<<<
* raise RuntimeError('unable to start the loop; it was closed')
*
*/
__pyx_t_1 = ((__pyx_v_self->_closed == 1) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":352
*
* if self._closed == 1:
* raise RuntimeError('unable to start the loop; it was closed') # <<<<<<<<<<<<<<
*
* if self._running == 1:
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 352, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__PYX_ERR(1, 352, __pyx_L1_error)
/* "uvloop/loop.pyx":351
* cdef int err
*
* if self._closed == 1: # <<<<<<<<<<<<<<
* raise RuntimeError('unable to start the loop; it was closed')
*
*/
}
/* "uvloop/loop.pyx":354
* raise RuntimeError('unable to start the loop; it was closed')
*
* if self._running == 1: # <<<<<<<<<<<<<<
* raise RuntimeError('this event loop is already running.')
*
*/
__pyx_t_1 = ((__pyx_v_self->_running == 1) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":355
*
* if self._running == 1:
* raise RuntimeError('this event loop is already running.') # <<<<<<<<<<<<<<
*
* if (aio_get_running_loop is not None and
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 355, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__PYX_ERR(1, 355, __pyx_L1_error)
/* "uvloop/loop.pyx":354
* raise RuntimeError('unable to start the loop; it was closed')
*
* if self._running == 1: # <<<<<<<<<<<<<<
* raise RuntimeError('this event loop is already running.')
*
*/
}
/* "uvloop/loop.pyx":357
* raise RuntimeError('this event loop is already running.')
*
* if (aio_get_running_loop is not None and # <<<<<<<<<<<<<<
* aio_get_running_loop() is not None):
* raise RuntimeError(
*/
__pyx_t_3 = (__pyx_v_6uvloop_4loop_aio_get_running_loop != Py_None);
__pyx_t_4 = (__pyx_t_3 != 0);
if (__pyx_t_4) {
} else {
__pyx_t_1 = __pyx_t_4;
goto __pyx_L6_bool_binop_done;
}
/* "uvloop/loop.pyx":358
*
* if (aio_get_running_loop is not None and
* aio_get_running_loop() is not None): # <<<<<<<<<<<<<<
* raise RuntimeError(
* 'Cannot run the event loop while another loop is running')
*/
__Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_get_running_loop);
__pyx_t_5 = __pyx_v_6uvloop_4loop_aio_get_running_loop; __pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_5, function);
}
}
if (__pyx_t_6) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 358, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
__pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 358, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_4 = (__pyx_t_2 != Py_None);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_3 = (__pyx_t_4 != 0);
__pyx_t_1 = __pyx_t_3;
__pyx_L6_bool_binop_done:;
/* "uvloop/loop.pyx":357
* raise RuntimeError('this event loop is already running.')
*
* if (aio_get_running_loop is not None and # <<<<<<<<<<<<<<
* aio_get_running_loop() is not None):
* raise RuntimeError(
*/
if (__pyx_t_1) {
/* "uvloop/loop.pyx":359
* if (aio_get_running_loop is not None and
* aio_get_running_loop() is not None):
* raise RuntimeError( # <<<<<<<<<<<<<<
* 'Cannot run the event loop while another loop is running')
*
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 359, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__PYX_ERR(1, 359, __pyx_L1_error)
/* "uvloop/loop.pyx":357
* raise RuntimeError('this event loop is already running.')
*
* if (aio_get_running_loop is not None and # <<<<<<<<<<<<<<
* aio_get_running_loop() is not None):
* raise RuntimeError(
*/
}
/* "uvloop/loop.pyx":362
* 'Cannot run the event loop while another loop is running')
*
* if self._signal_handlers is None: # <<<<<<<<<<<<<<
* self._setup_signals()
*
*/
__pyx_t_1 = (__pyx_v_self->_signal_handlers == ((PyObject*)Py_None));
__pyx_t_3 = (__pyx_t_1 != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":363
*
* if self._signal_handlers is None:
* self._setup_signals() # <<<<<<<<<<<<<<
*
* # reset _last_error
*/
__pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_setup_signals(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 363, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":362
* 'Cannot run the event loop while another loop is running')
*
* if self._signal_handlers is None: # <<<<<<<<<<<<<<
* self._setup_signals()
*
*/
}
/* "uvloop/loop.pyx":366
*
* # reset _last_error
* self._last_error = None # <<<<<<<<<<<<<<
*
* self._thread_id = PyThread_get_thread_ident()
*/
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__Pyx_GOTREF(__pyx_v_self->_last_error);
__Pyx_DECREF(__pyx_v_self->_last_error);
__pyx_v_self->_last_error = Py_None;
/* "uvloop/loop.pyx":368
* self._last_error = None
*
* self._thread_id = PyThread_get_thread_ident() # <<<<<<<<<<<<<<
* self._thread_is_main = MAIN_THREAD_ID == self._thread_id
* self._running = 1
*/
__pyx_v_self->_thread_id = PyThread_get_thread_ident();
/* "uvloop/loop.pyx":369
*
* self._thread_id = PyThread_get_thread_ident()
* self._thread_is_main = MAIN_THREAD_ID == self._thread_id # <<<<<<<<<<<<<<
* self._running = 1
*
*/
__pyx_v_self->_thread_is_main = (__pyx_v_6uvloop_4loop_MAIN_THREAD_ID == __pyx_v_self->_thread_id);
/* "uvloop/loop.pyx":370
* self._thread_id = PyThread_get_thread_ident()
* self._thread_is_main = MAIN_THREAD_ID == self._thread_id
* self._running = 1 # <<<<<<<<<<<<<<
*
* self.handler_check__exec_writes.start()
*/
__pyx_v_self->_running = 1;
/* "uvloop/loop.pyx":372
* self._running = 1
*
* self.handler_check__exec_writes.start() # <<<<<<<<<<<<<<
* self.handler_idle.start()
*
*/
__pyx_t_2 = __pyx_f_6uvloop_4loop_7UVCheck_start(__pyx_v_self->handler_check__exec_writes); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 372, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":373
*
* self.handler_check__exec_writes.start()
* self.handler_idle.start() # <<<<<<<<<<<<<<
*
* if aio_set_running_loop is not None:
*/
__pyx_t_2 = __pyx_f_6uvloop_4loop_6UVIdle_start(__pyx_v_self->handler_idle); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 373, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":375
* self.handler_idle.start()
*
* if aio_set_running_loop is not None: # <<<<<<<<<<<<<<
* aio_set_running_loop(self)
* try:
*/
__pyx_t_3 = (__pyx_v_6uvloop_4loop_aio_set_running_loop != Py_None);
__pyx_t_1 = (__pyx_t_3 != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":376
*
* if aio_set_running_loop is not None:
* aio_set_running_loop(self) # <<<<<<<<<<<<<<
* try:
* self.__run(mode)
*/
__Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_set_running_loop);
__pyx_t_5 = __pyx_v_6uvloop_4loop_aio_set_running_loop; __pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_5, function);
}
}
if (!__pyx_t_6) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_5, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 376, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_5)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, ((PyObject *)__pyx_v_self)};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 376, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, ((PyObject *)__pyx_v_self)};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 376, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else
#endif
{
__pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 376, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_v_self));
PyTuple_SET_ITEM(__pyx_t_7, 0+1, ((PyObject *)__pyx_v_self));
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 376, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":375
* self.handler_idle.start()
*
* if aio_set_running_loop is not None: # <<<<<<<<<<<<<<
* aio_set_running_loop(self)
* try:
*/
}
/* "uvloop/loop.pyx":377
* if aio_set_running_loop is not None:
* aio_set_running_loop(self)
* try: # <<<<<<<<<<<<<<
* self.__run(mode)
* finally:
*/
/*try:*/ {
/* "uvloop/loop.pyx":378
* aio_set_running_loop(self)
* try:
* self.__run(mode) # <<<<<<<<<<<<<<
* finally:
* if aio_set_running_loop is not None:
*/
__pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->__pyx___run(__pyx_v_self, __pyx_v_mode); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 378, __pyx_L11_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
/* "uvloop/loop.pyx":380
* self.__run(mode)
* finally:
* if aio_set_running_loop is not None: # <<<<<<<<<<<<<<
* aio_set_running_loop(None)
*
*/
/*finally:*/ {
/*normal exit:*/{
__pyx_t_1 = (__pyx_v_6uvloop_4loop_aio_set_running_loop != Py_None);
__pyx_t_3 = (__pyx_t_1 != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":381
* finally:
* if aio_set_running_loop is not None:
* aio_set_running_loop(None) # <<<<<<<<<<<<<<
*
* self.handler_check__exec_writes.stop()
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_v_6uvloop_4loop_aio_set_running_loop, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 381, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":380
* self.__run(mode)
* finally:
* if aio_set_running_loop is not None: # <<<<<<<<<<<<<<
* aio_set_running_loop(None)
*
*/
}
goto __pyx_L12;
}
/*exception exit:*/{
__Pyx_PyThreadState_declare
__pyx_L11_error:;
__pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16);
if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13) < 0)) __Pyx_ErrFetch(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13);
__Pyx_XGOTREF(__pyx_t_11);
__Pyx_XGOTREF(__pyx_t_12);
__Pyx_XGOTREF(__pyx_t_13);
__Pyx_XGOTREF(__pyx_t_14);
__Pyx_XGOTREF(__pyx_t_15);
__Pyx_XGOTREF(__pyx_t_16);
__pyx_t_8 = __pyx_lineno; __pyx_t_9 = __pyx_clineno; __pyx_t_10 = __pyx_filename;
{
__pyx_t_3 = (__pyx_v_6uvloop_4loop_aio_set_running_loop != Py_None);
__pyx_t_1 = (__pyx_t_3 != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":381
* finally:
* if aio_set_running_loop is not None:
* aio_set_running_loop(None) # <<<<<<<<<<<<<<
*
* self.handler_check__exec_writes.stop()
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_v_6uvloop_4loop_aio_set_running_loop, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 381, __pyx_L15_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":380
* self.__run(mode)
* finally:
* if aio_set_running_loop is not None: # <<<<<<<<<<<<<<
* aio_set_running_loop(None)
*
*/
}
}
__Pyx_PyThreadState_assign
if (PY_MAJOR_VERSION >= 3) {
__Pyx_XGIVEREF(__pyx_t_14);
__Pyx_XGIVEREF(__pyx_t_15);
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16);
}
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_XGIVEREF(__pyx_t_12);
__Pyx_XGIVEREF(__pyx_t_13);
__Pyx_ErrRestore(__pyx_t_11, __pyx_t_12, __pyx_t_13);
__pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0;
__pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_9; __pyx_filename = __pyx_t_10;
goto __pyx_L1_error;
__pyx_L15_error:;
__Pyx_PyThreadState_assign
if (PY_MAJOR_VERSION >= 3) {
__Pyx_XGIVEREF(__pyx_t_14);
__Pyx_XGIVEREF(__pyx_t_15);
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16);
}
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
__pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0;
goto __pyx_L1_error;
}
__pyx_L12:;
}
/* "uvloop/loop.pyx":383
* aio_set_running_loop(None)
*
* self.handler_check__exec_writes.stop() # <<<<<<<<<<<<<<
* self.handler_idle.stop()
*
*/
__pyx_t_2 = __pyx_f_6uvloop_4loop_7UVCheck_stop(__pyx_v_self->handler_check__exec_writes); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 383, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":384
*
* self.handler_check__exec_writes.stop()
* self.handler_idle.stop() # <<<<<<<<<<<<<<
*
* self._thread_is_main = 0
*/
__pyx_t_2 = __pyx_f_6uvloop_4loop_6UVIdle_stop(__pyx_v_self->handler_idle); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 384, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":386
* self.handler_idle.stop()
*
* self._thread_is_main = 0 # <<<<<<<<<<<<<<
* self._thread_id = 0
* self._running = 0
*/
__pyx_v_self->_thread_is_main = 0;
/* "uvloop/loop.pyx":387
*
* self._thread_is_main = 0
* self._thread_id = 0 # <<<<<<<<<<<<<<
* self._running = 0
* self._stopping = 0
*/
__pyx_v_self->_thread_id = 0;
/* "uvloop/loop.pyx":388
* self._thread_is_main = 0
* self._thread_id = 0
* self._running = 0 # <<<<<<<<<<<<<<
* self._stopping = 0
*
*/
__pyx_v_self->_running = 0;
/* "uvloop/loop.pyx":389
* self._thread_id = 0
* self._running = 0
* self._stopping = 0 # <<<<<<<<<<<<<<
*
* if self._last_error is not None:
*/
__pyx_v_self->_stopping = 0;
/* "uvloop/loop.pyx":391
* self._stopping = 0
*
* if self._last_error is not None: # <<<<<<<<<<<<<<
* # The loop was stopped with an error with 'loop._stop(error)' call
* raise self._last_error
*/
__pyx_t_1 = (__pyx_v_self->_last_error != Py_None);
__pyx_t_3 = (__pyx_t_1 != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":393
* if self._last_error is not None:
* # The loop was stopped with an error with 'loop._stop(error)' call
* raise self._last_error # <<<<<<<<<<<<<<
*
* cdef _close(self):
*/
__Pyx_Raise(__pyx_v_self->_last_error, 0, 0, 0);
__PYX_ERR(1, 393, __pyx_L1_error)
/* "uvloop/loop.pyx":391
* self._stopping = 0
*
* if self._last_error is not None: # <<<<<<<<<<<<<<
* # The loop was stopped with an error with 'loop._stop(error)' call
* raise self._last_error
*/
}
/* "uvloop/loop.pyx":348
* raise convert_error(err)
*
* cdef _run(self, uv.uv_run_mode mode): # <<<<<<<<<<<<<<
* cdef int err
*
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_AddTraceback("uvloop.loop.Loop._run", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":395
* raise self._last_error
*
* cdef _close(self): # <<<<<<<<<<<<<<
* cdef int err
*
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__close(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
int __pyx_v_err;
PyObject *__pyx_v_cb_handle = NULL;
PyObject *__pyx_v_poll_handle = NULL;
PyObject *__pyx_v_timer_cbhandle = NULL;
PyObject *__pyx_v_executor = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
Py_ssize_t __pyx_t_3;
PyObject *(*__pyx_t_4)(PyObject *);
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
Py_ssize_t __pyx_t_8;
int __pyx_t_9;
int __pyx_t_10;
int __pyx_t_11;
int __pyx_t_12;
__Pyx_RefNannySetupContext("_close", 0);
/* "uvloop/loop.pyx":398
* cdef int err
*
* if self._running == 1: # <<<<<<<<<<<<<<
* raise RuntimeError("Cannot close a running event loop")
*
*/
__pyx_t_1 = ((__pyx_v_self->_running == 1) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":399
*
* if self._running == 1:
* raise RuntimeError("Cannot close a running event loop") # <<<<<<<<<<<<<<
*
* if self._closed == 1:
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 399, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__PYX_ERR(1, 399, __pyx_L1_error)
/* "uvloop/loop.pyx":398
* cdef int err
*
* if self._running == 1: # <<<<<<<<<<<<<<
* raise RuntimeError("Cannot close a running event loop")
*
*/
}
/* "uvloop/loop.pyx":401
* raise RuntimeError("Cannot close a running event loop")
*
* if self._closed == 1: # <<<<<<<<<<<<<<
* return
*
*/
__pyx_t_1 = ((__pyx_v_self->_closed == 1) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":402
*
* if self._closed == 1:
* return # <<<<<<<<<<<<<<
*
* self._closed = 1
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
/* "uvloop/loop.pyx":401
* raise RuntimeError("Cannot close a running event loop")
*
* if self._closed == 1: # <<<<<<<<<<<<<<
* return
*
*/
}
/* "uvloop/loop.pyx":404
* return
*
* self._closed = 1 # <<<<<<<<<<<<<<
*
* for cb_handle in self._ready:
*/
__pyx_v_self->_closed = 1;
/* "uvloop/loop.pyx":406
* self._closed = 1
*
* for cb_handle in self._ready: # <<<<<<<<<<<<<<
* cb_handle.cancel()
* self._ready.clear()
*/
if (likely(PyList_CheckExact(__pyx_v_self->_ready)) || PyTuple_CheckExact(__pyx_v_self->_ready)) {
__pyx_t_2 = __pyx_v_self->_ready; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0;
__pyx_t_4 = NULL;
} else {
__pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_self->_ready); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 406, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 406, __pyx_L1_error)
}
for (;;) {
if (likely(!__pyx_t_4)) {
if (likely(PyList_CheckExact(__pyx_t_2))) {
if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 406, __pyx_L1_error)
#else
__pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 406, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
#endif
} else {
if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 406, __pyx_L1_error)
#else
__pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 406, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
#endif
}
} else {
__pyx_t_5 = __pyx_t_4(__pyx_t_2);
if (unlikely(!__pyx_t_5)) {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(1, 406, __pyx_L1_error)
}
break;
}
__Pyx_GOTREF(__pyx_t_5);
}
__Pyx_XDECREF_SET(__pyx_v_cb_handle, __pyx_t_5);
__pyx_t_5 = 0;
/* "uvloop/loop.pyx":407
*
* for cb_handle in self._ready:
* cb_handle.cancel() # <<<<<<<<<<<<<<
* self._ready.clear()
* self._ready_len = 0
*/
__pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_cb_handle, __pyx_n_s_cancel); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 407, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_7 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
__pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
if (likely(__pyx_t_7)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
__Pyx_INCREF(__pyx_t_7);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_6, function);
}
}
if (__pyx_t_7) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 407, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else {
__pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 407, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":406
* self._closed = 1
*
* for cb_handle in self._ready: # <<<<<<<<<<<<<<
* cb_handle.cancel()
* self._ready.clear()
*/
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":408
* for cb_handle in self._ready:
* cb_handle.cancel()
* self._ready.clear() # <<<<<<<<<<<<<<
* self._ready_len = 0
*
*/
__pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_ready, __pyx_n_s_clear); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 408, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_5, function);
}
}
if (__pyx_t_6) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 408, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
__pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 408, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":409
* cb_handle.cancel()
* self._ready.clear()
* self._ready_len = 0 # <<<<<<<<<<<<<<
*
* if self._polls:
*/
__pyx_v_self->_ready_len = 0;
/* "uvloop/loop.pyx":411
* self._ready_len = 0
*
* if self._polls: # <<<<<<<<<<<<<<
* for poll_handle in self._polls.values():
* (poll_handle)._close()
*/
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->_polls); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 411, __pyx_L1_error)
if (__pyx_t_1) {
/* "uvloop/loop.pyx":412
*
* if self._polls:
* for poll_handle in self._polls.values(): # <<<<<<<<<<<<<<
* (poll_handle)._close()
*
*/
__pyx_t_3 = 0;
if (unlikely(__pyx_v_self->_polls == Py_None)) {
PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "values");
__PYX_ERR(1, 412, __pyx_L1_error)
}
__pyx_t_5 = __Pyx_dict_iterator(__pyx_v_self->_polls, 1, __pyx_n_s_values, (&__pyx_t_8), (&__pyx_t_9)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 412, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_2);
__pyx_t_2 = __pyx_t_5;
__pyx_t_5 = 0;
while (1) {
__pyx_t_10 = __Pyx_dict_iter_next(__pyx_t_2, __pyx_t_8, &__pyx_t_3, NULL, &__pyx_t_5, NULL, __pyx_t_9);
if (unlikely(__pyx_t_10 == 0)) break;
if (unlikely(__pyx_t_10 == -1)) __PYX_ERR(1, 412, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_XDECREF_SET(__pyx_v_poll_handle, __pyx_t_5);
__pyx_t_5 = 0;
/* "uvloop/loop.pyx":413
* if self._polls:
* for poll_handle in self._polls.values():
* (poll_handle)._close() # <<<<<<<<<<<<<<
*
* self._polls.clear()
*/
__pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVHandle *)((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_poll_handle)->__pyx_vtab)->_close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_poll_handle)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 413, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":415
* (poll_handle)._close()
*
* self._polls.clear() # <<<<<<<<<<<<<<
*
* if self._timers:
*/
if (unlikely(__pyx_v_self->_polls == Py_None)) {
PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "clear");
__PYX_ERR(1, 415, __pyx_L1_error)
}
__pyx_t_11 = __Pyx_PyDict_Clear(__pyx_v_self->_polls); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(1, 415, __pyx_L1_error)
/* "uvloop/loop.pyx":411
* self._ready_len = 0
*
* if self._polls: # <<<<<<<<<<<<<<
* for poll_handle in self._polls.values():
* (poll_handle)._close()
*/
}
/* "uvloop/loop.pyx":417
* self._polls.clear()
*
* if self._timers: # <<<<<<<<<<<<<<
* for timer_cbhandle in tuple(self._timers):
* timer_cbhandle.cancel()
*/
__pyx_t_1 = (__pyx_v_self->_timers != Py_None) && (PySet_GET_SIZE(__pyx_v_self->_timers) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":418
*
* if self._timers:
* for timer_cbhandle in tuple(self._timers): # <<<<<<<<<<<<<<
* timer_cbhandle.cancel()
*
*/
__pyx_t_2 = PySequence_Tuple(__pyx_v_self->_timers); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 418, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_5 = __pyx_t_2; __Pyx_INCREF(__pyx_t_5); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
for (;;) {
if (__pyx_t_8 >= PyTuple_GET_SIZE(__pyx_t_5)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_2 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_8); __Pyx_INCREF(__pyx_t_2); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(1, 418, __pyx_L1_error)
#else
__pyx_t_2 = PySequence_ITEM(__pyx_t_5, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 418, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
__Pyx_XDECREF_SET(__pyx_v_timer_cbhandle, __pyx_t_2);
__pyx_t_2 = 0;
/* "uvloop/loop.pyx":419
* if self._timers:
* for timer_cbhandle in tuple(self._timers):
* timer_cbhandle.cancel() # <<<<<<<<<<<<<<
*
* # Close all remaining handles
*/
__pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_timer_cbhandle, __pyx_n_s_cancel); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 419, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_7 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
__pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
if (likely(__pyx_t_7)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
__Pyx_INCREF(__pyx_t_7);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_6, function);
}
}
if (__pyx_t_7) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 419, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else {
__pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 419, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":418
*
* if self._timers:
* for timer_cbhandle in tuple(self._timers): # <<<<<<<<<<<<<<
* timer_cbhandle.cancel()
*
*/
}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":417
* self._polls.clear()
*
* if self._timers: # <<<<<<<<<<<<<<
* for timer_cbhandle in tuple(self._timers):
* timer_cbhandle.cancel()
*/
}
/* "uvloop/loop.pyx":422
*
* # Close all remaining handles
* self.handler_async._close() # <<<<<<<<<<<<<<
* self.handler_idle._close()
* self.handler_check__exec_writes._close()
*/
__pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVAsync *)__pyx_v_self->handler_async->__pyx_base.__pyx_vtab)->__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self->handler_async)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 422, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":423
* # Close all remaining handles
* self.handler_async._close()
* self.handler_idle._close() # <<<<<<<<<<<<<<
* self.handler_check__exec_writes._close()
* __close_all_handles(self)
*/
__pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVIdle *)__pyx_v_self->handler_idle->__pyx_base.__pyx_vtab)->__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self->handler_idle)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 423, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":424
* self.handler_async._close()
* self.handler_idle._close()
* self.handler_check__exec_writes._close() # <<<<<<<<<<<<<<
* __close_all_handles(self)
* self._shutdown_signals()
*/
__pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVCheck *)__pyx_v_self->handler_check__exec_writes->__pyx_base.__pyx_vtab)->__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_self->handler_check__exec_writes)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 424, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":425
* self.handler_idle._close()
* self.handler_check__exec_writes._close()
* __close_all_handles(self) # <<<<<<<<<<<<<<
* self._shutdown_signals()
* # During this run there should be no open handles,
*/
__pyx_f_6uvloop_4loop___close_all_handles(__pyx_v_self);
/* "uvloop/loop.pyx":426
* self.handler_check__exec_writes._close()
* __close_all_handles(self)
* self._shutdown_signals() # <<<<<<<<<<<<<<
* # During this run there should be no open handles,
* # so it should finish right away
*/
__pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_shutdown_signals(__pyx_v_self); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 426, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":429
* # During this run there should be no open handles,
* # so it should finish right away
* self.__run(uv.UV_RUN_DEFAULT) # <<<<<<<<<<<<<<
*
* if self._timers:
*/
__pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->__pyx___run(__pyx_v_self, UV_RUN_DEFAULT); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 429, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":431
* self.__run(uv.UV_RUN_DEFAULT)
*
* if self._timers: # <<<<<<<<<<<<<<
* raise RuntimeError(
* "new timers were queued during loop closing: {}"
*/
__pyx_t_1 = (__pyx_v_self->_timers != Py_None) && (PySet_GET_SIZE(__pyx_v_self->_timers) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":434
* raise RuntimeError(
* "new timers were queued during loop closing: {}"
* .format(self._timers)) # <<<<<<<<<<<<<<
*
* if self._polls:
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_new_timers_were_queued_during_lo, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 434, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (!__pyx_t_6) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_self->_timers); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 434, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_self->_timers};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 434, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_self->_timers};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 434, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else
#endif
{
__pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 434, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_INCREF(__pyx_v_self->_timers);
__Pyx_GIVEREF(__pyx_v_self->_timers);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_self->_timers);
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 434, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":432
*
* if self._timers:
* raise RuntimeError( # <<<<<<<<<<<<<<
* "new timers were queued during loop closing: {}"
* .format(self._timers))
*/
__pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 432, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 432, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_Raise(__pyx_t_5, 0, 0, 0);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__PYX_ERR(1, 432, __pyx_L1_error)
/* "uvloop/loop.pyx":431
* self.__run(uv.UV_RUN_DEFAULT)
*
* if self._timers: # <<<<<<<<<<<<<<
* raise RuntimeError(
* "new timers were queued during loop closing: {}"
*/
}
/* "uvloop/loop.pyx":436
* .format(self._timers))
*
* if self._polls: # <<<<<<<<<<<<<<
* raise RuntimeError(
* "new poll handles were queued during loop closing: {}"
*/
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->_polls); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 436, __pyx_L1_error)
if (__pyx_t_1) {
/* "uvloop/loop.pyx":439
* raise RuntimeError(
* "new poll handles were queued during loop closing: {}"
* .format(self._polls)) # <<<<<<<<<<<<<<
*
* if self._ready:
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_new_poll_handles_were_queued_dur, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 439, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_7 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_7 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_7)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_7);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (!__pyx_t_7) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_self->_polls); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 439, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_self->_polls};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 439, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_self->_polls};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 439, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else
#endif
{
__pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 439, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7); __pyx_t_7 = NULL;
__Pyx_INCREF(__pyx_v_self->_polls);
__Pyx_GIVEREF(__pyx_v_self->_polls);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_self->_polls);
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 439, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":437
*
* if self._polls:
* raise RuntimeError( # <<<<<<<<<<<<<<
* "new poll handles were queued during loop closing: {}"
* .format(self._polls))
*/
__pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 437, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 437, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_Raise(__pyx_t_5, 0, 0, 0);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__PYX_ERR(1, 437, __pyx_L1_error)
/* "uvloop/loop.pyx":436
* .format(self._timers))
*
* if self._polls: # <<<<<<<<<<<<<<
* raise RuntimeError(
* "new poll handles were queued during loop closing: {}"
*/
}
/* "uvloop/loop.pyx":441
* .format(self._polls))
*
* if self._ready: # <<<<<<<<<<<<<<
* raise RuntimeError(
* "new callbacks were queued during loop closing: {}"
*/
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_self->_ready); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 441, __pyx_L1_error)
if (__pyx_t_1) {
/* "uvloop/loop.pyx":444
* raise RuntimeError(
* "new callbacks were queued during loop closing: {}"
* .format(self._ready)) # <<<<<<<<<<<<<<
*
* err = uv.uv_loop_close(self.uvloop)
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_new_callbacks_were_queued_during, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 444, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (!__pyx_t_6) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_self->_ready); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 444, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_self->_ready};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 444, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_self->_ready};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 444, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else
#endif
{
__pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 444, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_INCREF(__pyx_v_self->_ready);
__Pyx_GIVEREF(__pyx_v_self->_ready);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_self->_ready);
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 444, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":442
*
* if self._ready:
* raise RuntimeError( # <<<<<<<<<<<<<<
* "new callbacks were queued during loop closing: {}"
* .format(self._ready))
*/
__pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 442, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 442, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_Raise(__pyx_t_5, 0, 0, 0);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__PYX_ERR(1, 442, __pyx_L1_error)
/* "uvloop/loop.pyx":441
* .format(self._polls))
*
* if self._ready: # <<<<<<<<<<<<<<
* raise RuntimeError(
* "new callbacks were queued during loop closing: {}"
*/
}
/* "uvloop/loop.pyx":446
* .format(self._ready))
*
* err = uv.uv_loop_close(self.uvloop) # <<<<<<<<<<<<<<
* if err < 0:
* raise convert_error(err)
*/
__pyx_v_err = uv_loop_close(__pyx_v_self->uvloop);
/* "uvloop/loop.pyx":447
*
* err = uv.uv_loop_close(self.uvloop)
* if err < 0: # <<<<<<<<<<<<<<
* raise convert_error(err)
*
*/
__pyx_t_1 = ((__pyx_v_err < 0) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":448
* err = uv.uv_loop_close(self.uvloop)
* if err < 0:
* raise convert_error(err) # <<<<<<<<<<<<<<
*
* self.handler_async = None
*/
__pyx_t_5 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 448, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_Raise(__pyx_t_5, 0, 0, 0);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__PYX_ERR(1, 448, __pyx_L1_error)
/* "uvloop/loop.pyx":447
*
* err = uv.uv_loop_close(self.uvloop)
* if err < 0: # <<<<<<<<<<<<<<
* raise convert_error(err)
*
*/
}
/* "uvloop/loop.pyx":450
* raise convert_error(err)
*
* self.handler_async = None # <<<<<<<<<<<<<<
* self.handler_idle = None
* self.handler_check__exec_writes = None
*/
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__Pyx_GOTREF(__pyx_v_self->handler_async);
__Pyx_DECREF(((PyObject *)__pyx_v_self->handler_async));
__pyx_v_self->handler_async = ((struct __pyx_obj_6uvloop_4loop_UVAsync *)Py_None);
/* "uvloop/loop.pyx":451
*
* self.handler_async = None
* self.handler_idle = None # <<<<<<<<<<<<<<
* self.handler_check__exec_writes = None
*
*/
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__Pyx_GOTREF(__pyx_v_self->handler_idle);
__Pyx_DECREF(((PyObject *)__pyx_v_self->handler_idle));
__pyx_v_self->handler_idle = ((struct __pyx_obj_6uvloop_4loop_UVIdle *)Py_None);
/* "uvloop/loop.pyx":452
* self.handler_async = None
* self.handler_idle = None
* self.handler_check__exec_writes = None # <<<<<<<<<<<<<<
*
* executor = self._default_executor
*/
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__Pyx_GOTREF(__pyx_v_self->handler_check__exec_writes);
__Pyx_DECREF(((PyObject *)__pyx_v_self->handler_check__exec_writes));
__pyx_v_self->handler_check__exec_writes = ((struct __pyx_obj_6uvloop_4loop_UVCheck *)Py_None);
/* "uvloop/loop.pyx":454
* self.handler_check__exec_writes = None
*
* executor = self._default_executor # <<<<<<<<<<<<<<
* if executor is not None:
* self._default_executor = None
*/
__pyx_t_5 = __pyx_v_self->_default_executor;
__Pyx_INCREF(__pyx_t_5);
__pyx_v_executor = __pyx_t_5;
__pyx_t_5 = 0;
/* "uvloop/loop.pyx":455
*
* executor = self._default_executor
* if executor is not None: # <<<<<<<<<<<<<<
* self._default_executor = None
* executor.shutdown(wait=False)
*/
__pyx_t_1 = (__pyx_v_executor != Py_None);
__pyx_t_12 = (__pyx_t_1 != 0);
if (__pyx_t_12) {
/* "uvloop/loop.pyx":456
* executor = self._default_executor
* if executor is not None:
* self._default_executor = None # <<<<<<<<<<<<<<
* executor.shutdown(wait=False)
*
*/
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__Pyx_GOTREF(__pyx_v_self->_default_executor);
__Pyx_DECREF(__pyx_v_self->_default_executor);
__pyx_v_self->_default_executor = Py_None;
/* "uvloop/loop.pyx":457
* if executor is not None:
* self._default_executor = None
* executor.shutdown(wait=False) # <<<<<<<<<<<<<<
*
* cdef uint64_t _time(self):
*/
__pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_executor, __pyx_n_s_shutdown); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 457, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 457, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_wait, Py_False) < 0) __PYX_ERR(1, 457, __pyx_L1_error)
__pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_empty_tuple, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 457, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "uvloop/loop.pyx":455
*
* executor = self._default_executor
* if executor is not None: # <<<<<<<<<<<<<<
* self._default_executor = None
* executor.shutdown(wait=False)
*/
}
/* "uvloop/loop.pyx":395
* raise self._last_error
*
* cdef _close(self): # <<<<<<<<<<<<<<
* cdef int err
*
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_AddTraceback("uvloop.loop.Loop._close", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_cb_handle);
__Pyx_XDECREF(__pyx_v_poll_handle);
__Pyx_XDECREF(__pyx_v_timer_cbhandle);
__Pyx_XDECREF(__pyx_v_executor);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":459
* executor.shutdown(wait=False)
*
* cdef uint64_t _time(self): # <<<<<<<<<<<<<<
* # asyncio doesn't have a time cache, neither should uvloop.
* uv.uv_update_time(self.uvloop) # void
*/
static uint64_t __pyx_f_6uvloop_4loop_4Loop__time(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
uint64_t __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("_time", 0);
/* "uvloop/loop.pyx":461
* cdef uint64_t _time(self):
* # asyncio doesn't have a time cache, neither should uvloop.
* uv.uv_update_time(self.uvloop) # void # <<<<<<<<<<<<<<
* return uv.uv_now(self.uvloop)
*
*/
uv_update_time(__pyx_v_self->uvloop);
/* "uvloop/loop.pyx":462
* # asyncio doesn't have a time cache, neither should uvloop.
* uv.uv_update_time(self.uvloop) # void
* return uv.uv_now(self.uvloop) # <<<<<<<<<<<<<<
*
* cdef inline _queue_write(self, UVStream stream):
*/
__pyx_r = uv_now(__pyx_v_self->uvloop);
goto __pyx_L0;
/* "uvloop/loop.pyx":459
* executor.shutdown(wait=False)
*
* cdef uint64_t _time(self): # <<<<<<<<<<<<<<
* # asyncio doesn't have a time cache, neither should uvloop.
* uv.uv_update_time(self.uvloop) # void
*/
/* function exit code */
__pyx_L0:;
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":464
* return uv.uv_now(self.uvloop)
*
* cdef inline _queue_write(self, UVStream stream): # <<<<<<<<<<<<<<
* self._queued_streams.add(stream)
* if not self.handler_check__exec_writes.running:
*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__queue_write(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_stream) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
__Pyx_RefNannySetupContext("_queue_write", 0);
/* "uvloop/loop.pyx":465
*
* cdef inline _queue_write(self, UVStream stream):
* self._queued_streams.add(stream) # <<<<<<<<<<<<<<
* if not self.handler_check__exec_writes.running:
* self.handler_check__exec_writes.start()
*/
if (unlikely(__pyx_v_self->_queued_streams == Py_None)) {
PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "add");
__PYX_ERR(1, 465, __pyx_L1_error)
}
__pyx_t_1 = PySet_Add(__pyx_v_self->_queued_streams, ((PyObject *)__pyx_v_stream)); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(1, 465, __pyx_L1_error)
/* "uvloop/loop.pyx":466
* cdef inline _queue_write(self, UVStream stream):
* self._queued_streams.add(stream)
* if not self.handler_check__exec_writes.running: # <<<<<<<<<<<<<<
* self.handler_check__exec_writes.start()
*
*/
__pyx_t_2 = ((!(__pyx_v_self->handler_check__exec_writes->running != 0)) != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":467
* self._queued_streams.add(stream)
* if not self.handler_check__exec_writes.running:
* self.handler_check__exec_writes.start() # <<<<<<<<<<<<<<
*
* cdef _exec_queued_writes(self):
*/
__pyx_t_3 = __pyx_f_6uvloop_4loop_7UVCheck_start(__pyx_v_self->handler_check__exec_writes); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 467, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":466
* cdef inline _queue_write(self, UVStream stream):
* self._queued_streams.add(stream)
* if not self.handler_check__exec_writes.running: # <<<<<<<<<<<<<<
* self.handler_check__exec_writes.start()
*
*/
}
/* "uvloop/loop.pyx":464
* return uv.uv_now(self.uvloop)
*
* cdef inline _queue_write(self, UVStream stream): # <<<<<<<<<<<<<<
* self._queued_streams.add(stream)
* if not self.handler_check__exec_writes.running:
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_AddTraceback("uvloop.loop.Loop._queue_write", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":469
* self.handler_check__exec_writes.start()
*
* cdef _exec_queued_writes(self): # <<<<<<<<<<<<<<
* if len(self._queued_streams) == 0:
* if self.handler_check__exec_writes.running:
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__exec_queued_writes(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
struct __pyx_obj_6uvloop_4loop_UVStream *__pyx_v_stream = 0;
int __pyx_v_queued_len;
PyObject *__pyx_v_pystream = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
Py_ssize_t __pyx_t_2;
int __pyx_t_3;
PyObject *(*__pyx_t_4)(PyObject *);
PyObject *__pyx_t_5 = NULL;
int __pyx_t_6;
__Pyx_RefNannySetupContext("_exec_queued_writes", 0);
/* "uvloop/loop.pyx":470
*
* cdef _exec_queued_writes(self):
* if len(self._queued_streams) == 0: # <<<<<<<<<<<<<<
* if self.handler_check__exec_writes.running:
* self.handler_check__exec_writes.stop()
*/
__pyx_t_1 = __pyx_v_self->_queued_streams;
__Pyx_INCREF(__pyx_t_1);
if (unlikely(__pyx_t_1 == Py_None)) {
PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
__PYX_ERR(1, 470, __pyx_L1_error)
}
__pyx_t_2 = PySet_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(1, 470, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_3 = ((__pyx_t_2 == 0) != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":471
* cdef _exec_queued_writes(self):
* if len(self._queued_streams) == 0:
* if self.handler_check__exec_writes.running: # <<<<<<<<<<<<<<
* self.handler_check__exec_writes.stop()
* return
*/
__pyx_t_3 = (__pyx_v_self->handler_check__exec_writes->running != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":472
* if len(self._queued_streams) == 0:
* if self.handler_check__exec_writes.running:
* self.handler_check__exec_writes.stop() # <<<<<<<<<<<<<<
* return
*
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_7UVCheck_stop(__pyx_v_self->handler_check__exec_writes); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 472, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":471
* cdef _exec_queued_writes(self):
* if len(self._queued_streams) == 0:
* if self.handler_check__exec_writes.running: # <<<<<<<<<<<<<<
* self.handler_check__exec_writes.stop()
* return
*/
}
/* "uvloop/loop.pyx":473
* if self.handler_check__exec_writes.running:
* self.handler_check__exec_writes.stop()
* return # <<<<<<<<<<<<<<
*
* cdef:
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
/* "uvloop/loop.pyx":470
*
* cdef _exec_queued_writes(self):
* if len(self._queued_streams) == 0: # <<<<<<<<<<<<<<
* if self.handler_check__exec_writes.running:
* self.handler_check__exec_writes.stop()
*/
}
/* "uvloop/loop.pyx":479
* int queued_len
*
* if UVLOOP_DEBUG: # <<<<<<<<<<<<<<
* queued_len = len(self._queued_streams)
*
*/
__pyx_t_3 = (UVLOOP_DEBUG != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":480
*
* if UVLOOP_DEBUG:
* queued_len = len(self._queued_streams) # <<<<<<<<<<<<<<
*
* for pystream in self._queued_streams:
*/
__pyx_t_1 = __pyx_v_self->_queued_streams;
__Pyx_INCREF(__pyx_t_1);
if (unlikely(__pyx_t_1 == Py_None)) {
PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
__PYX_ERR(1, 480, __pyx_L1_error)
}
__pyx_t_2 = PySet_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(1, 480, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_queued_len = __pyx_t_2;
/* "uvloop/loop.pyx":479
* int queued_len
*
* if UVLOOP_DEBUG: # <<<<<<<<<<<<<<
* queued_len = len(self._queued_streams)
*
*/
}
/* "uvloop/loop.pyx":482
* queued_len = len(self._queued_streams)
*
* for pystream in self._queued_streams: # <<<<<<<<<<<<<<
* stream = pystream
* stream._exec_write()
*/
__pyx_t_1 = PyObject_GetIter(__pyx_v_self->_queued_streams); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 482, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_4 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 482, __pyx_L1_error)
for (;;) {
{
__pyx_t_5 = __pyx_t_4(__pyx_t_1);
if (unlikely(!__pyx_t_5)) {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(1, 482, __pyx_L1_error)
}
break;
}
__Pyx_GOTREF(__pyx_t_5);
}
__Pyx_XDECREF_SET(__pyx_v_pystream, __pyx_t_5);
__pyx_t_5 = 0;
/* "uvloop/loop.pyx":483
*
* for pystream in self._queued_streams:
* stream = pystream # <<<<<<<<<<<<<<
* stream._exec_write()
*
*/
__pyx_t_5 = __pyx_v_pystream;
__Pyx_INCREF(__pyx_t_5);
__Pyx_XDECREF_SET(__pyx_v_stream, ((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_t_5));
__pyx_t_5 = 0;
/* "uvloop/loop.pyx":484
* for pystream in self._queued_streams:
* stream = pystream
* stream._exec_write() # <<<<<<<<<<<<<<
*
* if UVLOOP_DEBUG:
*/
__pyx_t_5 = __pyx_f_6uvloop_4loop_8UVStream__exec_write(__pyx_v_stream); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 484, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":482
* queued_len = len(self._queued_streams)
*
* for pystream in self._queued_streams: # <<<<<<<<<<<<<<
* stream = pystream
* stream._exec_write()
*/
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":486
* stream._exec_write()
*
* if UVLOOP_DEBUG: # <<<<<<<<<<<<<<
* if len(self._queued_streams) != queued_len:
* raise RuntimeError(
*/
__pyx_t_3 = (UVLOOP_DEBUG != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":487
*
* if UVLOOP_DEBUG:
* if len(self._queued_streams) != queued_len: # <<<<<<<<<<<<<<
* raise RuntimeError(
* 'loop._queued_streams are not empty after '
*/
__pyx_t_1 = __pyx_v_self->_queued_streams;
__Pyx_INCREF(__pyx_t_1);
if (unlikely(__pyx_t_1 == Py_None)) {
PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
__PYX_ERR(1, 487, __pyx_L1_error)
}
__pyx_t_2 = PySet_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(1, 487, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_3 = ((__pyx_t_2 != __pyx_v_queued_len) != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":488
* if UVLOOP_DEBUG:
* if len(self._queued_streams) != queued_len:
* raise RuntimeError( # <<<<<<<<<<<<<<
* 'loop._queued_streams are not empty after '
* '_exec_queued_writes')
*/
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 488, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__PYX_ERR(1, 488, __pyx_L1_error)
/* "uvloop/loop.pyx":487
*
* if UVLOOP_DEBUG:
* if len(self._queued_streams) != queued_len: # <<<<<<<<<<<<<<
* raise RuntimeError(
* 'loop._queued_streams are not empty after '
*/
}
/* "uvloop/loop.pyx":486
* stream._exec_write()
*
* if UVLOOP_DEBUG: # <<<<<<<<<<<<<<
* if len(self._queued_streams) != queued_len:
* raise RuntimeError(
*/
}
/* "uvloop/loop.pyx":492
* '_exec_queued_writes')
*
* self._queued_streams.clear() # <<<<<<<<<<<<<<
*
* if self.handler_check__exec_writes.running:
*/
if (unlikely(__pyx_v_self->_queued_streams == Py_None)) {
PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "clear");
__PYX_ERR(1, 492, __pyx_L1_error)
}
__pyx_t_6 = PySet_Clear(__pyx_v_self->_queued_streams); if (unlikely(__pyx_t_6 == -1)) __PYX_ERR(1, 492, __pyx_L1_error)
/* "uvloop/loop.pyx":494
* self._queued_streams.clear()
*
* if self.handler_check__exec_writes.running: # <<<<<<<<<<<<<<
* self.handler_check__exec_writes.stop()
*
*/
__pyx_t_3 = (__pyx_v_self->handler_check__exec_writes->running != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":495
*
* if self.handler_check__exec_writes.running:
* self.handler_check__exec_writes.stop() # <<<<<<<<<<<<<<
*
* cdef inline _call_soon(self, object callback, object args):
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_7UVCheck_stop(__pyx_v_self->handler_check__exec_writes); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":494
* self._queued_streams.clear()
*
* if self.handler_check__exec_writes.running: # <<<<<<<<<<<<<<
* self.handler_check__exec_writes.stop()
*
*/
}
/* "uvloop/loop.pyx":469
* self.handler_check__exec_writes.start()
*
* cdef _exec_queued_writes(self): # <<<<<<<<<<<<<<
* if len(self._queued_streams) == 0:
* if self.handler_check__exec_writes.running:
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("uvloop.loop.Loop._exec_queued_writes", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_stream);
__Pyx_XDECREF(__pyx_v_pystream);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":497
* self.handler_check__exec_writes.stop()
*
* cdef inline _call_soon(self, object callback, object args): # <<<<<<<<<<<<<<
* cdef Handle handle
* handle = new_Handle(self, callback, args)
*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__call_soon(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) {
struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle = 0;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("_call_soon", 0);
/* "uvloop/loop.pyx":499
* cdef inline _call_soon(self, object callback, object args):
* cdef Handle handle
* handle = new_Handle(self, callback, args) # <<<<<<<<<<<<<<
* self._call_soon_handle(handle)
* return handle
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_new_Handle(__pyx_v_self, __pyx_v_callback, __pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 499, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(1, 499, __pyx_L1_error)
__pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_1);
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":500
* cdef Handle handle
* handle = new_Handle(self, callback, args)
* self._call_soon_handle(handle) # <<<<<<<<<<<<<<
* return handle
*
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__call_soon_handle(__pyx_v_self, __pyx_v_handle); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 500, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":501
* handle = new_Handle(self, callback, args)
* self._call_soon_handle(handle)
* return handle # <<<<<<<<<<<<<<
*
* cdef inline _call_soon_handle(self, Handle handle):
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(((PyObject *)__pyx_v_handle));
__pyx_r = ((PyObject *)__pyx_v_handle);
goto __pyx_L0;
/* "uvloop/loop.pyx":497
* self.handler_check__exec_writes.stop()
*
* cdef inline _call_soon(self, object callback, object args): # <<<<<<<<<<<<<<
* cdef Handle handle
* handle = new_Handle(self, callback, args)
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._call_soon", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_handle);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":503
* return handle
*
* cdef inline _call_soon_handle(self, Handle handle): # <<<<<<<<<<<<<<
* self._check_closed()
* self._ready.append(handle)
*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__call_soon_handle(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_t_2;
int __pyx_t_3;
__Pyx_RefNannySetupContext("_call_soon_handle", 0);
/* "uvloop/loop.pyx":504
*
* cdef inline _call_soon_handle(self, Handle handle):
* self._check_closed() # <<<<<<<<<<<<<<
* self._ready.append(handle)
* self._ready_len += 1;
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__check_closed(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 504, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":505
* cdef inline _call_soon_handle(self, Handle handle):
* self._check_closed()
* self._ready.append(handle) # <<<<<<<<<<<<<<
* self._ready_len += 1;
* if not self.handler_idle.running:
*/
__pyx_t_2 = __Pyx_PyObject_Append(__pyx_v_self->_ready, ((PyObject *)__pyx_v_handle)); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(1, 505, __pyx_L1_error)
/* "uvloop/loop.pyx":506
* self._check_closed()
* self._ready.append(handle)
* self._ready_len += 1; # <<<<<<<<<<<<<<
* if not self.handler_idle.running:
* self.handler_idle.start()
*/
__pyx_v_self->_ready_len = (__pyx_v_self->_ready_len + 1);
/* "uvloop/loop.pyx":507
* self._ready.append(handle)
* self._ready_len += 1;
* if not self.handler_idle.running: # <<<<<<<<<<<<<<
* self.handler_idle.start()
*
*/
__pyx_t_3 = ((!(__pyx_v_self->handler_idle->running != 0)) != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":508
* self._ready_len += 1;
* if not self.handler_idle.running:
* self.handler_idle.start() # <<<<<<<<<<<<<<
*
* cdef _call_later(self, uint64_t delay, object callback, object args):
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_6UVIdle_start(__pyx_v_self->handler_idle); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 508, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":507
* self._ready.append(handle)
* self._ready_len += 1;
* if not self.handler_idle.running: # <<<<<<<<<<<<<<
* self.handler_idle.start()
*
*/
}
/* "uvloop/loop.pyx":503
* return handle
*
* cdef inline _call_soon_handle(self, Handle handle): # <<<<<<<<<<<<<<
* self._check_closed()
* self._ready.append(handle)
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._call_soon_handle", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":510
* self.handler_idle.start()
*
* cdef _call_later(self, uint64_t delay, object callback, object args): # <<<<<<<<<<<<<<
* return TimerHandle(self, callback, args, delay)
*
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__call_later(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, uint64_t __pyx_v_delay, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
__Pyx_RefNannySetupContext("_call_later", 0);
/* "uvloop/loop.pyx":511
*
* cdef _call_later(self, uint64_t delay, object callback, object args):
* return TimerHandle(self, callback, args, delay) # <<<<<<<<<<<<<<
*
* cdef void _handle_exception(self, object ex):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_delay); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 511, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 511, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_v_self));
PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)__pyx_v_self));
__Pyx_INCREF(__pyx_v_callback);
__Pyx_GIVEREF(__pyx_v_callback);
PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_callback);
__Pyx_INCREF(__pyx_v_args);
__Pyx_GIVEREF(__pyx_v_args);
PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_args);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_1);
__pyx_t_1 = 0;
__pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6uvloop_4loop_TimerHandle), __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 511, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* "uvloop/loop.pyx":510
* self.handler_idle.start()
*
* cdef _call_later(self, uint64_t delay, object callback, object args): # <<<<<<<<<<<<<<
* return TimerHandle(self, callback, args, delay)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_AddTraceback("uvloop.loop.Loop._call_later", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":513
* return TimerHandle(self, callback, args, delay)
*
* cdef void _handle_exception(self, object ex): # <<<<<<<<<<<<<<
* if isinstance(ex, Exception):
* self.call_exception_handler({'exception': ex})
*/
static void __pyx_f_6uvloop_4loop_4Loop__handle_exception(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_ex) {
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
__Pyx_RefNannySetupContext("_handle_exception", 0);
/* "uvloop/loop.pyx":514
*
* cdef void _handle_exception(self, object ex):
* if isinstance(ex, Exception): # <<<<<<<<<<<<<<
* self.call_exception_handler({'exception': ex})
* else:
*/
__pyx_t_1 = __Pyx_PyException_Check(__pyx_v_ex);
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":515
* cdef void _handle_exception(self, object ex):
* if isinstance(ex, Exception):
* self.call_exception_handler({'exception': ex}) # <<<<<<<<<<<<<<
* else:
* # BaseException
*/
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_call_exception_handler); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 515, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 515, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
if (PyDict_SetItem(__pyx_t_5, __pyx_n_u_exception, __pyx_v_ex) < 0) __PYX_ERR(1, 515, __pyx_L1_error)
__pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (!__pyx_t_6) {
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 515, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5};
__pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 515, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5};
__pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 515, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else
#endif
{
__pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 515, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 515, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":514
*
* cdef void _handle_exception(self, object ex):
* if isinstance(ex, Exception): # <<<<<<<<<<<<<<
* self.call_exception_handler({'exception': ex})
* else:
*/
goto __pyx_L3;
}
/* "uvloop/loop.pyx":518
* else:
* # BaseException
* self._last_error = ex # <<<<<<<<<<<<<<
* # Exit ASAP
* self._stop(None)
*/
/*else*/ {
__Pyx_INCREF(__pyx_v_ex);
__Pyx_GIVEREF(__pyx_v_ex);
__Pyx_GOTREF(__pyx_v_self->_last_error);
__Pyx_DECREF(__pyx_v_self->_last_error);
__pyx_v_self->_last_error = __pyx_v_ex;
/* "uvloop/loop.pyx":520
* self._last_error = ex
* # Exit ASAP
* self._stop(None) # <<<<<<<<<<<<<<
*
* cdef inline _check_signal(self, sig):
*/
__pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_stop(__pyx_v_self, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 520, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
__pyx_L3:;
/* "uvloop/loop.pyx":513
* return TimerHandle(self, callback, args, delay)
*
* cdef void _handle_exception(self, object ex): # <<<<<<<<<<<<<<
* if isinstance(ex, Exception):
* self.call_exception_handler({'exception': ex})
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_WriteUnraisable("uvloop.loop.Loop._handle_exception", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
__pyx_L0:;
__Pyx_RefNannyFinishContext();
}
/* "uvloop/loop.pyx":522
* self._stop(None)
*
* cdef inline _check_signal(self, sig): # <<<<<<<<<<<<<<
* if not isinstance(sig, int):
* raise TypeError('sig must be an int, not {!r}'.format(sig))
*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__check_signal(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sig) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
int __pyx_t_7;
PyObject *__pyx_t_8 = NULL;
__Pyx_RefNannySetupContext("_check_signal", 0);
/* "uvloop/loop.pyx":523
*
* cdef inline _check_signal(self, sig):
* if not isinstance(sig, int): # <<<<<<<<<<<<<<
* raise TypeError('sig must be an int, not {!r}'.format(sig))
*
*/
__pyx_t_1 = PyInt_Check(__pyx_v_sig);
__pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":524
* cdef inline _check_signal(self, sig):
* if not isinstance(sig, int):
* raise TypeError('sig must be an int, not {!r}'.format(sig)) # <<<<<<<<<<<<<<
*
* if not (1 <= sig < signal_NSIG):
*/
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_sig_must_be_an_int_not_r, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 524, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (!__pyx_t_5) {
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_sig); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 524, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_v_sig};
__pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 524, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_v_sig};
__pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 524, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else
#endif
{
__pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 524, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_INCREF(__pyx_v_sig);
__Pyx_GIVEREF(__pyx_v_sig);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_sig);
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 524, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 524, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
__pyx_t_3 = 0;
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 524, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 524, __pyx_L1_error)
/* "uvloop/loop.pyx":523
*
* cdef inline _check_signal(self, sig):
* if not isinstance(sig, int): # <<<<<<<<<<<<<<
* raise TypeError('sig must be an int, not {!r}'.format(sig))
*
*/
}
/* "uvloop/loop.pyx":526
* raise TypeError('sig must be an int, not {!r}'.format(sig))
*
* if not (1 <= sig < signal_NSIG): # <<<<<<<<<<<<<<
* raise ValueError(
* 'sig {} out of range(1, {})'.format(sig, signal_NSIG))
*/
__pyx_t_3 = PyObject_RichCompare(__pyx_int_1, __pyx_v_sig, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 526, __pyx_L1_error)
if (__Pyx_PyObject_IsTrue(__pyx_t_3)) {
__Pyx_DECREF(__pyx_t_3);
__pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_6uvloop_4loop_signal_NSIG); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 526, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = PyObject_RichCompare(__pyx_v_sig, __pyx_t_4, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 526, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 526, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_1 = ((!__pyx_t_2) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":528
* if not (1 <= sig < signal_NSIG):
* raise ValueError(
* 'sig {} out of range(1, {})'.format(sig, signal_NSIG)) # <<<<<<<<<<<<<<
*
* cdef inline _check_closed(self):
*/
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_sig_out_of_range_1, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 528, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_6uvloop_4loop_signal_NSIG); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 528, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_5 = NULL;
__pyx_t_7 = 0;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
__pyx_t_7 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_sig, __pyx_t_6};
__pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 528, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_v_sig, __pyx_t_6};
__pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 528, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else
#endif
{
__pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 528, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
if (__pyx_t_5) {
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL;
}
__Pyx_INCREF(__pyx_v_sig);
__Pyx_GIVEREF(__pyx_v_sig);
PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_v_sig);
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_6);
__pyx_t_6 = 0;
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 528, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":527
*
* if not (1 <= sig < signal_NSIG):
* raise ValueError( # <<<<<<<<<<<<<<
* 'sig {} out of range(1, {})'.format(sig, signal_NSIG))
*
*/
__pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 527, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3);
__pyx_t_3 = 0;
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 527, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 527, __pyx_L1_error)
/* "uvloop/loop.pyx":526
* raise TypeError('sig must be an int, not {!r}'.format(sig))
*
* if not (1 <= sig < signal_NSIG): # <<<<<<<<<<<<<<
* raise ValueError(
* 'sig {} out of range(1, {})'.format(sig, signal_NSIG))
*/
}
/* "uvloop/loop.pyx":522
* self._stop(None)
*
* cdef inline _check_signal(self, sig): # <<<<<<<<<<<<<<
* if not isinstance(sig, int):
* raise TypeError('sig must be an int, not {!r}'.format(sig))
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_AddTraceback("uvloop.loop.Loop._check_signal", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":530
* 'sig {} out of range(1, {})'.format(sig, signal_NSIG))
*
* cdef inline _check_closed(self): # <<<<<<<<<<<<<<
* if self._closed == 1:
* raise RuntimeError('Event loop is closed')
*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__check_closed(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
__Pyx_RefNannySetupContext("_check_closed", 0);
/* "uvloop/loop.pyx":531
*
* cdef inline _check_closed(self):
* if self._closed == 1: # <<<<<<<<<<<<<<
* raise RuntimeError('Event loop is closed')
*
*/
__pyx_t_1 = ((__pyx_v_self->_closed == 1) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":532
* cdef inline _check_closed(self):
* if self._closed == 1:
* raise RuntimeError('Event loop is closed') # <<<<<<<<<<<<<<
*
* cdef inline _check_thread(self):
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 532, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__PYX_ERR(1, 532, __pyx_L1_error)
/* "uvloop/loop.pyx":531
*
* cdef inline _check_closed(self):
* if self._closed == 1: # <<<<<<<<<<<<<<
* raise RuntimeError('Event loop is closed')
*
*/
}
/* "uvloop/loop.pyx":530
* 'sig {} out of range(1, {})'.format(sig, signal_NSIG))
*
* cdef inline _check_closed(self): # <<<<<<<<<<<<<<
* if self._closed == 1:
* raise RuntimeError('Event loop is closed')
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_AddTraceback("uvloop.loop.Loop._check_closed", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":534
* raise RuntimeError('Event loop is closed')
*
* cdef inline _check_thread(self): # <<<<<<<<<<<<<<
* if self._thread_id == 0:
* return
*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__check_thread(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
long __pyx_v_thread_id;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
__Pyx_RefNannySetupContext("_check_thread", 0);
/* "uvloop/loop.pyx":535
*
* cdef inline _check_thread(self):
* if self._thread_id == 0: # <<<<<<<<<<<<<<
* return
* cdef long thread_id = PyThread_get_thread_ident()
*/
__pyx_t_1 = ((__pyx_v_self->_thread_id == 0) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":536
* cdef inline _check_thread(self):
* if self._thread_id == 0:
* return # <<<<<<<<<<<<<<
* cdef long thread_id = PyThread_get_thread_ident()
* if thread_id != self._thread_id:
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
/* "uvloop/loop.pyx":535
*
* cdef inline _check_thread(self):
* if self._thread_id == 0: # <<<<<<<<<<<<<<
* return
* cdef long thread_id = PyThread_get_thread_ident()
*/
}
/* "uvloop/loop.pyx":537
* if self._thread_id == 0:
* return
* cdef long thread_id = PyThread_get_thread_ident() # <<<<<<<<<<<<<<
* if thread_id != self._thread_id:
* raise RuntimeError(
*/
__pyx_v_thread_id = PyThread_get_thread_ident();
/* "uvloop/loop.pyx":538
* return
* cdef long thread_id = PyThread_get_thread_ident()
* if thread_id != self._thread_id: # <<<<<<<<<<<<<<
* raise RuntimeError(
* "Non-thread-safe operation invoked on an event loop other "
*/
__pyx_t_1 = ((__pyx_v_thread_id != __pyx_v_self->_thread_id) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":539
* cdef long thread_id = PyThread_get_thread_ident()
* if thread_id != self._thread_id:
* raise RuntimeError( # <<<<<<<<<<<<<<
* "Non-thread-safe operation invoked on an event loop other "
* "than the current one")
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 539, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__PYX_ERR(1, 539, __pyx_L1_error)
/* "uvloop/loop.pyx":538
* return
* cdef long thread_id = PyThread_get_thread_ident()
* if thread_id != self._thread_id: # <<<<<<<<<<<<<<
* raise RuntimeError(
* "Non-thread-safe operation invoked on an event loop other "
*/
}
/* "uvloop/loop.pyx":534
* raise RuntimeError('Event loop is closed')
*
* cdef inline _check_thread(self): # <<<<<<<<<<<<<<
* if self._thread_id == 0:
* return
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_AddTraceback("uvloop.loop.Loop._check_thread", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":543
* "than the current one")
*
* cdef inline _new_future(self): # <<<<<<<<<<<<<<
* return future_factory(loop=self)
*
*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_4Loop__new_future(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
__Pyx_RefNannySetupContext("_new_future", 0);
/* "uvloop/loop.pyx":544
*
* cdef inline _new_future(self):
* return future_factory(loop=self) # <<<<<<<<<<<<<<
*
* cdef _track_transport(self, UVBaseTransport transport):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 544, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_loop, ((PyObject *)__pyx_v_self)) < 0) __PYX_ERR(1, 544, __pyx_L1_error)
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_v_6uvloop_4loop_future_factory, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 544, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
/* "uvloop/loop.pyx":543
* "than the current one")
*
* cdef inline _new_future(self): # <<<<<<<<<<<<<<
* return future_factory(loop=self)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_AddTraceback("uvloop.loop.Loop._new_future", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":546
* return future_factory(loop=self)
*
* cdef _track_transport(self, UVBaseTransport transport): # <<<<<<<<<<<<<<
* self._transports[transport._fileno()] = transport
*
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__track_transport(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_transport) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("_track_transport", 0);
/* "uvloop/loop.pyx":547
*
* cdef _track_transport(self, UVBaseTransport transport):
* self._transports[transport._fileno()] = transport # <<<<<<<<<<<<<<
*
* cdef _ensure_fd_no_transport(self, fd):
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_transport->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._fileno(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_v_transport)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 547, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (unlikely(PyObject_SetItem(__pyx_v_self->_transports, __pyx_t_1, ((PyObject *)__pyx_v_transport)) < 0)) __PYX_ERR(1, 547, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":546
* return future_factory(loop=self)
*
* cdef _track_transport(self, UVBaseTransport transport): # <<<<<<<<<<<<<<
* self._transports[transport._fileno()] = transport
*
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._track_transport", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":549
* self._transports[transport._fileno()] = transport
*
* cdef _ensure_fd_no_transport(self, fd): # <<<<<<<<<<<<<<
* cdef UVBaseTransport tr
* try:
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__ensure_fd_no_transport(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fd) {
struct __pyx_obj_6uvloop_4loop_UVBaseTransport *__pyx_v_tr = 0;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_t_6;
PyObject *__pyx_t_7 = NULL;
int __pyx_t_8;
PyObject *__pyx_t_9 = NULL;
__Pyx_RefNannySetupContext("_ensure_fd_no_transport", 0);
/* "uvloop/loop.pyx":551
* cdef _ensure_fd_no_transport(self, fd):
* cdef UVBaseTransport tr
* try: # <<<<<<<<<<<<<<
* tr = (self._transports[fd])
* except KeyError:
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3);
__Pyx_XGOTREF(__pyx_t_1);
__Pyx_XGOTREF(__pyx_t_2);
__Pyx_XGOTREF(__pyx_t_3);
/*try:*/ {
/* "uvloop/loop.pyx":552
* cdef UVBaseTransport tr
* try:
* tr = (self._transports[fd]) # <<<<<<<<<<<<<<
* except KeyError:
* pass
*/
__pyx_t_4 = PyObject_GetItem(__pyx_v_self->_transports, __pyx_v_fd); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 552, __pyx_L3_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = __pyx_t_4;
__Pyx_INCREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_v_tr = ((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_t_5);
__pyx_t_5 = 0;
/* "uvloop/loop.pyx":551
* cdef _ensure_fd_no_transport(self, fd):
* cdef UVBaseTransport tr
* try: # <<<<<<<<<<<<<<
* tr = (self._transports[fd])
* except KeyError:
*/
}
/* "uvloop/loop.pyx":556
* pass
* else:
* if tr._is_alive(): # <<<<<<<<<<<<<<
* raise RuntimeError(
* 'File descriptor {!r} is used by transport {!r}'.format(
*/
/*else:*/ {
__pyx_t_6 = (((struct __pyx_vtabstruct_6uvloop_4loop_UVBaseTransport *)__pyx_v_tr->__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._is_alive(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_tr)) != 0);
if (__pyx_t_6) {
/* "uvloop/loop.pyx":558
* if tr._is_alive():
* raise RuntimeError(
* 'File descriptor {!r} is used by transport {!r}'.format( # <<<<<<<<<<<<<<
* fd, tr))
*
*/
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_File_descriptor_r_is_used_by_tra, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 558, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_4);
/* "uvloop/loop.pyx":559
* raise RuntimeError(
* 'File descriptor {!r} is used by transport {!r}'.format(
* fd, tr)) # <<<<<<<<<<<<<<
*
* cdef inline _add_reader(self, fd, Handle handle):
*/
__pyx_t_7 = NULL;
__pyx_t_8 = 0;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_7)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_7);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
__pyx_t_8 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_fd, ((PyObject *)__pyx_v_tr)};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 558, __pyx_L5_except_error)
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_v_fd, ((PyObject *)__pyx_v_tr)};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 558, __pyx_L5_except_error)
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else
#endif
{
__pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 558, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_9);
if (__pyx_t_7) {
__Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL;
}
__Pyx_INCREF(__pyx_v_fd);
__Pyx_GIVEREF(__pyx_v_fd);
PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_v_fd);
__Pyx_INCREF(((PyObject *)__pyx_v_tr));
__Pyx_GIVEREF(((PyObject *)__pyx_v_tr));
PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, ((PyObject *)__pyx_v_tr));
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 558, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":557
* else:
* if tr._is_alive():
* raise RuntimeError( # <<<<<<<<<<<<<<
* 'File descriptor {!r} is used by transport {!r}'.format(
* fd, tr))
*/
__pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 557, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 557, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_5, 0, 0, 0);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__PYX_ERR(1, 557, __pyx_L5_except_error)
/* "uvloop/loop.pyx":556
* pass
* else:
* if tr._is_alive(): # <<<<<<<<<<<<<<
* raise RuntimeError(
* 'File descriptor {!r} is used by transport {!r}'.format(
*/
}
}
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
goto __pyx_L10_try_end;
__pyx_L3_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":553
* try:
* tr = (self._transports[fd])
* except KeyError: # <<<<<<<<<<<<<<
* pass
* else:
*/
__pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
if (__pyx_t_8) {
__Pyx_ErrRestore(0,0,0);
goto __pyx_L4_exception_handled;
}
goto __pyx_L5_except_error;
__pyx_L5_except_error:;
/* "uvloop/loop.pyx":551
* cdef _ensure_fd_no_transport(self, fd):
* cdef UVBaseTransport tr
* try: # <<<<<<<<<<<<<<
* tr = (self._transports[fd])
* except KeyError:
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_1);
__Pyx_XGIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
goto __pyx_L1_error;
__pyx_L4_exception_handled:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_1);
__Pyx_XGIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3);
__pyx_L10_try_end:;
}
/* "uvloop/loop.pyx":549
* self._transports[transport._fileno()] = transport
*
* cdef _ensure_fd_no_transport(self, fd): # <<<<<<<<<<<<<<
* cdef UVBaseTransport tr
* try:
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_9);
__Pyx_AddTraceback("uvloop.loop.Loop._ensure_fd_no_transport", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_tr);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":561
* fd, tr))
*
* cdef inline _add_reader(self, fd, Handle handle): # <<<<<<<<<<<<<<
* cdef:
* UVPoll poll
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__add_reader(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fd, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle) {
struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_poll = 0;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_t_6;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
__Pyx_RefNannySetupContext("_add_reader", 0);
/* "uvloop/loop.pyx":565
* UVPoll poll
*
* self._check_closed() # <<<<<<<<<<<<<<
*
* try:
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__check_closed(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 565, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":567
* self._check_closed()
*
* try: # <<<<<<<<<<<<<<
* poll = (self._polls[fd])
* except KeyError:
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
__Pyx_XGOTREF(__pyx_t_2);
__Pyx_XGOTREF(__pyx_t_3);
__Pyx_XGOTREF(__pyx_t_4);
/*try:*/ {
/* "uvloop/loop.pyx":568
*
* try:
* poll = (self._polls[fd]) # <<<<<<<<<<<<<<
* except KeyError:
* poll = UVPoll.new(self, fd)
*/
if (unlikely(__pyx_v_self->_polls == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
__PYX_ERR(1, 568, __pyx_L3_error)
}
__pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_self->_polls, __pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 568, __pyx_L3_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_5 = __pyx_t_1;
__Pyx_INCREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_poll = ((struct __pyx_obj_6uvloop_4loop_UVPoll *)__pyx_t_5);
__pyx_t_5 = 0;
/* "uvloop/loop.pyx":567
* self._check_closed()
*
* try: # <<<<<<<<<<<<<<
* poll = (self._polls[fd])
* except KeyError:
*/
}
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
goto __pyx_L10_try_end;
__pyx_L3_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":569
* try:
* poll = (self._polls[fd])
* except KeyError: # <<<<<<<<<<<<<<
* poll = UVPoll.new(self, fd)
* self._polls[fd] = poll
*/
__pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
if (__pyx_t_6) {
__Pyx_AddTraceback("uvloop.loop.Loop._add_reader", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_1, &__pyx_t_7) < 0) __PYX_ERR(1, 569, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_7);
/* "uvloop/loop.pyx":570
* poll = (self._polls[fd])
* except KeyError:
* poll = UVPoll.new(self, fd) # <<<<<<<<<<<<<<
* self._polls[fd] = poll
*
*/
__pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_fd); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 570, __pyx_L5_except_error)
__pyx_t_8 = ((PyObject *)__pyx_f_6uvloop_4loop_6UVPoll_new(__pyx_v_self, __pyx_t_6)); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 570, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_XDECREF_SET(__pyx_v_poll, ((struct __pyx_obj_6uvloop_4loop_UVPoll *)__pyx_t_8));
__pyx_t_8 = 0;
/* "uvloop/loop.pyx":571
* except KeyError:
* poll = UVPoll.new(self, fd)
* self._polls[fd] = poll # <<<<<<<<<<<<<<
*
* poll.start_reading(handle)
*/
if (unlikely(__pyx_v_self->_polls == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
__PYX_ERR(1, 571, __pyx_L5_except_error)
}
if (unlikely(PyDict_SetItem(__pyx_v_self->_polls, __pyx_v_fd, ((PyObject *)__pyx_v_poll)) < 0)) __PYX_ERR(1, 571, __pyx_L5_except_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
goto __pyx_L4_exception_handled;
}
goto __pyx_L5_except_error;
__pyx_L5_except_error:;
/* "uvloop/loop.pyx":567
* self._check_closed()
*
* try: # <<<<<<<<<<<<<<
* poll = (self._polls[fd])
* except KeyError:
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
goto __pyx_L1_error;
__pyx_L4_exception_handled:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
__pyx_L10_try_end:;
}
/* "uvloop/loop.pyx":573
* self._polls[fd] = poll
*
* poll.start_reading(handle) # <<<<<<<<<<<<<<
*
* cdef inline _remove_reader(self, fd):
*/
__pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_poll->__pyx_base.__pyx_vtab)->start_reading(__pyx_v_poll, __pyx_v_handle); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 573, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "uvloop/loop.pyx":561
* fd, tr))
*
* cdef inline _add_reader(self, fd, Handle handle): # <<<<<<<<<<<<<<
* cdef:
* UVPoll poll
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_AddTraceback("uvloop.loop.Loop._add_reader", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_poll);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":575
* poll.start_reading(handle)
*
* cdef inline _remove_reader(self, fd): # <<<<<<<<<<<<<<
* cdef:
* UVPoll poll
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__remove_reader(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fd) {
struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_poll = 0;
PyObject *__pyx_v_result = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
int __pyx_t_7;
PyObject *__pyx_t_8 = NULL;
__Pyx_RefNannySetupContext("_remove_reader", 0);
/* "uvloop/loop.pyx":579
* UVPoll poll
*
* if self._closed == 1: # <<<<<<<<<<<<<<
* return False
*
*/
__pyx_t_1 = ((__pyx_v_self->_closed == 1) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":580
*
* if self._closed == 1:
* return False # <<<<<<<<<<<<<<
*
* try:
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(Py_False);
__pyx_r = Py_False;
goto __pyx_L0;
/* "uvloop/loop.pyx":579
* UVPoll poll
*
* if self._closed == 1: # <<<<<<<<<<<<<<
* return False
*
*/
}
/* "uvloop/loop.pyx":582
* return False
*
* try: # <<<<<<<<<<<<<<
* poll = (self._polls[fd])
* except KeyError:
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
__Pyx_XGOTREF(__pyx_t_2);
__Pyx_XGOTREF(__pyx_t_3);
__Pyx_XGOTREF(__pyx_t_4);
/*try:*/ {
/* "uvloop/loop.pyx":583
*
* try:
* poll = (self._polls[fd]) # <<<<<<<<<<<<<<
* except KeyError:
* return False
*/
if (unlikely(__pyx_v_self->_polls == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
__PYX_ERR(1, 583, __pyx_L4_error)
}
__pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_self->_polls, __pyx_v_fd); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 583, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = __pyx_t_5;
__Pyx_INCREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_v_poll = ((struct __pyx_obj_6uvloop_4loop_UVPoll *)__pyx_t_6);
__pyx_t_6 = 0;
/* "uvloop/loop.pyx":582
* return False
*
* try: # <<<<<<<<<<<<<<
* poll = (self._polls[fd])
* except KeyError:
*/
}
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
goto __pyx_L11_try_end;
__pyx_L4_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "uvloop/loop.pyx":584
* try:
* poll = (self._polls[fd])
* except KeyError: # <<<<<<<<<<<<<<
* return False
*
*/
__pyx_t_7 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
if (__pyx_t_7) {
__Pyx_AddTraceback("uvloop.loop.Loop._remove_reader", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_5, &__pyx_t_8) < 0) __PYX_ERR(1, 584, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_t_8);
/* "uvloop/loop.pyx":585
* poll = (self._polls[fd])
* except KeyError:
* return False # <<<<<<<<<<<<<<
*
* result = poll.stop_reading()
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(Py_False);
__pyx_r = Py_False;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
goto __pyx_L7_except_return;
}
goto __pyx_L6_except_error;
__pyx_L6_except_error:;
/* "uvloop/loop.pyx":582
* return False
*
* try: # <<<<<<<<<<<<<<
* poll = (self._polls[fd])
* except KeyError:
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
goto __pyx_L1_error;
__pyx_L7_except_return:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
goto __pyx_L0;
__pyx_L11_try_end:;
}
/* "uvloop/loop.pyx":587
* return False
*
* result = poll.stop_reading() # <<<<<<<<<<<<<<
* if not poll.is_active():
* del self._polls[fd]
*/
__pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_poll->__pyx_base.__pyx_vtab)->stop_reading(__pyx_v_poll); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 587, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__pyx_v_result = __pyx_t_8;
__pyx_t_8 = 0;
/* "uvloop/loop.pyx":588
*
* result = poll.stop_reading()
* if not poll.is_active(): # <<<<<<<<<<<<<<
* del self._polls[fd]
* poll._close()
*/
__pyx_t_1 = ((!(((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_poll->__pyx_base.__pyx_vtab)->is_active(__pyx_v_poll) != 0)) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":589
* result = poll.stop_reading()
* if not poll.is_active():
* del self._polls[fd] # <<<<<<<<<<<<<<
* poll._close()
* return result
*/
if (unlikely(__pyx_v_self->_polls == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
__PYX_ERR(1, 589, __pyx_L1_error)
}
if (unlikely(PyDict_DelItem(__pyx_v_self->_polls, __pyx_v_fd) < 0)) __PYX_ERR(1, 589, __pyx_L1_error)
/* "uvloop/loop.pyx":590
* if not poll.is_active():
* del self._polls[fd]
* poll._close() # <<<<<<<<<<<<<<
* return result
*
*/
__pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_poll->__pyx_base.__pyx_vtab)->__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_poll)); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 590, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
/* "uvloop/loop.pyx":588
*
* result = poll.stop_reading()
* if not poll.is_active(): # <<<<<<<<<<<<<<
* del self._polls[fd]
* poll._close()
*/
}
/* "uvloop/loop.pyx":591
* del self._polls[fd]
* poll._close()
* return result # <<<<<<<<<<<<<<
*
* cdef inline _add_writer(self, fd, Handle handle):
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v_result);
__pyx_r = __pyx_v_result;
goto __pyx_L0;
/* "uvloop/loop.pyx":575
* poll.start_reading(handle)
*
* cdef inline _remove_reader(self, fd): # <<<<<<<<<<<<<<
* cdef:
* UVPoll poll
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_AddTraceback("uvloop.loop.Loop._remove_reader", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_poll);
__Pyx_XDECREF(__pyx_v_result);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":593
* return result
*
* cdef inline _add_writer(self, fd, Handle handle): # <<<<<<<<<<<<<<
* cdef:
* UVPoll poll
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__add_writer(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fd, struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle) {
struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_poll = 0;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_t_6;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
__Pyx_RefNannySetupContext("_add_writer", 0);
/* "uvloop/loop.pyx":597
* UVPoll poll
*
* self._check_closed() # <<<<<<<<<<<<<<
*
* try:
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__check_closed(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 597, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":599
* self._check_closed()
*
* try: # <<<<<<<<<<<<<<
* poll = (self._polls[fd])
* except KeyError:
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
__Pyx_XGOTREF(__pyx_t_2);
__Pyx_XGOTREF(__pyx_t_3);
__Pyx_XGOTREF(__pyx_t_4);
/*try:*/ {
/* "uvloop/loop.pyx":600
*
* try:
* poll = (self._polls[fd]) # <<<<<<<<<<<<<<
* except KeyError:
* poll = UVPoll.new(self, fd)
*/
if (unlikely(__pyx_v_self->_polls == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
__PYX_ERR(1, 600, __pyx_L3_error)
}
__pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_self->_polls, __pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 600, __pyx_L3_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_5 = __pyx_t_1;
__Pyx_INCREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_poll = ((struct __pyx_obj_6uvloop_4loop_UVPoll *)__pyx_t_5);
__pyx_t_5 = 0;
/* "uvloop/loop.pyx":599
* self._check_closed()
*
* try: # <<<<<<<<<<<<<<
* poll = (self._polls[fd])
* except KeyError:
*/
}
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
goto __pyx_L10_try_end;
__pyx_L3_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":601
* try:
* poll = (self._polls[fd])
* except KeyError: # <<<<<<<<<<<<<<
* poll = UVPoll.new(self, fd)
* self._polls[fd] = poll
*/
__pyx_t_6 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
if (__pyx_t_6) {
__Pyx_AddTraceback("uvloop.loop.Loop._add_writer", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_1, &__pyx_t_7) < 0) __PYX_ERR(1, 601, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_7);
/* "uvloop/loop.pyx":602
* poll = (self._polls[fd])
* except KeyError:
* poll = UVPoll.new(self, fd) # <<<<<<<<<<<<<<
* self._polls[fd] = poll
*
*/
__pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_fd); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 602, __pyx_L5_except_error)
__pyx_t_8 = ((PyObject *)__pyx_f_6uvloop_4loop_6UVPoll_new(__pyx_v_self, __pyx_t_6)); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 602, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_XDECREF_SET(__pyx_v_poll, ((struct __pyx_obj_6uvloop_4loop_UVPoll *)__pyx_t_8));
__pyx_t_8 = 0;
/* "uvloop/loop.pyx":603
* except KeyError:
* poll = UVPoll.new(self, fd)
* self._polls[fd] = poll # <<<<<<<<<<<<<<
*
* poll.start_writing(handle)
*/
if (unlikely(__pyx_v_self->_polls == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
__PYX_ERR(1, 603, __pyx_L5_except_error)
}
if (unlikely(PyDict_SetItem(__pyx_v_self->_polls, __pyx_v_fd, ((PyObject *)__pyx_v_poll)) < 0)) __PYX_ERR(1, 603, __pyx_L5_except_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
goto __pyx_L4_exception_handled;
}
goto __pyx_L5_except_error;
__pyx_L5_except_error:;
/* "uvloop/loop.pyx":599
* self._check_closed()
*
* try: # <<<<<<<<<<<<<<
* poll = (self._polls[fd])
* except KeyError:
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
goto __pyx_L1_error;
__pyx_L4_exception_handled:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
__pyx_L10_try_end:;
}
/* "uvloop/loop.pyx":605
* self._polls[fd] = poll
*
* poll.start_writing(handle) # <<<<<<<<<<<<<<
*
* cdef inline _remove_writer(self, fd):
*/
__pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_poll->__pyx_base.__pyx_vtab)->start_writing(__pyx_v_poll, __pyx_v_handle); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 605, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "uvloop/loop.pyx":593
* return result
*
* cdef inline _add_writer(self, fd, Handle handle): # <<<<<<<<<<<<<<
* cdef:
* UVPoll poll
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_AddTraceback("uvloop.loop.Loop._add_writer", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_poll);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":607
* poll.start_writing(handle)
*
* cdef inline _remove_writer(self, fd): # <<<<<<<<<<<<<<
* cdef:
* UVPoll poll
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__remove_writer(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fd) {
struct __pyx_obj_6uvloop_4loop_UVPoll *__pyx_v_poll = 0;
PyObject *__pyx_v_result = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
int __pyx_t_7;
PyObject *__pyx_t_8 = NULL;
__Pyx_RefNannySetupContext("_remove_writer", 0);
/* "uvloop/loop.pyx":611
* UVPoll poll
*
* if self._closed == 1: # <<<<<<<<<<<<<<
* return False
*
*/
__pyx_t_1 = ((__pyx_v_self->_closed == 1) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":612
*
* if self._closed == 1:
* return False # <<<<<<<<<<<<<<
*
* try:
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(Py_False);
__pyx_r = Py_False;
goto __pyx_L0;
/* "uvloop/loop.pyx":611
* UVPoll poll
*
* if self._closed == 1: # <<<<<<<<<<<<<<
* return False
*
*/
}
/* "uvloop/loop.pyx":614
* return False
*
* try: # <<<<<<<<<<<<<<
* poll = (self._polls[fd])
* except KeyError:
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
__Pyx_XGOTREF(__pyx_t_2);
__Pyx_XGOTREF(__pyx_t_3);
__Pyx_XGOTREF(__pyx_t_4);
/*try:*/ {
/* "uvloop/loop.pyx":615
*
* try:
* poll = (self._polls[fd]) # <<<<<<<<<<<<<<
* except KeyError:
* return False
*/
if (unlikely(__pyx_v_self->_polls == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
__PYX_ERR(1, 615, __pyx_L4_error)
}
__pyx_t_5 = __Pyx_PyDict_GetItem(__pyx_v_self->_polls, __pyx_v_fd); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 615, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = __pyx_t_5;
__Pyx_INCREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_v_poll = ((struct __pyx_obj_6uvloop_4loop_UVPoll *)__pyx_t_6);
__pyx_t_6 = 0;
/* "uvloop/loop.pyx":614
* return False
*
* try: # <<<<<<<<<<<<<<
* poll = (self._polls[fd])
* except KeyError:
*/
}
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
goto __pyx_L11_try_end;
__pyx_L4_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "uvloop/loop.pyx":616
* try:
* poll = (self._polls[fd])
* except KeyError: # <<<<<<<<<<<<<<
* return False
*
*/
__pyx_t_7 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
if (__pyx_t_7) {
__Pyx_AddTraceback("uvloop.loop.Loop._remove_writer", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_5, &__pyx_t_8) < 0) __PYX_ERR(1, 616, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_t_8);
/* "uvloop/loop.pyx":617
* poll = (self._polls[fd])
* except KeyError:
* return False # <<<<<<<<<<<<<<
*
* result = poll.stop_writing()
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(Py_False);
__pyx_r = Py_False;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
goto __pyx_L7_except_return;
}
goto __pyx_L6_except_error;
__pyx_L6_except_error:;
/* "uvloop/loop.pyx":614
* return False
*
* try: # <<<<<<<<<<<<<<
* poll = (self._polls[fd])
* except KeyError:
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
goto __pyx_L1_error;
__pyx_L7_except_return:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
goto __pyx_L0;
__pyx_L11_try_end:;
}
/* "uvloop/loop.pyx":619
* return False
*
* result = poll.stop_writing() # <<<<<<<<<<<<<<
* if not poll.is_active():
* del self._polls[fd]
*/
__pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_poll->__pyx_base.__pyx_vtab)->stop_writing(__pyx_v_poll); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 619, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__pyx_v_result = __pyx_t_8;
__pyx_t_8 = 0;
/* "uvloop/loop.pyx":620
*
* result = poll.stop_writing()
* if not poll.is_active(): # <<<<<<<<<<<<<<
* del self._polls[fd]
* poll._close()
*/
__pyx_t_1 = ((!(((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_poll->__pyx_base.__pyx_vtab)->is_active(__pyx_v_poll) != 0)) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":621
* result = poll.stop_writing()
* if not poll.is_active():
* del self._polls[fd] # <<<<<<<<<<<<<<
* poll._close()
* return result
*/
if (unlikely(__pyx_v_self->_polls == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
__PYX_ERR(1, 621, __pyx_L1_error)
}
if (unlikely(PyDict_DelItem(__pyx_v_self->_polls, __pyx_v_fd) < 0)) __PYX_ERR(1, 621, __pyx_L1_error)
/* "uvloop/loop.pyx":622
* if not poll.is_active():
* del self._polls[fd]
* poll._close() # <<<<<<<<<<<<<<
* return result
*
*/
__pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVPoll *)__pyx_v_poll->__pyx_base.__pyx_vtab)->__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_poll)); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 622, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
/* "uvloop/loop.pyx":620
*
* result = poll.stop_writing()
* if not poll.is_active(): # <<<<<<<<<<<<<<
* del self._polls[fd]
* poll._close()
*/
}
/* "uvloop/loop.pyx":623
* del self._polls[fd]
* poll._close()
* return result # <<<<<<<<<<<<<<
*
* cdef _getaddrinfo(self, object host, object port,
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v_result);
__pyx_r = __pyx_v_result;
goto __pyx_L0;
/* "uvloop/loop.pyx":607
* poll.start_writing(handle)
*
* cdef inline _remove_writer(self, fd): # <<<<<<<<<<<<<<
* cdef:
* UVPoll poll
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_AddTraceback("uvloop.loop.Loop._remove_writer", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_poll);
__Pyx_XDECREF(__pyx_v_result);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":645
* fut = self._new_future()
*
* def callback(result): # <<<<<<<<<<<<<<
* if AddrInfo.isinstance(result):
* try:
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_12_getaddrinfo_1callback(PyObject *__pyx_self, PyObject *__pyx_v_result); /*proto*/
static PyMethodDef __pyx_mdef_6uvloop_4loop_4Loop_12_getaddrinfo_1callback = {"callback", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_12_getaddrinfo_1callback, METH_O, 0};
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_12_getaddrinfo_1callback(PyObject *__pyx_self, PyObject *__pyx_v_result) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("callback (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_12_getaddrinfo_callback(__pyx_self, ((PyObject *)__pyx_v_result));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_12_getaddrinfo_callback(PyObject *__pyx_self, PyObject *__pyx_v_result) {
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo *__pyx_cur_scope;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo *__pyx_outer_scope;
PyObject *__pyx_v_data = NULL;
PyObject *__pyx_v_ex = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
int __pyx_t_8;
PyObject *__pyx_t_9 = NULL;
int __pyx_t_10;
PyObject *__pyx_t_11 = NULL;
PyObject *__pyx_t_12 = NULL;
PyObject *__pyx_t_13 = NULL;
int __pyx_t_14;
char const *__pyx_t_15;
PyObject *__pyx_t_16 = NULL;
PyObject *__pyx_t_17 = NULL;
PyObject *__pyx_t_18 = NULL;
PyObject *__pyx_t_19 = NULL;
PyObject *__pyx_t_20 = NULL;
PyObject *__pyx_t_21 = NULL;
__Pyx_RefNannySetupContext("callback", 0);
__pyx_outer_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo *) __Pyx_CyFunction_GetClosure(__pyx_self);
__pyx_cur_scope = __pyx_outer_scope;
/* "uvloop/loop.pyx":646
*
* def callback(result):
* if AddrInfo.isinstance(result): # <<<<<<<<<<<<<<
* try:
* if unpack == 0:
*/
__pyx_t_1 = (__pyx_f_6uvloop_4loop_8AddrInfo_isinstance(__pyx_v_result) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":647
* def callback(result):
* if AddrInfo.isinstance(result):
* try: # <<<<<<<<<<<<<<
* if unpack == 0:
* data = result
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4);
__Pyx_XGOTREF(__pyx_t_2);
__Pyx_XGOTREF(__pyx_t_3);
__Pyx_XGOTREF(__pyx_t_4);
/*try:*/ {
/* "uvloop/loop.pyx":648
* if AddrInfo.isinstance(result):
* try:
* if unpack == 0: # <<<<<<<<<<<<<<
* data = result
* else:
*/
__pyx_t_1 = ((__pyx_cur_scope->__pyx_v_unpack == 0) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":649
* try:
* if unpack == 0:
* data = result # <<<<<<<<<<<<<<
* else:
* data = (result).unpack()
*/
__Pyx_INCREF(__pyx_v_result);
__pyx_v_data = __pyx_v_result;
/* "uvloop/loop.pyx":648
* if AddrInfo.isinstance(result):
* try:
* if unpack == 0: # <<<<<<<<<<<<<<
* data = result
* else:
*/
goto __pyx_L12;
}
/* "uvloop/loop.pyx":651
* data = result
* else:
* data = (result).unpack() # <<<<<<<<<<<<<<
* except Exception as ex:
* if not fut.cancelled():
*/
/*else*/ {
__pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_AddrInfo *)((struct __pyx_obj_6uvloop_4loop_AddrInfo *)__pyx_v_result)->__pyx_vtab)->unpack(((struct __pyx_obj_6uvloop_4loop_AddrInfo *)__pyx_v_result)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 651, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_v_data = __pyx_t_5;
__pyx_t_5 = 0;
}
__pyx_L12:;
/* "uvloop/loop.pyx":647
* def callback(result):
* if AddrInfo.isinstance(result):
* try: # <<<<<<<<<<<<<<
* if unpack == 0:
* data = result
*/
}
/* "uvloop/loop.pyx":656
* fut.set_exception(ex)
* else:
* if not fut.cancelled(): # <<<<<<<<<<<<<<
* fut.set_result(data)
* else:
*/
/*else:*/ {
if (unlikely(!__pyx_cur_scope->__pyx_v_fut)) { __Pyx_RaiseClosureNameError("fut"); __PYX_ERR(1, 656, __pyx_L6_except_error) }
__pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_fut, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 656, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_7 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
__pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
if (likely(__pyx_t_7)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
__Pyx_INCREF(__pyx_t_7);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_6, function);
}
}
if (__pyx_t_7) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 656, __pyx_L6_except_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else {
__pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 656, __pyx_L6_except_error)
}
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 656, __pyx_L6_except_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_8 = ((!__pyx_t_1) != 0);
if (__pyx_t_8) {
/* "uvloop/loop.pyx":657
* else:
* if not fut.cancelled():
* fut.set_result(data) # <<<<<<<<<<<<<<
* else:
* if not fut.cancelled():
*/
if (unlikely(!__pyx_cur_scope->__pyx_v_fut)) { __Pyx_RaiseClosureNameError("fut"); __PYX_ERR(1, 657, __pyx_L6_except_error) }
__pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_fut, __pyx_n_s_set_result); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 657, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_7 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
__pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
if (likely(__pyx_t_7)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
__Pyx_INCREF(__pyx_t_7);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_6, function);
}
}
if (!__pyx_t_7) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_data); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 657, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_5);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_6)) {
PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_data};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 657, __pyx_L6_except_error)
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_v_data};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 657, __pyx_L6_except_error)
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else
#endif
{
__pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 657, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL;
__Pyx_INCREF(__pyx_v_data);
__Pyx_GIVEREF(__pyx_v_data);
PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_v_data);
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_9, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 657, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
}
}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":656
* fut.set_exception(ex)
* else:
* if not fut.cancelled(): # <<<<<<<<<<<<<<
* fut.set_result(data)
* else:
*/
}
}
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
goto __pyx_L11_try_end;
__pyx_L4_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":652
* else:
* data = (result).unpack()
* except Exception as ex: # <<<<<<<<<<<<<<
* if not fut.cancelled():
* fut.set_exception(ex)
*/
__pyx_t_10 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
if (__pyx_t_10) {
__Pyx_AddTraceback("uvloop.loop.Loop._getaddrinfo.callback", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_9) < 0) __PYX_ERR(1, 652, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_t_9);
__Pyx_INCREF(__pyx_t_6);
__pyx_v_ex = __pyx_t_6;
/*try:*/ {
/* "uvloop/loop.pyx":653
* data = (result).unpack()
* except Exception as ex:
* if not fut.cancelled(): # <<<<<<<<<<<<<<
* fut.set_exception(ex)
* else:
*/
if (unlikely(!__pyx_cur_scope->__pyx_v_fut)) { __Pyx_RaiseClosureNameError("fut"); __PYX_ERR(1, 653, __pyx_L19_error) }
__pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_fut, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 653, __pyx_L19_error)
__Pyx_GOTREF(__pyx_t_11);
__pyx_t_12 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
__pyx_t_12 = PyMethod_GET_SELF(__pyx_t_11);
if (likely(__pyx_t_12)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
__Pyx_INCREF(__pyx_t_12);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_11, function);
}
}
if (__pyx_t_12) {
__pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_12); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 653, __pyx_L19_error)
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
} else {
__pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_11); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 653, __pyx_L19_error)
}
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(1, 653, __pyx_L19_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_1 = ((!__pyx_t_8) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":654
* except Exception as ex:
* if not fut.cancelled():
* fut.set_exception(ex) # <<<<<<<<<<<<<<
* else:
* if not fut.cancelled():
*/
if (unlikely(!__pyx_cur_scope->__pyx_v_fut)) { __Pyx_RaiseClosureNameError("fut"); __PYX_ERR(1, 654, __pyx_L19_error) }
__pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_fut, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 654, __pyx_L19_error)
__Pyx_GOTREF(__pyx_t_11);
__pyx_t_12 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
__pyx_t_12 = PyMethod_GET_SELF(__pyx_t_11);
if (likely(__pyx_t_12)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
__Pyx_INCREF(__pyx_t_12);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_11, function);
}
}
if (!__pyx_t_12) {
__pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_v_ex); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 654, __pyx_L19_error)
__Pyx_GOTREF(__pyx_t_7);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_11)) {
PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_v_ex};
__pyx_t_7 = __Pyx_PyFunction_FastCall(__pyx_t_11, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 654, __pyx_L19_error)
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_GOTREF(__pyx_t_7);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_11)) {
PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_v_ex};
__pyx_t_7 = __Pyx_PyCFunction_FastCall(__pyx_t_11, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 654, __pyx_L19_error)
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_GOTREF(__pyx_t_7);
} else
#endif
{
__pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 654, __pyx_L19_error)
__Pyx_GOTREF(__pyx_t_13);
__Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); __pyx_t_12 = NULL;
__Pyx_INCREF(__pyx_v_ex);
__Pyx_GIVEREF(__pyx_v_ex);
PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_v_ex);
__pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_13, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 654, __pyx_L19_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
}
}
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "uvloop/loop.pyx":653
* data = (result).unpack()
* except Exception as ex:
* if not fut.cancelled(): # <<<<<<<<<<<<<<
* fut.set_exception(ex)
* else:
*/
}
}
/* "uvloop/loop.pyx":652
* else:
* data = (result).unpack()
* except Exception as ex: # <<<<<<<<<<<<<<
* if not fut.cancelled():
* fut.set_exception(ex)
*/
/*finally:*/ {
/*normal exit:*/{
__Pyx_DECREF(__pyx_v_ex);
__pyx_v_ex = NULL;
goto __pyx_L20;
}
/*exception exit:*/{
__Pyx_PyThreadState_declare
__pyx_L19_error:;
__pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_19, &__pyx_t_20, &__pyx_t_21);
if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18) < 0)) __Pyx_ErrFetch(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
__Pyx_XGOTREF(__pyx_t_16);
__Pyx_XGOTREF(__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_18);
__Pyx_XGOTREF(__pyx_t_19);
__Pyx_XGOTREF(__pyx_t_20);
__Pyx_XGOTREF(__pyx_t_21);
__pyx_t_10 = __pyx_lineno; __pyx_t_14 = __pyx_clineno; __pyx_t_15 = __pyx_filename;
{
__Pyx_DECREF(__pyx_v_ex);
__pyx_v_ex = NULL;
}
__Pyx_PyThreadState_assign
if (PY_MAJOR_VERSION >= 3) {
__Pyx_XGIVEREF(__pyx_t_19);
__Pyx_XGIVEREF(__pyx_t_20);
__Pyx_XGIVEREF(__pyx_t_21);
__Pyx_ExceptionReset(__pyx_t_19, __pyx_t_20, __pyx_t_21);
}
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_ErrRestore(__pyx_t_16, __pyx_t_17, __pyx_t_18);
__pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0;
__pyx_lineno = __pyx_t_10; __pyx_clineno = __pyx_t_14; __pyx_filename = __pyx_t_15;
goto __pyx_L6_except_error;
}
__pyx_L20:;
}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
goto __pyx_L5_exception_handled;
}
goto __pyx_L6_except_error;
__pyx_L6_except_error:;
/* "uvloop/loop.pyx":647
* def callback(result):
* if AddrInfo.isinstance(result):
* try: # <<<<<<<<<<<<<<
* if unpack == 0:
* data = result
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
goto __pyx_L1_error;
__pyx_L5_exception_handled:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4);
__pyx_L11_try_end:;
}
/* "uvloop/loop.pyx":646
*
* def callback(result):
* if AddrInfo.isinstance(result): # <<<<<<<<<<<<<<
* try:
* if unpack == 0:
*/
goto __pyx_L3;
}
/* "uvloop/loop.pyx":659
* fut.set_result(data)
* else:
* if not fut.cancelled(): # <<<<<<<<<<<<<<
* fut.set_exception(result)
*
*/
/*else*/ {
if (unlikely(!__pyx_cur_scope->__pyx_v_fut)) { __Pyx_RaiseClosureNameError("fut"); __PYX_ERR(1, 659, __pyx_L1_error) }
__pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_fut, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 659, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_6, function);
}
}
if (__pyx_t_5) {
__pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_5); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 659, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
__pyx_t_9 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 659, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 659, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__pyx_t_8 = ((!__pyx_t_1) != 0);
if (__pyx_t_8) {
/* "uvloop/loop.pyx":660
* else:
* if not fut.cancelled():
* fut.set_exception(result) # <<<<<<<<<<<<<<
*
* AddrInfoRequest(self, host, port, family, type, proto, flags, callback)
*/
if (unlikely(!__pyx_cur_scope->__pyx_v_fut)) { __Pyx_RaiseClosureNameError("fut"); __PYX_ERR(1, 660, __pyx_L1_error) }
__pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_fut, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 660, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_6, function);
}
}
if (!__pyx_t_5) {
__pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_v_result); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 660, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_6)) {
PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_v_result};
__pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 660, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_9);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_v_result};
__pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 660, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_9);
} else
#endif
{
__pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 660, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_INCREF(__pyx_v_result);
__Pyx_GIVEREF(__pyx_v_result);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_result);
__pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_7, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 660, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
/* "uvloop/loop.pyx":659
* fut.set_result(data)
* else:
* if not fut.cancelled(): # <<<<<<<<<<<<<<
* fut.set_exception(result)
*
*/
}
}
__pyx_L3:;
/* "uvloop/loop.pyx":645
* fut = self._new_future()
*
* def callback(result): # <<<<<<<<<<<<<<
* if AddrInfo.isinstance(result):
* try:
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_9);
__Pyx_XDECREF(__pyx_t_11);
__Pyx_XDECREF(__pyx_t_12);
__Pyx_XDECREF(__pyx_t_13);
__Pyx_AddTraceback("uvloop.loop.Loop._getaddrinfo.callback", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_data);
__Pyx_XDECREF(__pyx_v_ex);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":625
* return result
*
* cdef _getaddrinfo(self, object host, object port, # <<<<<<<<<<<<<<
* int family, int type,
* int proto, int flags,
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__getaddrinfo(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_host, PyObject *__pyx_v_port, int __pyx_v_family, int __pyx_v_type, int __pyx_v_proto, int __pyx_v_flags, int __pyx_v_unpack) {
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo *__pyx_cur_scope;
PyObject *__pyx_v_callback = 0;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_t_6;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
__Pyx_RefNannySetupContext("_getaddrinfo", 0);
__pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct___getaddrinfo(__pyx_ptype_6uvloop_4loop___pyx_scope_struct___getaddrinfo, __pyx_empty_tuple, NULL);
if (unlikely(!__pyx_cur_scope)) {
__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct___getaddrinfo *)Py_None);
__Pyx_INCREF(Py_None);
__PYX_ERR(1, 625, __pyx_L1_error)
} else {
__Pyx_GOTREF(__pyx_cur_scope);
}
__pyx_cur_scope->__pyx_v_unpack = __pyx_v_unpack;
__Pyx_INCREF(__pyx_v_host);
__Pyx_INCREF(__pyx_v_port);
/* "uvloop/loop.pyx":630
* int unpack):
*
* if isinstance(port, str): # <<<<<<<<<<<<<<
* port = port.encode()
* elif isinstance(port, int):
*/
__pyx_t_1 = PyUnicode_Check(__pyx_v_port);
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":631
*
* if isinstance(port, str):
* port = port.encode() # <<<<<<<<<<<<<<
* elif isinstance(port, int):
* port = str(port).encode()
*/
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_port, __pyx_n_s_encode); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 631, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (__pyx_t_5) {
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 631, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
__pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 631, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF_SET(__pyx_v_port, __pyx_t_3);
__pyx_t_3 = 0;
/* "uvloop/loop.pyx":630
* int unpack):
*
* if isinstance(port, str): # <<<<<<<<<<<<<<
* port = port.encode()
* elif isinstance(port, int):
*/
goto __pyx_L3;
}
/* "uvloop/loop.pyx":632
* if isinstance(port, str):
* port = port.encode()
* elif isinstance(port, int): # <<<<<<<<<<<<<<
* port = str(port).encode()
* if port is not None and not isinstance(port, bytes):
*/
__pyx_t_2 = PyInt_Check(__pyx_v_port);
__pyx_t_1 = (__pyx_t_2 != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":633
* port = port.encode()
* elif isinstance(port, int):
* port = str(port).encode() # <<<<<<<<<<<<<<
* if port is not None and not isinstance(port, bytes):
* raise TypeError('port must be a str, bytes or int')
*/
__pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 633, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_v_port);
__Pyx_GIVEREF(__pyx_v_port);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_port);
__pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 633, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = PyUnicode_AsEncodedString(((PyObject*)__pyx_t_4), NULL, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 633, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF_SET(__pyx_v_port, __pyx_t_3);
__pyx_t_3 = 0;
/* "uvloop/loop.pyx":632
* if isinstance(port, str):
* port = port.encode()
* elif isinstance(port, int): # <<<<<<<<<<<<<<
* port = str(port).encode()
* if port is not None and not isinstance(port, bytes):
*/
}
__pyx_L3:;
/* "uvloop/loop.pyx":634
* elif isinstance(port, int):
* port = str(port).encode()
* if port is not None and not isinstance(port, bytes): # <<<<<<<<<<<<<<
* raise TypeError('port must be a str, bytes or int')
*
*/
__pyx_t_2 = (__pyx_v_port != Py_None);
__pyx_t_6 = (__pyx_t_2 != 0);
if (__pyx_t_6) {
} else {
__pyx_t_1 = __pyx_t_6;
goto __pyx_L5_bool_binop_done;
}
__pyx_t_6 = PyBytes_Check(__pyx_v_port);
__pyx_t_2 = ((!(__pyx_t_6 != 0)) != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L5_bool_binop_done:;
if (__pyx_t_1) {
/* "uvloop/loop.pyx":635
* port = str(port).encode()
* if port is not None and not isinstance(port, bytes):
* raise TypeError('port must be a str, bytes or int') # <<<<<<<<<<<<<<
*
* if isinstance(host, str):
*/
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 635, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 635, __pyx_L1_error)
/* "uvloop/loop.pyx":634
* elif isinstance(port, int):
* port = str(port).encode()
* if port is not None and not isinstance(port, bytes): # <<<<<<<<<<<<<<
* raise TypeError('port must be a str, bytes or int')
*
*/
}
/* "uvloop/loop.pyx":637
* raise TypeError('port must be a str, bytes or int')
*
* if isinstance(host, str): # <<<<<<<<<<<<<<
* host = host.encode('idna')
* if host is not None:
*/
__pyx_t_1 = PyUnicode_Check(__pyx_v_host);
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":638
*
* if isinstance(host, str):
* host = host.encode('idna') # <<<<<<<<<<<<<<
* if host is not None:
* if not isinstance(host, bytes):
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_host, __pyx_n_s_encode); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 638, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__18, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 638, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF_SET(__pyx_v_host, __pyx_t_4);
__pyx_t_4 = 0;
/* "uvloop/loop.pyx":637
* raise TypeError('port must be a str, bytes or int')
*
* if isinstance(host, str): # <<<<<<<<<<<<<<
* host = host.encode('idna')
* if host is not None:
*/
}
/* "uvloop/loop.pyx":639
* if isinstance(host, str):
* host = host.encode('idna')
* if host is not None: # <<<<<<<<<<<<<<
* if not isinstance(host, bytes):
* raise TypeError('host must be a str or bytes')
*/
__pyx_t_2 = (__pyx_v_host != Py_None);
__pyx_t_1 = (__pyx_t_2 != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":640
* host = host.encode('idna')
* if host is not None:
* if not isinstance(host, bytes): # <<<<<<<<<<<<<<
* raise TypeError('host must be a str or bytes')
*
*/
__pyx_t_1 = PyBytes_Check(__pyx_v_host);
__pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":641
* if host is not None:
* if not isinstance(host, bytes):
* raise TypeError('host must be a str or bytes') # <<<<<<<<<<<<<<
*
* fut = self._new_future()
*/
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__19, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 641, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__PYX_ERR(1, 641, __pyx_L1_error)
/* "uvloop/loop.pyx":640
* host = host.encode('idna')
* if host is not None:
* if not isinstance(host, bytes): # <<<<<<<<<<<<<<
* raise TypeError('host must be a str or bytes')
*
*/
}
/* "uvloop/loop.pyx":639
* if isinstance(host, str):
* host = host.encode('idna')
* if host is not None: # <<<<<<<<<<<<<<
* if not isinstance(host, bytes):
* raise TypeError('host must be a str or bytes')
*/
}
/* "uvloop/loop.pyx":643
* raise TypeError('host must be a str or bytes')
*
* fut = self._new_future() # <<<<<<<<<<<<<<
*
* def callback(result):
*/
__pyx_t_4 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_v_self); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 643, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_4);
__pyx_cur_scope->__pyx_v_fut = __pyx_t_4;
__pyx_t_4 = 0;
/* "uvloop/loop.pyx":645
* fut = self._new_future()
*
* def callback(result): # <<<<<<<<<<<<<<
* if AddrInfo.isinstance(result):
* try:
*/
__pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6uvloop_4loop_4Loop_12_getaddrinfo_1callback, 0, __pyx_n_s_Loop__getaddrinfo_locals_callbac, ((PyObject*)__pyx_cur_scope), __pyx_n_s_uvloop_loop, __pyx_d, ((PyObject *)__pyx_codeobj__21)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 645, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_v_callback = __pyx_t_4;
__pyx_t_4 = 0;
/* "uvloop/loop.pyx":662
* fut.set_exception(result)
*
* AddrInfoRequest(self, host, port, family, type, proto, flags, callback) # <<<<<<<<<<<<<<
* return fut
*
*/
__pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_family); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 662, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_type); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 662, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_proto); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 662, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 662, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_8 = PyTuple_New(8); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 662, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_v_self));
PyTuple_SET_ITEM(__pyx_t_8, 0, ((PyObject *)__pyx_v_self));
__Pyx_INCREF(__pyx_v_host);
__Pyx_GIVEREF(__pyx_v_host);
PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_v_host);
__Pyx_INCREF(__pyx_v_port);
__Pyx_GIVEREF(__pyx_v_port);
PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_v_port);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_8, 3, __pyx_t_4);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_8, 4, __pyx_t_3);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_8, 5, __pyx_t_5);
__Pyx_GIVEREF(__pyx_t_7);
PyTuple_SET_ITEM(__pyx_t_8, 6, __pyx_t_7);
__Pyx_INCREF(__pyx_v_callback);
__Pyx_GIVEREF(__pyx_v_callback);
PyTuple_SET_ITEM(__pyx_t_8, 7, __pyx_v_callback);
__pyx_t_4 = 0;
__pyx_t_3 = 0;
__pyx_t_5 = 0;
__pyx_t_7 = 0;
__pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6uvloop_4loop_AddrInfoRequest), __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 662, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "uvloop/loop.pyx":663
*
* AddrInfoRequest(self, host, port, family, type, proto, flags, callback)
* return fut # <<<<<<<<<<<<<<
*
* cdef _getnameinfo(self, system.sockaddr *addr, int flags):
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_fut);
__pyx_r = __pyx_cur_scope->__pyx_v_fut;
goto __pyx_L0;
/* "uvloop/loop.pyx":625
* return result
*
* cdef _getaddrinfo(self, object host, object port, # <<<<<<<<<<<<<<
* int family, int type,
* int proto, int flags,
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_AddTraceback("uvloop.loop.Loop._getaddrinfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_callback);
__Pyx_XDECREF(__pyx_v_host);
__Pyx_XDECREF(__pyx_v_port);
__Pyx_DECREF(((PyObject *)__pyx_cur_scope));
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":669
* fut = self._new_future()
*
* def callback(result): # <<<<<<<<<<<<<<
* if isinstance(result, tuple):
* fut.set_result(result)
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_12_getnameinfo_1callback(PyObject *__pyx_self, PyObject *__pyx_v_result); /*proto*/
static PyMethodDef __pyx_mdef_6uvloop_4loop_4Loop_12_getnameinfo_1callback = {"callback", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_12_getnameinfo_1callback, METH_O, 0};
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_12_getnameinfo_1callback(PyObject *__pyx_self, PyObject *__pyx_v_result) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("callback (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_12_getnameinfo_callback(__pyx_self, ((PyObject *)__pyx_v_result));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_12_getnameinfo_callback(PyObject *__pyx_self, PyObject *__pyx_v_result) {
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo *__pyx_cur_scope;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo *__pyx_outer_scope;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
__Pyx_RefNannySetupContext("callback", 0);
__pyx_outer_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo *) __Pyx_CyFunction_GetClosure(__pyx_self);
__pyx_cur_scope = __pyx_outer_scope;
/* "uvloop/loop.pyx":670
*
* def callback(result):
* if isinstance(result, tuple): # <<<<<<<<<<<<<<
* fut.set_result(result)
* else:
*/
__pyx_t_1 = PyTuple_Check(__pyx_v_result);
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":671
* def callback(result):
* if isinstance(result, tuple):
* fut.set_result(result) # <<<<<<<<<<<<<<
* else:
* fut.set_exception(result)
*/
if (unlikely(!__pyx_cur_scope->__pyx_v_fut)) { __Pyx_RaiseClosureNameError("fut"); __PYX_ERR(1, 671, __pyx_L1_error) }
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_fut, __pyx_n_s_set_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 671, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (!__pyx_t_5) {
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_result); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 671, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_v_result};
__pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 671, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_v_result};
__pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 671, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else
#endif
{
__pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 671, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_INCREF(__pyx_v_result);
__Pyx_GIVEREF(__pyx_v_result);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_result);
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 671, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":670
*
* def callback(result):
* if isinstance(result, tuple): # <<<<<<<<<<<<<<
* fut.set_result(result)
* else:
*/
goto __pyx_L3;
}
/* "uvloop/loop.pyx":673
* fut.set_result(result)
* else:
* fut.set_exception(result) # <<<<<<<<<<<<<<
*
* nr = NameInfoRequest(self, callback)
*/
/*else*/ {
if (unlikely(!__pyx_cur_scope->__pyx_v_fut)) { __Pyx_RaiseClosureNameError("fut"); __PYX_ERR(1, 673, __pyx_L1_error) }
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_fut, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 673, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (!__pyx_t_6) {
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_result); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 673, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_result};
__pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 673, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_result};
__pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 673, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else
#endif
{
__pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 673, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_INCREF(__pyx_v_result);
__Pyx_GIVEREF(__pyx_v_result);
PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_result);
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 673, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
__pyx_L3:;
/* "uvloop/loop.pyx":669
* fut = self._new_future()
*
* def callback(result): # <<<<<<<<<<<<<<
* if isinstance(result, tuple):
* fut.set_result(result)
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_AddTraceback("uvloop.loop.Loop._getnameinfo.callback", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":665
* return fut
*
* cdef _getnameinfo(self, system.sockaddr *addr, int flags): # <<<<<<<<<<<<<<
* cdef NameInfoRequest nr
* fut = self._new_future()
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__getnameinfo(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, struct sockaddr *__pyx_v_addr, int __pyx_v_flags) {
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo *__pyx_cur_scope;
struct __pyx_obj_6uvloop_4loop_NameInfoRequest *__pyx_v_nr = 0;
PyObject *__pyx_v_callback = 0;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
__Pyx_RefNannySetupContext("_getnameinfo", 0);
__pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_1__getnameinfo(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_1__getnameinfo, __pyx_empty_tuple, NULL);
if (unlikely(!__pyx_cur_scope)) {
__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_1__getnameinfo *)Py_None);
__Pyx_INCREF(Py_None);
__PYX_ERR(1, 665, __pyx_L1_error)
} else {
__Pyx_GOTREF(__pyx_cur_scope);
}
/* "uvloop/loop.pyx":667
* cdef _getnameinfo(self, system.sockaddr *addr, int flags):
* cdef NameInfoRequest nr
* fut = self._new_future() # <<<<<<<<<<<<<<
*
* def callback(result):
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 667, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
__pyx_cur_scope->__pyx_v_fut = __pyx_t_1;
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":669
* fut = self._new_future()
*
* def callback(result): # <<<<<<<<<<<<<<
* if isinstance(result, tuple):
* fut.set_result(result)
*/
__pyx_t_1 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6uvloop_4loop_4Loop_12_getnameinfo_1callback, 0, __pyx_n_s_Loop__getnameinfo_locals_callbac, ((PyObject*)__pyx_cur_scope), __pyx_n_s_uvloop_loop, __pyx_d, ((PyObject *)__pyx_codeobj__23)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 669, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_callback = __pyx_t_1;
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":675
* fut.set_exception(result)
*
* nr = NameInfoRequest(self, callback) # <<<<<<<<<<<<<<
* nr.query(addr, flags)
* return fut
*/
__pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 675, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_v_self));
PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self));
__Pyx_INCREF(__pyx_v_callback);
__Pyx_GIVEREF(__pyx_v_callback);
PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_callback);
__pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6uvloop_4loop_NameInfoRequest), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 675, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_nr = ((struct __pyx_obj_6uvloop_4loop_NameInfoRequest *)__pyx_t_2);
__pyx_t_2 = 0;
/* "uvloop/loop.pyx":676
*
* nr = NameInfoRequest(self, callback)
* nr.query(addr, flags) # <<<<<<<<<<<<<<
* return fut
*
*/
__pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_NameInfoRequest *)__pyx_v_nr->__pyx_base.__pyx_vtab)->query(__pyx_v_nr, __pyx_v_addr, __pyx_v_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 676, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":677
* nr = NameInfoRequest(self, callback)
* nr.query(addr, flags)
* return fut # <<<<<<<<<<<<<<
*
* cdef _sock_recv(self, fut, sock, n):
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_fut);
__pyx_r = __pyx_cur_scope->__pyx_v_fut;
goto __pyx_L0;
/* "uvloop/loop.pyx":665
* return fut
*
* cdef _getnameinfo(self, system.sockaddr *addr, int flags): # <<<<<<<<<<<<<<
* cdef NameInfoRequest nr
* fut = self._new_future()
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_AddTraceback("uvloop.loop.Loop._getnameinfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_nr);
__Pyx_XDECREF(__pyx_v_callback);
__Pyx_DECREF(((PyObject *)__pyx_cur_scope));
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":679
* return fut
*
* cdef _sock_recv(self, fut, sock, n): # <<<<<<<<<<<<<<
* cdef:
* Handle handle
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_recv(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fut, PyObject *__pyx_v_sock, PyObject *__pyx_v_n) {
int __pyx_v_fd;
PyObject *__pyx_v_data = NULL;
PyObject *__pyx_v_exc = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
int __pyx_t_4;
int __pyx_t_5;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
PyObject *__pyx_t_10 = NULL;
PyObject *__pyx_t_11 = NULL;
PyObject *__pyx_t_12 = NULL;
int __pyx_t_13;
char const *__pyx_t_14;
PyObject *__pyx_t_15 = NULL;
PyObject *__pyx_t_16 = NULL;
PyObject *__pyx_t_17 = NULL;
PyObject *__pyx_t_18 = NULL;
PyObject *__pyx_t_19 = NULL;
PyObject *__pyx_t_20 = NULL;
__Pyx_RefNannySetupContext("_sock_recv", 0);
/* "uvloop/loop.pyx":684
* int fd
*
* fd = sock.fileno() # <<<<<<<<<<<<<<
* if fut.cancelled():
* self._remove_reader(fd)
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_fileno); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 684, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (__pyx_t_3) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 684, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 684, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 684, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_fd = __pyx_t_4;
/* "uvloop/loop.pyx":685
*
* fd = sock.fileno()
* if fut.cancelled(): # <<<<<<<<<<<<<<
* self._remove_reader(fd)
* return
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 685, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (__pyx_t_3) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 685, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 685, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(1, 685, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_5) {
/* "uvloop/loop.pyx":686
* fd = sock.fileno()
* if fut.cancelled():
* self._remove_reader(fd) # <<<<<<<<<<<<<<
* return
*
*/
__pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 686, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = __pyx_f_6uvloop_4loop_4Loop__remove_reader(__pyx_v_self, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 686, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":687
* if fut.cancelled():
* self._remove_reader(fd)
* return # <<<<<<<<<<<<<<
*
* try:
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
/* "uvloop/loop.pyx":685
*
* fd = sock.fileno()
* if fut.cancelled(): # <<<<<<<<<<<<<<
* self._remove_reader(fd)
* return
*/
}
/* "uvloop/loop.pyx":689
* return
*
* try: # <<<<<<<<<<<<<<
* data = sock.recv(n)
* except (BlockingIOError, InterruptedError):
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8);
__Pyx_XGOTREF(__pyx_t_6);
__Pyx_XGOTREF(__pyx_t_7);
__Pyx_XGOTREF(__pyx_t_8);
/*try:*/ {
/* "uvloop/loop.pyx":690
*
* try:
* data = sock.recv(n) # <<<<<<<<<<<<<<
* except (BlockingIOError, InterruptedError):
* # No need to re-add the reader, let's just wait until
*/
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_recv); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 690, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_1, function);
}
}
if (!__pyx_t_3) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_n); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 690, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_2);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_1)) {
PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_n};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 690, __pyx_L4_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_n};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 690, __pyx_L4_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else
#endif
{
__pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 690, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_INCREF(__pyx_v_n);
__Pyx_GIVEREF(__pyx_v_n);
PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_v_n);
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_9, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 690, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
}
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_data = __pyx_t_2;
__pyx_t_2 = 0;
/* "uvloop/loop.pyx":689
* return
*
* try: # <<<<<<<<<<<<<<
* data = sock.recv(n)
* except (BlockingIOError, InterruptedError):
*/
}
/* "uvloop/loop.pyx":699
* self._remove_reader(fd)
* else:
* fut.set_result(data) # <<<<<<<<<<<<<<
* self._remove_reader(fd)
*
*/
/*else:*/ {
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_set_result); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 699, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_9 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
__pyx_t_9 = PyMethod_GET_SELF(__pyx_t_1);
if (likely(__pyx_t_9)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
__Pyx_INCREF(__pyx_t_9);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_1, function);
}
}
if (!__pyx_t_9) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_data); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 699, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_2);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_1)) {
PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_v_data};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 699, __pyx_L6_except_error)
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_v_data};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 699, __pyx_L6_except_error)
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else
#endif
{
__pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 699, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_9); __pyx_t_9 = NULL;
__Pyx_INCREF(__pyx_v_data);
__Pyx_GIVEREF(__pyx_v_data);
PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_v_data);
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 699, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":700
* else:
* fut.set_result(data)
* self._remove_reader(fd) # <<<<<<<<<<<<<<
*
* cdef _sock_sendall(self, fut, sock, data):
*/
__pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_fd); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 700, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__remove_reader(__pyx_v_self, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 700, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
goto __pyx_L11_try_end;
__pyx_L4_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":691
* try:
* data = sock.recv(n)
* except (BlockingIOError, InterruptedError): # <<<<<<<<<<<<<<
* # No need to re-add the reader, let's just wait until
* # the poll handler calls this callback again.
*/
__pyx_t_4 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BlockingIOError) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_InterruptedError);
if (__pyx_t_4) {
__Pyx_ErrRestore(0,0,0);
goto __pyx_L5_exception_handled;
}
/* "uvloop/loop.pyx":695
* # the poll handler calls this callback again.
* pass
* except Exception as exc: # <<<<<<<<<<<<<<
* fut.set_exception(exc)
* self._remove_reader(fd)
*/
__pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
if (__pyx_t_4) {
__Pyx_AddTraceback("uvloop.loop.Loop._sock_recv", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3) < 0) __PYX_ERR(1, 695, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_t_2);
__pyx_v_exc = __pyx_t_2;
/*try:*/ {
/* "uvloop/loop.pyx":696
* pass
* except Exception as exc:
* fut.set_exception(exc) # <<<<<<<<<<<<<<
* self._remove_reader(fd)
* else:
*/
__pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 696, __pyx_L17_error)
__Pyx_GOTREF(__pyx_t_10);
__pyx_t_11 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) {
__pyx_t_11 = PyMethod_GET_SELF(__pyx_t_10);
if (likely(__pyx_t_11)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
__Pyx_INCREF(__pyx_t_11);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_10, function);
}
}
if (!__pyx_t_11) {
__pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_exc); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 696, __pyx_L17_error)
__Pyx_GOTREF(__pyx_t_9);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_10)) {
PyObject *__pyx_temp[2] = {__pyx_t_11, __pyx_v_exc};
__pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_10, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 696, __pyx_L17_error)
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_GOTREF(__pyx_t_9);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_10)) {
PyObject *__pyx_temp[2] = {__pyx_t_11, __pyx_v_exc};
__pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_10, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 696, __pyx_L17_error)
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_GOTREF(__pyx_t_9);
} else
#endif
{
__pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 696, __pyx_L17_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_11); __pyx_t_11 = NULL;
__Pyx_INCREF(__pyx_v_exc);
__Pyx_GIVEREF(__pyx_v_exc);
PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_v_exc);
__pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_12, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 696, __pyx_L17_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
}
}
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
/* "uvloop/loop.pyx":697
* except Exception as exc:
* fut.set_exception(exc)
* self._remove_reader(fd) # <<<<<<<<<<<<<<
* else:
* fut.set_result(data)
*/
__pyx_t_9 = __Pyx_PyInt_From_int(__pyx_v_fd); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 697, __pyx_L17_error)
__Pyx_GOTREF(__pyx_t_9);
__pyx_t_10 = __pyx_f_6uvloop_4loop_4Loop__remove_reader(__pyx_v_self, __pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 697, __pyx_L17_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
}
/* "uvloop/loop.pyx":695
* # the poll handler calls this callback again.
* pass
* except Exception as exc: # <<<<<<<<<<<<<<
* fut.set_exception(exc)
* self._remove_reader(fd)
*/
/*finally:*/ {
/*normal exit:*/{
__Pyx_DECREF(__pyx_v_exc);
__pyx_v_exc = NULL;
goto __pyx_L18;
}
/*exception exit:*/{
__Pyx_PyThreadState_declare
__pyx_L17_error:;
__pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20);
if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17) < 0)) __Pyx_ErrFetch(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_15);
__Pyx_XGOTREF(__pyx_t_16);
__Pyx_XGOTREF(__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_18);
__Pyx_XGOTREF(__pyx_t_19);
__Pyx_XGOTREF(__pyx_t_20);
__pyx_t_4 = __pyx_lineno; __pyx_t_13 = __pyx_clineno; __pyx_t_14 = __pyx_filename;
{
__Pyx_DECREF(__pyx_v_exc);
__pyx_v_exc = NULL;
}
__Pyx_PyThreadState_assign
if (PY_MAJOR_VERSION >= 3) {
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_XGIVEREF(__pyx_t_19);
__Pyx_XGIVEREF(__pyx_t_20);
__Pyx_ExceptionReset(__pyx_t_18, __pyx_t_19, __pyx_t_20);
}
__Pyx_XGIVEREF(__pyx_t_15);
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_ErrRestore(__pyx_t_15, __pyx_t_16, __pyx_t_17);
__pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
__pyx_lineno = __pyx_t_4; __pyx_clineno = __pyx_t_13; __pyx_filename = __pyx_t_14;
goto __pyx_L6_except_error;
}
__pyx_L18:;
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
goto __pyx_L5_exception_handled;
}
goto __pyx_L6_except_error;
__pyx_L6_except_error:;
/* "uvloop/loop.pyx":689
* return
*
* try: # <<<<<<<<<<<<<<
* data = sock.recv(n)
* except (BlockingIOError, InterruptedError):
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
goto __pyx_L1_error;
__pyx_L5_exception_handled:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
__pyx_L11_try_end:;
}
/* "uvloop/loop.pyx":679
* return fut
*
* cdef _sock_recv(self, fut, sock, n): # <<<<<<<<<<<<<<
* cdef:
* Handle handle
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_9);
__Pyx_XDECREF(__pyx_t_10);
__Pyx_XDECREF(__pyx_t_11);
__Pyx_XDECREF(__pyx_t_12);
__Pyx_AddTraceback("uvloop.loop.Loop._sock_recv", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_data);
__Pyx_XDECREF(__pyx_v_exc);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":702
* self._remove_reader(fd)
*
* cdef _sock_sendall(self, fut, sock, data): # <<<<<<<<<<<<<<
* cdef:
* Handle handle
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_sendall(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fut, PyObject *__pyx_v_sock, PyObject *__pyx_v_data) {
struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle = 0;
int __pyx_v_n;
int __pyx_v_fd;
PyObject *__pyx_v_exc = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
int __pyx_t_4;
int __pyx_t_5;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
PyObject *__pyx_t_10 = NULL;
PyObject *__pyx_t_11 = NULL;
PyObject *__pyx_t_12 = NULL;
int __pyx_t_13;
char const *__pyx_t_14;
PyObject *__pyx_t_15 = NULL;
PyObject *__pyx_t_16 = NULL;
PyObject *__pyx_t_17 = NULL;
PyObject *__pyx_t_18 = NULL;
PyObject *__pyx_t_19 = NULL;
PyObject *__pyx_t_20 = NULL;
Py_ssize_t __pyx_t_21;
int __pyx_t_22;
__Pyx_RefNannySetupContext("_sock_sendall", 0);
__Pyx_INCREF(__pyx_v_data);
/* "uvloop/loop.pyx":708
* int fd
*
* fd = sock.fileno() # <<<<<<<<<<<<<<
*
* if fut.cancelled():
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_fileno); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 708, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (__pyx_t_3) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 708, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 708, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 708, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_fd = __pyx_t_4;
/* "uvloop/loop.pyx":710
* fd = sock.fileno()
*
* if fut.cancelled(): # <<<<<<<<<<<<<<
* self._remove_writer(fd)
* return
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 710, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (__pyx_t_3) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 710, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 710, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(1, 710, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_5) {
/* "uvloop/loop.pyx":711
*
* if fut.cancelled():
* self._remove_writer(fd) # <<<<<<<<<<<<<<
* return
*
*/
__pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 711, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = __pyx_f_6uvloop_4loop_4Loop__remove_writer(__pyx_v_self, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 711, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":712
* if fut.cancelled():
* self._remove_writer(fd)
* return # <<<<<<<<<<<<<<
*
* try:
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
/* "uvloop/loop.pyx":710
* fd = sock.fileno()
*
* if fut.cancelled(): # <<<<<<<<<<<<<<
* self._remove_writer(fd)
* return
*/
}
/* "uvloop/loop.pyx":714
* return
*
* try: # <<<<<<<<<<<<<<
* n = sock.send(data)
* except (BlockingIOError, InterruptedError):
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8);
__Pyx_XGOTREF(__pyx_t_6);
__Pyx_XGOTREF(__pyx_t_7);
__Pyx_XGOTREF(__pyx_t_8);
/*try:*/ {
/* "uvloop/loop.pyx":715
*
* try:
* n = sock.send(data) # <<<<<<<<<<<<<<
* except (BlockingIOError, InterruptedError):
* # Try next time.
*/
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_send); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 715, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_1, function);
}
}
if (!__pyx_t_3) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_data); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 715, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_2);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_1)) {
PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_data};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 715, __pyx_L4_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_data};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 715, __pyx_L4_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else
#endif
{
__pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 715, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_INCREF(__pyx_v_data);
__Pyx_GIVEREF(__pyx_v_data);
PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_v_data);
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_9, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 715, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
}
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 715, __pyx_L4_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_v_n = __pyx_t_4;
/* "uvloop/loop.pyx":714
* return
*
* try: # <<<<<<<<<<<<<<
* n = sock.send(data)
* except (BlockingIOError, InterruptedError):
*/
}
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
goto __pyx_L11_try_end;
__pyx_L4_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":716
* try:
* n = sock.send(data)
* except (BlockingIOError, InterruptedError): # <<<<<<<<<<<<<<
* # Try next time.
* return
*/
__pyx_t_4 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BlockingIOError) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_InterruptedError);
if (__pyx_t_4) {
__Pyx_AddTraceback("uvloop.loop.Loop._sock_sendall", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_1, &__pyx_t_9) < 0) __PYX_ERR(1, 716, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_9);
/* "uvloop/loop.pyx":718
* except (BlockingIOError, InterruptedError):
* # Try next time.
* return # <<<<<<<<<<<<<<
* except Exception as exc:
* fut.set_exception(exc)
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
goto __pyx_L7_except_return;
}
/* "uvloop/loop.pyx":719
* # Try next time.
* return
* except Exception as exc: # <<<<<<<<<<<<<<
* fut.set_exception(exc)
* self._remove_writer(fd)
*/
__pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
if (__pyx_t_4) {
__Pyx_AddTraceback("uvloop.loop.Loop._sock_sendall", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_1, &__pyx_t_2) < 0) __PYX_ERR(1, 719, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_t_1);
__pyx_v_exc = __pyx_t_1;
/*try:*/ {
/* "uvloop/loop.pyx":720
* return
* except Exception as exc:
* fut.set_exception(exc) # <<<<<<<<<<<<<<
* self._remove_writer(fd)
* return
*/
__pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 720, __pyx_L19_error)
__Pyx_GOTREF(__pyx_t_10);
__pyx_t_11 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) {
__pyx_t_11 = PyMethod_GET_SELF(__pyx_t_10);
if (likely(__pyx_t_11)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
__Pyx_INCREF(__pyx_t_11);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_10, function);
}
}
if (!__pyx_t_11) {
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_exc); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 720, __pyx_L19_error)
__Pyx_GOTREF(__pyx_t_3);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_10)) {
PyObject *__pyx_temp[2] = {__pyx_t_11, __pyx_v_exc};
__pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_10, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 720, __pyx_L19_error)
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_10)) {
PyObject *__pyx_temp[2] = {__pyx_t_11, __pyx_v_exc};
__pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_10, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 720, __pyx_L19_error)
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else
#endif
{
__pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 720, __pyx_L19_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_11); __pyx_t_11 = NULL;
__Pyx_INCREF(__pyx_v_exc);
__Pyx_GIVEREF(__pyx_v_exc);
PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_v_exc);
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_12, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 720, __pyx_L19_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
}
}
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":721
* except Exception as exc:
* fut.set_exception(exc)
* self._remove_writer(fd) # <<<<<<<<<<<<<<
* return
*
*/
__pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_fd); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 721, __pyx_L19_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_10 = __pyx_f_6uvloop_4loop_4Loop__remove_writer(__pyx_v_self, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 721, __pyx_L19_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
/* "uvloop/loop.pyx":722
* fut.set_exception(exc)
* self._remove_writer(fd)
* return # <<<<<<<<<<<<<<
*
* if n == len(data):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
goto __pyx_L18_return;
}
/* "uvloop/loop.pyx":719
* # Try next time.
* return
* except Exception as exc: # <<<<<<<<<<<<<<
* fut.set_exception(exc)
* self._remove_writer(fd)
*/
/*finally:*/ {
/*exception exit:*/{
__Pyx_PyThreadState_declare
__pyx_L19_error:;
__pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20);
if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17) < 0)) __Pyx_ErrFetch(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_15);
__Pyx_XGOTREF(__pyx_t_16);
__Pyx_XGOTREF(__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_18);
__Pyx_XGOTREF(__pyx_t_19);
__Pyx_XGOTREF(__pyx_t_20);
__pyx_t_4 = __pyx_lineno; __pyx_t_13 = __pyx_clineno; __pyx_t_14 = __pyx_filename;
{
__Pyx_DECREF(__pyx_v_exc);
__pyx_v_exc = NULL;
}
__Pyx_PyThreadState_assign
if (PY_MAJOR_VERSION >= 3) {
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_XGIVEREF(__pyx_t_19);
__Pyx_XGIVEREF(__pyx_t_20);
__Pyx_ExceptionReset(__pyx_t_18, __pyx_t_19, __pyx_t_20);
}
__Pyx_XGIVEREF(__pyx_t_15);
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_ErrRestore(__pyx_t_15, __pyx_t_16, __pyx_t_17);
__pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
__pyx_lineno = __pyx_t_4; __pyx_clineno = __pyx_t_13; __pyx_filename = __pyx_t_14;
goto __pyx_L6_except_error;
}
__pyx_L18_return: {
__pyx_t_20 = __pyx_r;
__pyx_r = 0;
__Pyx_DECREF(__pyx_v_exc);
__pyx_v_exc = NULL;
__pyx_r = __pyx_t_20;
__pyx_t_20 = 0;
goto __pyx_L7_except_return;
}
}
}
goto __pyx_L6_except_error;
__pyx_L6_except_error:;
/* "uvloop/loop.pyx":714
* return
*
* try: # <<<<<<<<<<<<<<
* n = sock.send(data)
* except (BlockingIOError, InterruptedError):
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
goto __pyx_L1_error;
__pyx_L7_except_return:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
goto __pyx_L0;
__pyx_L11_try_end:;
}
/* "uvloop/loop.pyx":724
* return
*
* if n == len(data): # <<<<<<<<<<<<<<
* fut.set_result(None)
* self._remove_writer(fd)
*/
__pyx_t_21 = PyObject_Length(__pyx_v_data); if (unlikely(__pyx_t_21 == -1)) __PYX_ERR(1, 724, __pyx_L1_error)
__pyx_t_5 = ((__pyx_v_n == __pyx_t_21) != 0);
if (__pyx_t_5) {
/* "uvloop/loop.pyx":725
*
* if n == len(data):
* fut.set_result(None) # <<<<<<<<<<<<<<
* self._remove_writer(fd)
* else:
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_set_result); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 725, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 725, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":726
* if n == len(data):
* fut.set_result(None)
* self._remove_writer(fd) # <<<<<<<<<<<<<<
* else:
* if n:
*/
__pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 726, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = __pyx_f_6uvloop_4loop_4Loop__remove_writer(__pyx_v_self, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 726, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":724
* return
*
* if n == len(data): # <<<<<<<<<<<<<<
* fut.set_result(None)
* self._remove_writer(fd)
*/
goto __pyx_L25;
}
/* "uvloop/loop.pyx":728
* self._remove_writer(fd)
* else:
* if n: # <<<<<<<<<<<<<<
* if not isinstance(data, memoryview):
* data = memoryview(data)
*/
/*else*/ {
__pyx_t_5 = (__pyx_v_n != 0);
if (__pyx_t_5) {
/* "uvloop/loop.pyx":729
* else:
* if n:
* if not isinstance(data, memoryview): # <<<<<<<<<<<<<<
* data = memoryview(data)
* data = data[n:]
*/
__pyx_t_5 = PyObject_IsInstance(__pyx_v_data, __pyx_builtin_memoryview); if (unlikely(__pyx_t_5 == -1)) __PYX_ERR(1, 729, __pyx_L1_error)
__pyx_t_22 = ((!(__pyx_t_5 != 0)) != 0);
if (__pyx_t_22) {
/* "uvloop/loop.pyx":730
* if n:
* if not isinstance(data, memoryview):
* data = memoryview(data) # <<<<<<<<<<<<<<
* data = data[n:]
*
*/
__pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 730, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_v_data);
__Pyx_GIVEREF(__pyx_v_data);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_data);
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_memoryview, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 730, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF_SET(__pyx_v_data, __pyx_t_1);
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":729
* else:
* if n:
* if not isinstance(data, memoryview): # <<<<<<<<<<<<<<
* data = memoryview(data)
* data = data[n:]
*/
}
/* "uvloop/loop.pyx":731
* if not isinstance(data, memoryview):
* data = memoryview(data)
* data = data[n:] # <<<<<<<<<<<<<<
*
* handle = new_MethodHandle3(
*/
__pyx_t_1 = __Pyx_PyObject_GetSlice(__pyx_v_data, __pyx_v_n, 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 731, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF_SET(__pyx_v_data, __pyx_t_1);
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":728
* self._remove_writer(fd)
* else:
* if n: # <<<<<<<<<<<<<<
* if not isinstance(data, memoryview):
* data = memoryview(data)
*/
}
/* "uvloop/loop.pyx":733
* data = data[n:]
*
* handle = new_MethodHandle3( # <<<<<<<<<<<<<<
* self,
* "Loop._sock_sendall",
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_new_MethodHandle3(__pyx_v_self, __pyx_kp_u_Loop__sock_sendall, ((__pyx_t_6uvloop_4loop_method3_t)((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_sock_sendall), ((PyObject *)__pyx_v_self), __pyx_v_fut, __pyx_v_sock, __pyx_v_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 733, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(1, 733, __pyx_L1_error)
__pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_1);
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":740
* fut, sock, data)
*
* self._add_writer(fd, handle) # <<<<<<<<<<<<<<
*
* cdef _sock_accept(self, fut, sock):
*/
__pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 740, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = __pyx_f_6uvloop_4loop_4Loop__add_writer(__pyx_v_self, __pyx_t_1, __pyx_v_handle); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 740, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
__pyx_L25:;
/* "uvloop/loop.pyx":702
* self._remove_reader(fd)
*
* cdef _sock_sendall(self, fut, sock, data): # <<<<<<<<<<<<<<
* cdef:
* Handle handle
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_9);
__Pyx_XDECREF(__pyx_t_10);
__Pyx_XDECREF(__pyx_t_11);
__Pyx_XDECREF(__pyx_t_12);
__Pyx_AddTraceback("uvloop.loop.Loop._sock_sendall", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_handle);
__Pyx_XDECREF(__pyx_v_exc);
__Pyx_XDECREF(__pyx_v_data);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":742
* self._add_writer(fd, handle)
*
* cdef _sock_accept(self, fut, sock): # <<<<<<<<<<<<<<
* cdef:
* Handle handle
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_accept(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fut, PyObject *__pyx_v_sock) {
PyObject *__pyx_v_fd = NULL;
PyObject *__pyx_v_conn = NULL;
PyObject *__pyx_v_address = NULL;
PyObject *__pyx_v_exc = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
int __pyx_t_4;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
PyObject *(*__pyx_t_9)(PyObject *);
PyObject *__pyx_t_10 = NULL;
int __pyx_t_11;
PyObject *__pyx_t_12 = NULL;
PyObject *__pyx_t_13 = NULL;
int __pyx_t_14;
char const *__pyx_t_15;
PyObject *__pyx_t_16 = NULL;
PyObject *__pyx_t_17 = NULL;
PyObject *__pyx_t_18 = NULL;
PyObject *__pyx_t_19 = NULL;
PyObject *__pyx_t_20 = NULL;
PyObject *__pyx_t_21 = NULL;
__Pyx_RefNannySetupContext("_sock_accept", 0);
/* "uvloop/loop.pyx":746
* Handle handle
*
* fd = sock.fileno() # <<<<<<<<<<<<<<
*
* if fut.cancelled():
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_fileno); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 746, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (__pyx_t_3) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 746, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 746, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_v_fd = __pyx_t_1;
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":748
* fd = sock.fileno()
*
* if fut.cancelled(): # <<<<<<<<<<<<<<
* self._remove_reader(fd)
* return
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 748, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (__pyx_t_3) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 748, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 748, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 748, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_4) {
/* "uvloop/loop.pyx":749
*
* if fut.cancelled():
* self._remove_reader(fd) # <<<<<<<<<<<<<<
* return
*
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__remove_reader(__pyx_v_self, __pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 749, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":750
* if fut.cancelled():
* self._remove_reader(fd)
* return # <<<<<<<<<<<<<<
*
* try:
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
/* "uvloop/loop.pyx":748
* fd = sock.fileno()
*
* if fut.cancelled(): # <<<<<<<<<<<<<<
* self._remove_reader(fd)
* return
*/
}
/* "uvloop/loop.pyx":752
* return
*
* try: # <<<<<<<<<<<<<<
* conn, address = sock.accept()
* conn.setblocking(False)
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7);
__Pyx_XGOTREF(__pyx_t_5);
__Pyx_XGOTREF(__pyx_t_6);
__Pyx_XGOTREF(__pyx_t_7);
/*try:*/ {
/* "uvloop/loop.pyx":753
*
* try:
* conn, address = sock.accept() # <<<<<<<<<<<<<<
* conn.setblocking(False)
* except (BlockingIOError, InterruptedError):
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_accept); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 753, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (__pyx_t_3) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 753, __pyx_L4_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 753, __pyx_L4_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) {
PyObject* sequence = __pyx_t_1;
#if !CYTHON_COMPILING_IN_PYPY
Py_ssize_t size = Py_SIZE(sequence);
#else
Py_ssize_t size = PySequence_Size(sequence);
#endif
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
__PYX_ERR(1, 753, __pyx_L4_error)
}
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
if (likely(PyTuple_CheckExact(sequence))) {
__pyx_t_2 = PyTuple_GET_ITEM(sequence, 0);
__pyx_t_3 = PyTuple_GET_ITEM(sequence, 1);
} else {
__pyx_t_2 = PyList_GET_ITEM(sequence, 0);
__pyx_t_3 = PyList_GET_ITEM(sequence, 1);
}
__Pyx_INCREF(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
#else
__pyx_t_2 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 753, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 753, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
Py_ssize_t index = -1;
__pyx_t_8 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 753, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_9 = Py_TYPE(__pyx_t_8)->tp_iternext;
index = 0; __pyx_t_2 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_2)) goto __pyx_L12_unpacking_failed;
__Pyx_GOTREF(__pyx_t_2);
index = 1; __pyx_t_3 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_3)) goto __pyx_L12_unpacking_failed;
__Pyx_GOTREF(__pyx_t_3);
if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_8), 2) < 0) __PYX_ERR(1, 753, __pyx_L4_error)
__pyx_t_9 = NULL;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
goto __pyx_L13_unpacking_done;
__pyx_L12_unpacking_failed:;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__pyx_t_9 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
__PYX_ERR(1, 753, __pyx_L4_error)
__pyx_L13_unpacking_done:;
}
__pyx_v_conn = __pyx_t_2;
__pyx_t_2 = 0;
__pyx_v_address = __pyx_t_3;
__pyx_t_3 = 0;
/* "uvloop/loop.pyx":754
* try:
* conn, address = sock.accept()
* conn.setblocking(False) # <<<<<<<<<<<<<<
* except (BlockingIOError, InterruptedError):
* # There is an active reader for _sock_accept, so
*/
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_conn, __pyx_n_s_setblocking); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 754, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 754, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":752
* return
*
* try: # <<<<<<<<<<<<<<
* conn, address = sock.accept()
* conn.setblocking(False)
*/
}
/* "uvloop/loop.pyx":763
* self._remove_reader(fd)
* else:
* fut.set_result((conn, address)) # <<<<<<<<<<<<<<
* self._remove_reader(fd)
*
*/
/*else:*/ {
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_set_result); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 763, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 763, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_v_conn);
__Pyx_GIVEREF(__pyx_v_conn);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_conn);
__Pyx_INCREF(__pyx_v_address);
__Pyx_GIVEREF(__pyx_v_address);
PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_address);
__pyx_t_8 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
__pyx_t_8 = PyMethod_GET_SELF(__pyx_t_1);
if (likely(__pyx_t_8)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
__Pyx_INCREF(__pyx_t_8);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_1, function);
}
}
if (!__pyx_t_8) {
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 763, __pyx_L6_except_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_1)) {
PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_t_2};
__pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 763, __pyx_L6_except_error)
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_t_2};
__pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 763, __pyx_L6_except_error)
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
} else
#endif
{
__pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 763, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL;
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_2);
__pyx_t_2 = 0;
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 763, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
}
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":764
* else:
* fut.set_result((conn, address))
* self._remove_reader(fd) # <<<<<<<<<<<<<<
*
* cdef _sock_connect(self, fut, sock, address):
*/
__pyx_t_3 = __pyx_f_6uvloop_4loop_4Loop__remove_reader(__pyx_v_self, __pyx_v_fd); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 764, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
goto __pyx_L11_try_end;
__pyx_L4_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":755
* conn, address = sock.accept()
* conn.setblocking(False)
* except (BlockingIOError, InterruptedError): # <<<<<<<<<<<<<<
* # There is an active reader for _sock_accept, so
* # do nothing, it will be called again.
*/
__pyx_t_11 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BlockingIOError) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_InterruptedError);
if (__pyx_t_11) {
__Pyx_ErrRestore(0,0,0);
goto __pyx_L5_exception_handled;
}
/* "uvloop/loop.pyx":759
* # do nothing, it will be called again.
* pass
* except Exception as exc: # <<<<<<<<<<<<<<
* fut.set_exception(exc)
* self._remove_reader(fd)
*/
__pyx_t_11 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
if (__pyx_t_11) {
__Pyx_AddTraceback("uvloop.loop.Loop._sock_accept", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_1, &__pyx_t_10) < 0) __PYX_ERR(1, 759, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_10);
__Pyx_INCREF(__pyx_t_1);
__pyx_v_exc = __pyx_t_1;
/*try:*/ {
/* "uvloop/loop.pyx":760
* pass
* except Exception as exc:
* fut.set_exception(exc) # <<<<<<<<<<<<<<
* self._remove_reader(fd)
* else:
*/
__pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 760, __pyx_L19_error)
__Pyx_GOTREF(__pyx_t_8);
__pyx_t_12 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) {
__pyx_t_12 = PyMethod_GET_SELF(__pyx_t_8);
if (likely(__pyx_t_12)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
__Pyx_INCREF(__pyx_t_12);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_8, function);
}
}
if (!__pyx_t_12) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_v_exc); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 760, __pyx_L19_error)
__Pyx_GOTREF(__pyx_t_2);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_8)) {
PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_v_exc};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 760, __pyx_L19_error)
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) {
PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_v_exc};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 760, __pyx_L19_error)
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else
#endif
{
__pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 760, __pyx_L19_error)
__Pyx_GOTREF(__pyx_t_13);
__Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); __pyx_t_12 = NULL;
__Pyx_INCREF(__pyx_v_exc);
__Pyx_GIVEREF(__pyx_v_exc);
PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_v_exc);
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_13, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 760, __pyx_L19_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
}
}
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":761
* except Exception as exc:
* fut.set_exception(exc)
* self._remove_reader(fd) # <<<<<<<<<<<<<<
* else:
* fut.set_result((conn, address))
*/
__pyx_t_2 = __pyx_f_6uvloop_4loop_4Loop__remove_reader(__pyx_v_self, __pyx_v_fd); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 761, __pyx_L19_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
/* "uvloop/loop.pyx":759
* # do nothing, it will be called again.
* pass
* except Exception as exc: # <<<<<<<<<<<<<<
* fut.set_exception(exc)
* self._remove_reader(fd)
*/
/*finally:*/ {
/*normal exit:*/{
__Pyx_DECREF(__pyx_v_exc);
__pyx_v_exc = NULL;
goto __pyx_L20;
}
/*exception exit:*/{
__Pyx_PyThreadState_declare
__pyx_L19_error:;
__pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_19, &__pyx_t_20, &__pyx_t_21);
if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18) < 0)) __Pyx_ErrFetch(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
__Pyx_XGOTREF(__pyx_t_16);
__Pyx_XGOTREF(__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_18);
__Pyx_XGOTREF(__pyx_t_19);
__Pyx_XGOTREF(__pyx_t_20);
__Pyx_XGOTREF(__pyx_t_21);
__pyx_t_11 = __pyx_lineno; __pyx_t_14 = __pyx_clineno; __pyx_t_15 = __pyx_filename;
{
__Pyx_DECREF(__pyx_v_exc);
__pyx_v_exc = NULL;
}
__Pyx_PyThreadState_assign
if (PY_MAJOR_VERSION >= 3) {
__Pyx_XGIVEREF(__pyx_t_19);
__Pyx_XGIVEREF(__pyx_t_20);
__Pyx_XGIVEREF(__pyx_t_21);
__Pyx_ExceptionReset(__pyx_t_19, __pyx_t_20, __pyx_t_21);
}
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_ErrRestore(__pyx_t_16, __pyx_t_17, __pyx_t_18);
__pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0;
__pyx_lineno = __pyx_t_11; __pyx_clineno = __pyx_t_14; __pyx_filename = __pyx_t_15;
goto __pyx_L6_except_error;
}
__pyx_L20:;
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
goto __pyx_L5_exception_handled;
}
goto __pyx_L6_except_error;
__pyx_L6_except_error:;
/* "uvloop/loop.pyx":752
* return
*
* try: # <<<<<<<<<<<<<<
* conn, address = sock.accept()
* conn.setblocking(False)
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7);
goto __pyx_L1_error;
__pyx_L5_exception_handled:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7);
__pyx_L11_try_end:;
}
/* "uvloop/loop.pyx":742
* self._add_writer(fd, handle)
*
* cdef _sock_accept(self, fut, sock): # <<<<<<<<<<<<<<
* cdef:
* Handle handle
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_XDECREF(__pyx_t_10);
__Pyx_XDECREF(__pyx_t_12);
__Pyx_XDECREF(__pyx_t_13);
__Pyx_AddTraceback("uvloop.loop.Loop._sock_accept", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_fd);
__Pyx_XDECREF(__pyx_v_conn);
__Pyx_XDECREF(__pyx_v_address);
__Pyx_XDECREF(__pyx_v_exc);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":778
* # becomes writable to be notified when the connection succeed or
* # fails.
* fut.add_done_callback(lambda fut: self._remove_writer(fd)) # <<<<<<<<<<<<<<
*
* handle = new_MethodHandle3(
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_13_sock_connect_lambda(PyObject *__pyx_self, PyObject *__pyx_v_fut); /*proto*/
static PyMethodDef __pyx_mdef_6uvloop_4loop_4Loop_13_sock_connect_lambda = {"lambda", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_13_sock_connect_lambda, METH_O, 0};
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_13_sock_connect_lambda(PyObject *__pyx_self, PyObject *__pyx_v_fut) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("lambda (wrapper)", 0);
__pyx_r = __pyx_lambda_funcdef_lambda(__pyx_self, ((PyObject *)__pyx_v_fut));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_lambda_funcdef_lambda(PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_fut) {
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2__sock_connect *__pyx_cur_scope;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2__sock_connect *__pyx_outer_scope;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
__Pyx_RefNannySetupContext("lambda", 0);
__pyx_outer_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2__sock_connect *) __Pyx_CyFunction_GetClosure(__pyx_self);
__pyx_cur_scope = __pyx_outer_scope;
__Pyx_XDECREF(__pyx_r);
if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(1, 778, __pyx_L1_error) }
if (unlikely(!__pyx_cur_scope->__pyx_v_fd)) { __Pyx_RaiseClosureNameError("fd"); __PYX_ERR(1, 778, __pyx_L1_error) }
__pyx_t_1 = __pyx_cur_scope->__pyx_v_fd;
__Pyx_INCREF(__pyx_t_1);
__pyx_t_2 = __pyx_f_6uvloop_4loop_4Loop__remove_writer(__pyx_cur_scope->__pyx_v_self, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 778, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_AddTraceback("uvloop.loop.Loop._sock_connect.lambda", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":766
* self._remove_reader(fd)
*
* cdef _sock_connect(self, fut, sock, address): # <<<<<<<<<<<<<<
* cdef:
* Handle handle
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_connect(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fut, PyObject *__pyx_v_sock, PyObject *__pyx_v_address) {
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2__sock_connect *__pyx_cur_scope;
struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle = 0;
PyObject *__pyx_v_exc = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
int __pyx_t_8;
PyObject *__pyx_t_9 = NULL;
PyObject *__pyx_t_10 = NULL;
PyObject *__pyx_t_11 = NULL;
PyObject *__pyx_t_12 = NULL;
int __pyx_t_13;
char const *__pyx_t_14;
PyObject *__pyx_t_15 = NULL;
PyObject *__pyx_t_16 = NULL;
PyObject *__pyx_t_17 = NULL;
PyObject *__pyx_t_18 = NULL;
PyObject *__pyx_t_19 = NULL;
PyObject *__pyx_t_20 = NULL;
__Pyx_RefNannySetupContext("_sock_connect", 0);
__pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2__sock_connect *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_2__sock_connect(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_2__sock_connect, __pyx_empty_tuple, NULL);
if (unlikely(!__pyx_cur_scope)) {
__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_2__sock_connect *)Py_None);
__Pyx_INCREF(Py_None);
__PYX_ERR(1, 766, __pyx_L1_error)
} else {
__Pyx_GOTREF(__pyx_cur_scope);
}
__pyx_cur_scope->__pyx_v_self = __pyx_v_self;
__Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
/* "uvloop/loop.pyx":770
* Handle handle
*
* fd = sock.fileno() # <<<<<<<<<<<<<<
* try:
* sock.connect(address)
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_fileno); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 770, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (__pyx_t_3) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 770, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 770, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_GIVEREF(__pyx_t_1);
__pyx_cur_scope->__pyx_v_fd = __pyx_t_1;
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":771
*
* fd = sock.fileno()
* try: # <<<<<<<<<<<<<<
* sock.connect(address)
* except (BlockingIOError, InterruptedError):
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6);
__Pyx_XGOTREF(__pyx_t_4);
__Pyx_XGOTREF(__pyx_t_5);
__Pyx_XGOTREF(__pyx_t_6);
/*try:*/ {
/* "uvloop/loop.pyx":772
* fd = sock.fileno()
* try:
* sock.connect(address) # <<<<<<<<<<<<<<
* except (BlockingIOError, InterruptedError):
* # Issue #23618: When the C function connect() fails with EINTR, the
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_connect); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 772, __pyx_L3_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (!__pyx_t_3) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_address); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 772, __pyx_L3_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_address};
__pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 772, __pyx_L3_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_address};
__pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 772, __pyx_L3_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else
#endif
{
__pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 772, __pyx_L3_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_INCREF(__pyx_v_address);
__Pyx_GIVEREF(__pyx_v_address);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_address);
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 772, __pyx_L3_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":771
*
* fd = sock.fileno()
* try: # <<<<<<<<<<<<<<
* sock.connect(address)
* except (BlockingIOError, InterruptedError):
*/
}
/* "uvloop/loop.pyx":791
* fut.set_exception(exc)
* else:
* fut.set_result(None) # <<<<<<<<<<<<<<
*
* cdef _sock_connect_cb(self, fut, sock, address):
*/
/*else:*/ {
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_set_result); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 791, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 791, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
}
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
goto __pyx_L10_try_end;
__pyx_L3_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":773
* try:
* sock.connect(address)
* except (BlockingIOError, InterruptedError): # <<<<<<<<<<<<<<
* # Issue #23618: When the C function connect() fails with EINTR, the
* # connection runs in background. We have to wait until the socket
*/
__pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BlockingIOError) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_InterruptedError);
if (__pyx_t_8) {
__Pyx_AddTraceback("uvloop.loop.Loop._sock_connect", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_1, &__pyx_t_7) < 0) __PYX_ERR(1, 773, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_7);
/* "uvloop/loop.pyx":778
* # becomes writable to be notified when the connection succeed or
* # fails.
* fut.add_done_callback(lambda fut: self._remove_writer(fd)) # <<<<<<<<<<<<<<
*
* handle = new_MethodHandle3(
*/
__pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_add_done_callback); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 778, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_9);
__pyx_t_10 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6uvloop_4loop_4Loop_13_sock_connect_lambda, 0, __pyx_n_s_Loop__sock_connect_locals_lambda, ((PyObject*)__pyx_cur_scope), __pyx_n_s_uvloop_loop, __pyx_d, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 778, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_10);
__pyx_t_11 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_9))) {
__pyx_t_11 = PyMethod_GET_SELF(__pyx_t_9);
if (likely(__pyx_t_11)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9);
__Pyx_INCREF(__pyx_t_11);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_9, function);
}
}
if (!__pyx_t_11) {
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_9, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 778, __pyx_L5_except_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_9)) {
PyObject *__pyx_temp[2] = {__pyx_t_11, __pyx_t_10};
__pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 778, __pyx_L5_except_error)
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) {
PyObject *__pyx_temp[2] = {__pyx_t_11, __pyx_t_10};
__pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 778, __pyx_L5_except_error)
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
} else
#endif
{
__pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 778, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_11); __pyx_t_11 = NULL;
__Pyx_GIVEREF(__pyx_t_10);
PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_10);
__pyx_t_10 = 0;
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_12, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 778, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
}
}
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":781
*
* handle = new_MethodHandle3(
* self, # <<<<<<<<<<<<<<
* "Loop._sock_connect",
* self._sock_connect_cb,
*/
__pyx_t_3 = ((PyObject *)__pyx_cur_scope->__pyx_v_self);
__Pyx_INCREF(__pyx_t_3);
/* "uvloop/loop.pyx":784
* "Loop._sock_connect",
* self._sock_connect_cb,
* self, # <<<<<<<<<<<<<<
* fut, sock, address)
*
*/
__pyx_t_9 = ((PyObject *)__pyx_cur_scope->__pyx_v_self);
__Pyx_INCREF(__pyx_t_9);
/* "uvloop/loop.pyx":780
* fut.add_done_callback(lambda fut: self._remove_writer(fd))
*
* handle = new_MethodHandle3( # <<<<<<<<<<<<<<
* self,
* "Loop._sock_connect",
*/
__pyx_t_12 = __pyx_f_6uvloop_4loop_new_MethodHandle3(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_t_3), __pyx_kp_u_Loop__sock_connect, ((__pyx_t_6uvloop_4loop_method3_t)((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_sock_connect_cb), __pyx_t_9, __pyx_v_fut, __pyx_v_sock, __pyx_v_address); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 780, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
if (!(likely(((__pyx_t_12) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_12, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(1, 780, __pyx_L5_except_error)
__pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_12);
__pyx_t_12 = 0;
/* "uvloop/loop.pyx":787
* fut, sock, address)
*
* self._add_writer(fd, handle) # <<<<<<<<<<<<<<
* except Exception as exc:
* fut.set_exception(exc)
*/
__pyx_t_12 = __pyx_cur_scope->__pyx_v_fd;
__Pyx_INCREF(__pyx_t_12);
__pyx_t_9 = __pyx_f_6uvloop_4loop_4Loop__add_writer(__pyx_cur_scope->__pyx_v_self, __pyx_t_12, __pyx_v_handle); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 787, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
goto __pyx_L4_exception_handled;
}
/* "uvloop/loop.pyx":788
*
* self._add_writer(fd, handle)
* except Exception as exc: # <<<<<<<<<<<<<<
* fut.set_exception(exc)
* else:
*/
__pyx_t_8 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
if (__pyx_t_8) {
__Pyx_AddTraceback("uvloop.loop.Loop._sock_connect", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_1, &__pyx_t_2) < 0) __PYX_ERR(1, 788, __pyx_L5_except_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_t_1);
__pyx_v_exc = __pyx_t_1;
/*try:*/ {
/* "uvloop/loop.pyx":789
* self._add_writer(fd, handle)
* except Exception as exc:
* fut.set_exception(exc) # <<<<<<<<<<<<<<
* else:
* fut.set_result(None)
*/
__pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 789, __pyx_L18_error)
__Pyx_GOTREF(__pyx_t_12);
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_12))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_12);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_12, function);
}
}
if (!__pyx_t_3) {
__pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_v_exc); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 789, __pyx_L18_error)
__Pyx_GOTREF(__pyx_t_9);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_12)) {
PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_exc};
__pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_12, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 789, __pyx_L18_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_9);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_12)) {
PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_exc};
__pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_12, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 789, __pyx_L18_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_9);
} else
#endif
{
__pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 789, __pyx_L18_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_INCREF(__pyx_v_exc);
__Pyx_GIVEREF(__pyx_v_exc);
PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_v_exc);
__pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_10, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 789, __pyx_L18_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
}
}
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
}
/* "uvloop/loop.pyx":788
*
* self._add_writer(fd, handle)
* except Exception as exc: # <<<<<<<<<<<<<<
* fut.set_exception(exc)
* else:
*/
/*finally:*/ {
/*normal exit:*/{
__Pyx_DECREF(__pyx_v_exc);
__pyx_v_exc = NULL;
goto __pyx_L19;
}
/*exception exit:*/{
__Pyx_PyThreadState_declare
__pyx_L18_error:;
__pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20);
if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17) < 0)) __Pyx_ErrFetch(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_15);
__Pyx_XGOTREF(__pyx_t_16);
__Pyx_XGOTREF(__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_18);
__Pyx_XGOTREF(__pyx_t_19);
__Pyx_XGOTREF(__pyx_t_20);
__pyx_t_8 = __pyx_lineno; __pyx_t_13 = __pyx_clineno; __pyx_t_14 = __pyx_filename;
{
__Pyx_DECREF(__pyx_v_exc);
__pyx_v_exc = NULL;
}
__Pyx_PyThreadState_assign
if (PY_MAJOR_VERSION >= 3) {
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_XGIVEREF(__pyx_t_19);
__Pyx_XGIVEREF(__pyx_t_20);
__Pyx_ExceptionReset(__pyx_t_18, __pyx_t_19, __pyx_t_20);
}
__Pyx_XGIVEREF(__pyx_t_15);
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_ErrRestore(__pyx_t_15, __pyx_t_16, __pyx_t_17);
__pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
__pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_13; __pyx_filename = __pyx_t_14;
goto __pyx_L5_except_error;
}
__pyx_L19:;
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
goto __pyx_L4_exception_handled;
}
goto __pyx_L5_except_error;
__pyx_L5_except_error:;
/* "uvloop/loop.pyx":771
*
* fd = sock.fileno()
* try: # <<<<<<<<<<<<<<
* sock.connect(address)
* except (BlockingIOError, InterruptedError):
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
goto __pyx_L1_error;
__pyx_L4_exception_handled:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
__pyx_L10_try_end:;
}
/* "uvloop/loop.pyx":766
* self._remove_reader(fd)
*
* cdef _sock_connect(self, fut, sock, address): # <<<<<<<<<<<<<<
* cdef:
* Handle handle
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_9);
__Pyx_XDECREF(__pyx_t_10);
__Pyx_XDECREF(__pyx_t_11);
__Pyx_XDECREF(__pyx_t_12);
__Pyx_AddTraceback("uvloop.loop.Loop._sock_connect", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_handle);
__Pyx_XDECREF(__pyx_v_exc);
__Pyx_DECREF(((PyObject *)__pyx_cur_scope));
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":793
* fut.set_result(None)
*
* cdef _sock_connect_cb(self, fut, sock, address): # <<<<<<<<<<<<<<
* if fut.cancelled():
* return
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_connect_cb(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fut, PyObject *__pyx_v_sock, PyObject *__pyx_v_address) {
PyObject *__pyx_v_err = NULL;
PyObject *__pyx_v_exc = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
int __pyx_t_4;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
int __pyx_t_10;
PyObject *__pyx_t_11 = NULL;
PyObject *__pyx_t_12 = NULL;
int __pyx_t_13;
char const *__pyx_t_14;
PyObject *__pyx_t_15 = NULL;
PyObject *__pyx_t_16 = NULL;
PyObject *__pyx_t_17 = NULL;
PyObject *__pyx_t_18 = NULL;
PyObject *__pyx_t_19 = NULL;
PyObject *__pyx_t_20 = NULL;
__Pyx_RefNannySetupContext("_sock_connect_cb", 0);
/* "uvloop/loop.pyx":794
*
* cdef _sock_connect_cb(self, fut, sock, address):
* if fut.cancelled(): # <<<<<<<<<<<<<<
* return
*
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 794, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (__pyx_t_3) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 794, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 794, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 794, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_4) {
/* "uvloop/loop.pyx":795
* cdef _sock_connect_cb(self, fut, sock, address):
* if fut.cancelled():
* return # <<<<<<<<<<<<<<
*
* try:
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
/* "uvloop/loop.pyx":794
*
* cdef _sock_connect_cb(self, fut, sock, address):
* if fut.cancelled(): # <<<<<<<<<<<<<<
* return
*
*/
}
/* "uvloop/loop.pyx":797
* return
*
* try: # <<<<<<<<<<<<<<
* err = sock.getsockopt(uv.SOL_SOCKET, uv.SO_ERROR)
* if err != 0:
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7);
__Pyx_XGOTREF(__pyx_t_5);
__Pyx_XGOTREF(__pyx_t_6);
__Pyx_XGOTREF(__pyx_t_7);
/*try:*/ {
/* "uvloop/loop.pyx":798
*
* try:
* err = sock.getsockopt(uv.SOL_SOCKET, uv.SO_ERROR) # <<<<<<<<<<<<<<
* if err != 0:
* # Jump to any except clause below.
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_getsockopt); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 798, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = __Pyx_PyInt_From_int(SOL_SOCKET); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 798, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_8 = __Pyx_PyInt_From_int(SO_ERROR); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 798, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_8);
__pyx_t_9 = NULL;
__pyx_t_10 = 0;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_9 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_9)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_9);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
__pyx_t_10 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_3, __pyx_t_8};
__pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 798, __pyx_L4_error)
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_t_3, __pyx_t_8};
__pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 798, __pyx_L4_error)
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
} else
#endif
{
__pyx_t_11 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 798, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_11);
if (__pyx_t_9) {
__Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_9); __pyx_t_9 = NULL;
}
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_10, __pyx_t_3);
__Pyx_GIVEREF(__pyx_t_8);
PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_t_8);
__pyx_t_3 = 0;
__pyx_t_8 = 0;
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 798, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_v_err = __pyx_t_1;
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":799
* try:
* err = sock.getsockopt(uv.SOL_SOCKET, uv.SO_ERROR)
* if err != 0: # <<<<<<<<<<<<<<
* # Jump to any except clause below.
* raise OSError(err, 'Connect call failed %s' % (address,))
*/
__pyx_t_1 = PyObject_RichCompare(__pyx_v_err, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 799, __pyx_L4_error)
__pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 799, __pyx_L4_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_4) {
/* "uvloop/loop.pyx":801
* if err != 0:
* # Jump to any except clause below.
* raise OSError(err, 'Connect call failed %s' % (address,)) # <<<<<<<<<<<<<<
* except (BlockingIOError, InterruptedError):
* # socket is still registered, the callback will be retried later
*/
__pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 801, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_address);
__Pyx_GIVEREF(__pyx_v_address);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_address);
__pyx_t_2 = PyUnicode_Format(__pyx_kp_u_Connect_call_failed_s, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 801, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 801, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_err);
__Pyx_GIVEREF(__pyx_v_err);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_err);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_2);
__pyx_t_2 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 801, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__PYX_ERR(1, 801, __pyx_L4_error)
/* "uvloop/loop.pyx":799
* try:
* err = sock.getsockopt(uv.SOL_SOCKET, uv.SO_ERROR)
* if err != 0: # <<<<<<<<<<<<<<
* # Jump to any except clause below.
* raise OSError(err, 'Connect call failed %s' % (address,))
*/
}
/* "uvloop/loop.pyx":797
* return
*
* try: # <<<<<<<<<<<<<<
* err = sock.getsockopt(uv.SOL_SOCKET, uv.SO_ERROR)
* if err != 0:
*/
}
/* "uvloop/loop.pyx":808
* fut.set_exception(exc)
* else:
* fut.set_result(None) # <<<<<<<<<<<<<<
*
* cdef _sock_set_reuseport(self, int fd):
*/
/*else:*/ {
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_set_result); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 808, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__27, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 808, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
goto __pyx_L11_try_end;
__pyx_L4_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":802
* # Jump to any except clause below.
* raise OSError(err, 'Connect call failed %s' % (address,))
* except (BlockingIOError, InterruptedError): # <<<<<<<<<<<<<<
* # socket is still registered, the callback will be retried later
* pass
*/
__pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BlockingIOError) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_InterruptedError);
if (__pyx_t_10) {
__Pyx_ErrRestore(0,0,0);
goto __pyx_L5_exception_handled;
}
/* "uvloop/loop.pyx":805
* # socket is still registered, the callback will be retried later
* pass
* except Exception as exc: # <<<<<<<<<<<<<<
* fut.set_exception(exc)
* else:
*/
__pyx_t_10 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
if (__pyx_t_10) {
__Pyx_AddTraceback("uvloop.loop.Loop._sock_connect_cb", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_11) < 0) __PYX_ERR(1, 805, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GOTREF(__pyx_t_11);
__Pyx_INCREF(__pyx_t_2);
__pyx_v_exc = __pyx_t_2;
/*try:*/ {
/* "uvloop/loop.pyx":806
* pass
* except Exception as exc:
* fut.set_exception(exc) # <<<<<<<<<<<<<<
* else:
* fut.set_result(None)
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_set_exception); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 806, __pyx_L18_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_9 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_9 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_9)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_9);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (!__pyx_t_9) {
__pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_exc); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 806, __pyx_L18_error)
__Pyx_GOTREF(__pyx_t_8);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_v_exc};
__pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 806, __pyx_L18_error)
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_GOTREF(__pyx_t_8);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_v_exc};
__pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 806, __pyx_L18_error)
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_GOTREF(__pyx_t_8);
} else
#endif
{
__pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 806, __pyx_L18_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_9); __pyx_t_9 = NULL;
__Pyx_INCREF(__pyx_v_exc);
__Pyx_GIVEREF(__pyx_v_exc);
PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_v_exc);
__pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_12, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 806, __pyx_L18_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
}
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
}
/* "uvloop/loop.pyx":805
* # socket is still registered, the callback will be retried later
* pass
* except Exception as exc: # <<<<<<<<<<<<<<
* fut.set_exception(exc)
* else:
*/
/*finally:*/ {
/*normal exit:*/{
__Pyx_DECREF(__pyx_v_exc);
__pyx_v_exc = NULL;
goto __pyx_L19;
}
/*exception exit:*/{
__Pyx_PyThreadState_declare
__pyx_L18_error:;
__pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20);
if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17) < 0)) __Pyx_ErrFetch(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_15);
__Pyx_XGOTREF(__pyx_t_16);
__Pyx_XGOTREF(__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_18);
__Pyx_XGOTREF(__pyx_t_19);
__Pyx_XGOTREF(__pyx_t_20);
__pyx_t_10 = __pyx_lineno; __pyx_t_13 = __pyx_clineno; __pyx_t_14 = __pyx_filename;
{
__Pyx_DECREF(__pyx_v_exc);
__pyx_v_exc = NULL;
}
__Pyx_PyThreadState_assign
if (PY_MAJOR_VERSION >= 3) {
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_XGIVEREF(__pyx_t_19);
__Pyx_XGIVEREF(__pyx_t_20);
__Pyx_ExceptionReset(__pyx_t_18, __pyx_t_19, __pyx_t_20);
}
__Pyx_XGIVEREF(__pyx_t_15);
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_ErrRestore(__pyx_t_15, __pyx_t_16, __pyx_t_17);
__pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0;
__pyx_lineno = __pyx_t_10; __pyx_clineno = __pyx_t_13; __pyx_filename = __pyx_t_14;
goto __pyx_L6_except_error;
}
__pyx_L19:;
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
goto __pyx_L5_exception_handled;
}
goto __pyx_L6_except_error;
__pyx_L6_except_error:;
/* "uvloop/loop.pyx":797
* return
*
* try: # <<<<<<<<<<<<<<
* err = sock.getsockopt(uv.SOL_SOCKET, uv.SO_ERROR)
* if err != 0:
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7);
goto __pyx_L1_error;
__pyx_L5_exception_handled:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_ExceptionReset(__pyx_t_5, __pyx_t_6, __pyx_t_7);
__pyx_L11_try_end:;
}
/* "uvloop/loop.pyx":793
* fut.set_result(None)
*
* cdef _sock_connect_cb(self, fut, sock, address): # <<<<<<<<<<<<<<
* if fut.cancelled():
* return
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_XDECREF(__pyx_t_9);
__Pyx_XDECREF(__pyx_t_11);
__Pyx_XDECREF(__pyx_t_12);
__Pyx_AddTraceback("uvloop.loop.Loop._sock_connect_cb", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_err);
__Pyx_XDECREF(__pyx_v_exc);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":810
* fut.set_result(None)
*
* cdef _sock_set_reuseport(self, int fd): # <<<<<<<<<<<<<<
* cdef:
* int err
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__sock_set_reuseport(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, int __pyx_v_fd) {
int __pyx_v_err;
int __pyx_v_reuseport_flag;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
__Pyx_RefNannySetupContext("_sock_set_reuseport", 0);
/* "uvloop/loop.pyx":813
* cdef:
* int err
* int reuseport_flag = 1 # <<<<<<<<<<<<<<
*
* err = system.setsockopt(
*/
__pyx_v_reuseport_flag = 1;
/* "uvloop/loop.pyx":815
* int reuseport_flag = 1
*
* err = system.setsockopt( # <<<<<<<<<<<<<<
* fd,
* uv.SOL_SOCKET,
*/
__pyx_v_err = setsockopt(__pyx_v_fd, SOL_SOCKET, __pyx_v_6uvloop_4loop_SO_REUSEPORT, ((char *)(&__pyx_v_reuseport_flag)), (sizeof(__pyx_v_reuseport_flag)));
/* "uvloop/loop.pyx":822
* sizeof(reuseport_flag))
*
* if err < 0: # <<<<<<<<<<<<<<
* raise convert_error(-errno.errno)
*
*/
__pyx_t_1 = ((__pyx_v_err < 0) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":823
*
* if err < 0:
* raise convert_error(-errno.errno) # <<<<<<<<<<<<<<
*
* cdef _set_coroutine_wrapper(self, bint enabled):
*/
__pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error((-errno)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 823, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__PYX_ERR(1, 823, __pyx_L1_error)
/* "uvloop/loop.pyx":822
* sizeof(reuseport_flag))
*
* if err < 0: # <<<<<<<<<<<<<<
* raise convert_error(-errno.errno)
*
*/
}
/* "uvloop/loop.pyx":810
* fut.set_result(None)
*
* cdef _sock_set_reuseport(self, int fd): # <<<<<<<<<<<<<<
* cdef:
* int err
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_AddTraceback("uvloop.loop.Loop._sock_set_reuseport", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":825
* raise convert_error(-errno.errno)
*
* cdef _set_coroutine_wrapper(self, bint enabled): # <<<<<<<<<<<<<<
* enabled = bool(enabled)
* if self._coroutine_wrapper_set == enabled:
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__set_coroutine_wrapper(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, int __pyx_v_enabled) {
PyObject *__pyx_v_wrapper = NULL;
PyObject *__pyx_v_current_wrapper = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
int __pyx_t_5;
PyObject *__pyx_t_6 = NULL;
int __pyx_t_7;
PyObject *__pyx_t_8 = NULL;
__Pyx_RefNannySetupContext("_set_coroutine_wrapper", 0);
/* "uvloop/loop.pyx":826
*
* cdef _set_coroutine_wrapper(self, bint enabled):
* enabled = bool(enabled) # <<<<<<<<<<<<<<
* if self._coroutine_wrapper_set == enabled:
* return
*/
__pyx_t_1 = __pyx_v_enabled;
__pyx_v_enabled = (!(!__pyx_t_1));
/* "uvloop/loop.pyx":827
* cdef _set_coroutine_wrapper(self, bint enabled):
* enabled = bool(enabled)
* if self._coroutine_wrapper_set == enabled: # <<<<<<<<<<<<<<
* return
*
*/
__pyx_t_1 = ((__pyx_v_self->_coroutine_wrapper_set == __pyx_v_enabled) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":828
* enabled = bool(enabled)
* if self._coroutine_wrapper_set == enabled:
* return # <<<<<<<<<<<<<<
*
* wrapper = aio_debug_wrapper
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
/* "uvloop/loop.pyx":827
* cdef _set_coroutine_wrapper(self, bint enabled):
* enabled = bool(enabled)
* if self._coroutine_wrapper_set == enabled: # <<<<<<<<<<<<<<
* return
*
*/
}
/* "uvloop/loop.pyx":830
* return
*
* wrapper = aio_debug_wrapper # <<<<<<<<<<<<<<
* current_wrapper = sys_get_coroutine_wrapper()
*
*/
__Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_debug_wrapper);
__pyx_v_wrapper = __pyx_v_6uvloop_4loop_aio_debug_wrapper;
/* "uvloop/loop.pyx":831
*
* wrapper = aio_debug_wrapper
* current_wrapper = sys_get_coroutine_wrapper() # <<<<<<<<<<<<<<
*
* if enabled:
*/
__Pyx_INCREF(__pyx_v_6uvloop_4loop_sys_get_coroutine_wrapper);
__pyx_t_3 = __pyx_v_6uvloop_4loop_sys_get_coroutine_wrapper; __pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (__pyx_t_4) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 831, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
__pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 831, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_v_current_wrapper = __pyx_t_2;
__pyx_t_2 = 0;
/* "uvloop/loop.pyx":833
* current_wrapper = sys_get_coroutine_wrapper()
*
* if enabled: # <<<<<<<<<<<<<<
* if current_wrapper not in (None, wrapper):
* warnings.warn(
*/
__pyx_t_1 = (__pyx_v_enabled != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":834
*
* if enabled:
* if current_wrapper not in (None, wrapper): # <<<<<<<<<<<<<<
* warnings.warn(
* "loop.set_debug(True): cannot set debug coroutine "
*/
__Pyx_INCREF(__pyx_v_current_wrapper);
__pyx_t_2 = __pyx_v_current_wrapper;
__pyx_t_3 = PyObject_RichCompare(__pyx_t_2, Py_None, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 834, __pyx_L1_error)
__pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(1, 834, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (__pyx_t_5) {
} else {
__pyx_t_1 = __pyx_t_5;
goto __pyx_L6_bool_binop_done;
}
__pyx_t_3 = PyObject_RichCompare(__pyx_t_2, __pyx_v_wrapper, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 834, __pyx_L1_error)
__pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(1, 834, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_1 = __pyx_t_5;
__pyx_L6_bool_binop_done:;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_5 = (__pyx_t_1 != 0);
if (__pyx_t_5) {
/* "uvloop/loop.pyx":835
* if enabled:
* if current_wrapper not in (None, wrapper):
* warnings.warn( # <<<<<<<<<<<<<<
* "loop.set_debug(True): cannot set debug coroutine "
* "wrapper; another wrapper is already set %r" %
*/
__pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_warnings); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 835, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_warn); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 835, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":837
* warnings.warn(
* "loop.set_debug(True): cannot set debug coroutine "
* "wrapper; another wrapper is already set %r" % # <<<<<<<<<<<<<<
* current_wrapper, RuntimeWarning)
* else:
*/
__pyx_t_3 = PyUnicode_Format(__pyx_kp_u_loop_set_debug_True_cannot_set_d, __pyx_v_current_wrapper); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 837, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
/* "uvloop/loop.pyx":838
* "loop.set_debug(True): cannot set debug coroutine "
* "wrapper; another wrapper is already set %r" %
* current_wrapper, RuntimeWarning) # <<<<<<<<<<<<<<
* else:
* sys_set_coroutine_wrapper(wrapper)
*/
__pyx_t_6 = NULL;
__pyx_t_7 = 0;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
__pyx_t_7 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_builtin_RuntimeWarning};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 835, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_3, __pyx_builtin_RuntimeWarning};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 835, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else
#endif
{
__pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 835, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
if (__pyx_t_6) {
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL;
}
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_3);
__Pyx_INCREF(__pyx_builtin_RuntimeWarning);
__Pyx_GIVEREF(__pyx_builtin_RuntimeWarning);
PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_builtin_RuntimeWarning);
__pyx_t_3 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 835, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":834
*
* if enabled:
* if current_wrapper not in (None, wrapper): # <<<<<<<<<<<<<<
* warnings.warn(
* "loop.set_debug(True): cannot set debug coroutine "
*/
goto __pyx_L5;
}
/* "uvloop/loop.pyx":840
* current_wrapper, RuntimeWarning)
* else:
* sys_set_coroutine_wrapper(wrapper) # <<<<<<<<<<<<<<
* self._coroutine_wrapper_set = True
* else:
*/
/*else*/ {
__Pyx_INCREF(__pyx_v_6uvloop_4loop_sys_set_coroutine_wrapper);
__pyx_t_4 = __pyx_v_6uvloop_4loop_sys_set_coroutine_wrapper; __pyx_t_8 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_8)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_8);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (!__pyx_t_8) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_wrapper); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 840, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_wrapper};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 840, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_wrapper};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 840, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else
#endif
{
__pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 840, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_8); __pyx_t_8 = NULL;
__Pyx_INCREF(__pyx_v_wrapper);
__Pyx_GIVEREF(__pyx_v_wrapper);
PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_v_wrapper);
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 840, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":841
* else:
* sys_set_coroutine_wrapper(wrapper)
* self._coroutine_wrapper_set = True # <<<<<<<<<<<<<<
* else:
* if current_wrapper not in (None, wrapper):
*/
__pyx_v_self->_coroutine_wrapper_set = 1;
}
__pyx_L5:;
/* "uvloop/loop.pyx":833
* current_wrapper = sys_get_coroutine_wrapper()
*
* if enabled: # <<<<<<<<<<<<<<
* if current_wrapper not in (None, wrapper):
* warnings.warn(
*/
goto __pyx_L4;
}
/* "uvloop/loop.pyx":843
* self._coroutine_wrapper_set = True
* else:
* if current_wrapper not in (None, wrapper): # <<<<<<<<<<<<<<
* warnings.warn(
* "loop.set_debug(False): cannot unset debug coroutine "
*/
/*else*/ {
__Pyx_INCREF(__pyx_v_current_wrapper);
__pyx_t_2 = __pyx_v_current_wrapper;
__pyx_t_4 = PyObject_RichCompare(__pyx_t_2, Py_None, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 843, __pyx_L1_error)
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 843, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (__pyx_t_1) {
} else {
__pyx_t_5 = __pyx_t_1;
goto __pyx_L9_bool_binop_done;
}
__pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_v_wrapper, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 843, __pyx_L1_error)
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 843, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_5 = __pyx_t_1;
__pyx_L9_bool_binop_done:;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_1 = (__pyx_t_5 != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":844
* else:
* if current_wrapper not in (None, wrapper):
* warnings.warn( # <<<<<<<<<<<<<<
* "loop.set_debug(False): cannot unset debug coroutine "
* "wrapper; another wrapper was set %r" %
*/
__pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_warnings); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 844, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_warn); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 844, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":846
* warnings.warn(
* "loop.set_debug(False): cannot unset debug coroutine "
* "wrapper; another wrapper was set %r" % # <<<<<<<<<<<<<<
* current_wrapper, RuntimeWarning)
* else:
*/
__pyx_t_4 = PyUnicode_Format(__pyx_kp_u_loop_set_debug_False_cannot_unse, __pyx_v_current_wrapper); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 846, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
/* "uvloop/loop.pyx":847
* "loop.set_debug(False): cannot unset debug coroutine "
* "wrapper; another wrapper was set %r" %
* current_wrapper, RuntimeWarning) # <<<<<<<<<<<<<<
* else:
* sys_set_coroutine_wrapper(None)
*/
__pyx_t_8 = NULL;
__pyx_t_7 = 0;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_8)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_8);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
__pyx_t_7 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_4, __pyx_builtin_RuntimeWarning};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 844, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_4, __pyx_builtin_RuntimeWarning};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 844, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
{
__pyx_t_6 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 844, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
if (__pyx_t_8) {
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_8); __pyx_t_8 = NULL;
}
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_7, __pyx_t_4);
__Pyx_INCREF(__pyx_builtin_RuntimeWarning);
__Pyx_GIVEREF(__pyx_builtin_RuntimeWarning);
PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_7, __pyx_builtin_RuntimeWarning);
__pyx_t_4 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 844, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":843
* self._coroutine_wrapper_set = True
* else:
* if current_wrapper not in (None, wrapper): # <<<<<<<<<<<<<<
* warnings.warn(
* "loop.set_debug(False): cannot unset debug coroutine "
*/
goto __pyx_L8;
}
/* "uvloop/loop.pyx":849
* current_wrapper, RuntimeWarning)
* else:
* sys_set_coroutine_wrapper(None) # <<<<<<<<<<<<<<
* self._coroutine_wrapper_set = False
*
*/
/*else*/ {
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_v_6uvloop_4loop_sys_set_coroutine_wrapper, __pyx_tuple__28, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 849, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":850
* else:
* sys_set_coroutine_wrapper(None)
* self._coroutine_wrapper_set = False # <<<<<<<<<<<<<<
*
* cdef _create_server(self, system.sockaddr *addr,
*/
__pyx_v_self->_coroutine_wrapper_set = 0;
}
__pyx_L8:;
}
__pyx_L4:;
/* "uvloop/loop.pyx":825
* raise convert_error(-errno.errno)
*
* cdef _set_coroutine_wrapper(self, bint enabled): # <<<<<<<<<<<<<<
* enabled = bool(enabled)
* if self._coroutine_wrapper_set == enabled:
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_AddTraceback("uvloop.loop.Loop._set_coroutine_wrapper", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_wrapper);
__Pyx_XDECREF(__pyx_v_current_wrapper);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":852
* self._coroutine_wrapper_set = False
*
* cdef _create_server(self, system.sockaddr *addr, # <<<<<<<<<<<<<<
* object protocol_factory,
* Server server,
*/
static PyObject *__pyx_f_6uvloop_4loop_4Loop__create_server(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, struct sockaddr *__pyx_v_addr, PyObject *__pyx_v_protocol_factory, struct __pyx_obj_6uvloop_4loop_Server *__pyx_v_server, PyObject *__pyx_v_ssl, int __pyx_v_reuse_port, PyObject *__pyx_v_backlog) {
struct __pyx_obj_6uvloop_4loop_TCPServer *__pyx_v_tcp = 0;
int __pyx_v_bind_flags;
PyObject *__pyx_v_err = NULL;
PyObject *__pyx_v_pyaddr = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_t_2;
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
struct __pyx_opt_args_6uvloop_4loop_9TCPServer_bind __pyx_t_7;
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
PyObject *__pyx_t_10 = NULL;
PyObject *__pyx_t_11 = NULL;
PyObject *__pyx_t_12 = NULL;
PyObject *__pyx_t_13 = NULL;
int __pyx_t_14;
char const *__pyx_t_15;
PyObject *__pyx_t_16 = NULL;
PyObject *__pyx_t_17 = NULL;
PyObject *__pyx_t_18 = NULL;
PyObject *__pyx_t_19 = NULL;
PyObject *__pyx_t_20 = NULL;
PyObject *__pyx_t_21 = NULL;
__Pyx_RefNannySetupContext("_create_server", 0);
/* "uvloop/loop.pyx":862
* int bind_flags
*
* tcp = TCPServer.new(self, protocol_factory, server, ssl, # <<<<<<<<<<<<<<
* addr.sa_family)
*
*/
__pyx_t_1 = ((PyObject *)__pyx_f_6uvloop_4loop_9TCPServer_new(__pyx_v_self, __pyx_v_protocol_factory, __pyx_v_server, __pyx_v_ssl, __pyx_v_addr->sa_family)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 862, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_tcp = ((struct __pyx_obj_6uvloop_4loop_TCPServer *)__pyx_t_1);
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":865
* addr.sa_family)
*
* if reuse_port: # <<<<<<<<<<<<<<
* self._sock_set_reuseport(tcp._fileno())
*
*/
__pyx_t_2 = (__pyx_v_reuse_port != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":866
*
* if reuse_port:
* self._sock_set_reuseport(tcp._fileno()) # <<<<<<<<<<<<<<
*
* if addr.sa_family == uv.AF_INET6:
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPServer *)__pyx_v_tcp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._fileno(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_v_tcp)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 866, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 866, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_sock_set_reuseport(__pyx_v_self, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 866, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":865
* addr.sa_family)
*
* if reuse_port: # <<<<<<<<<<<<<<
* self._sock_set_reuseport(tcp._fileno())
*
*/
}
/* "uvloop/loop.pyx":868
* self._sock_set_reuseport(tcp._fileno())
*
* if addr.sa_family == uv.AF_INET6: # <<<<<<<<<<<<<<
* # Disable IPv4/IPv6 dual stack support (enabled by
* # default on Linux) which makes a single socket
*/
__pyx_t_2 = ((__pyx_v_addr->sa_family == AF_INET6) != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":872
* # default on Linux) which makes a single socket
* # listen on both address families.
* bind_flags = uv.UV_TCP_IPV6ONLY # <<<<<<<<<<<<<<
* else:
* bind_flags = 0
*/
__pyx_v_bind_flags = UV_TCP_IPV6ONLY;
/* "uvloop/loop.pyx":868
* self._sock_set_reuseport(tcp._fileno())
*
* if addr.sa_family == uv.AF_INET6: # <<<<<<<<<<<<<<
* # Disable IPv4/IPv6 dual stack support (enabled by
* # default on Linux) which makes a single socket
*/
goto __pyx_L4;
}
/* "uvloop/loop.pyx":874
* bind_flags = uv.UV_TCP_IPV6ONLY
* else:
* bind_flags = 0 # <<<<<<<<<<<<<<
*
* try:
*/
/*else*/ {
__pyx_v_bind_flags = 0;
}
__pyx_L4:;
/* "uvloop/loop.pyx":876
* bind_flags = 0
*
* try: # <<<<<<<<<<<<<<
* tcp.bind(addr, bind_flags)
* tcp.listen(backlog)
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6);
__Pyx_XGOTREF(__pyx_t_4);
__Pyx_XGOTREF(__pyx_t_5);
__Pyx_XGOTREF(__pyx_t_6);
/*try:*/ {
/* "uvloop/loop.pyx":877
*
* try:
* tcp.bind(addr, bind_flags) # <<<<<<<<<<<<<<
* tcp.listen(backlog)
* except OSError as err:
*/
__pyx_t_7.__pyx_n = 1;
__pyx_t_7.flags = __pyx_v_bind_flags;
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPServer *)__pyx_v_tcp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->bind(__pyx_v_tcp, __pyx_v_addr, &__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 877, __pyx_L5_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":878
* try:
* tcp.bind(addr, bind_flags)
* tcp.listen(backlog) # <<<<<<<<<<<<<<
* except OSError as err:
* pyaddr = __convert_sockaddr_to_pyaddr(addr)
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPServer *)__pyx_v_tcp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.listen(((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)__pyx_v_tcp), __pyx_v_backlog); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 878, __pyx_L5_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":876
* bind_flags = 0
*
* try: # <<<<<<<<<<<<<<
* tcp.bind(addr, bind_flags)
* tcp.listen(backlog)
*/
}
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
goto __pyx_L12_try_end;
__pyx_L5_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":879
* tcp.bind(addr, bind_flags)
* tcp.listen(backlog)
* except OSError as err: # <<<<<<<<<<<<<<
* pyaddr = __convert_sockaddr_to_pyaddr(addr)
* tcp._close()
*/
__pyx_t_3 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_OSError);
if (__pyx_t_3) {
__Pyx_AddTraceback("uvloop.loop.Loop._create_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_8, &__pyx_t_9) < 0) __PYX_ERR(1, 879, __pyx_L7_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_8);
__Pyx_GOTREF(__pyx_t_9);
__Pyx_INCREF(__pyx_t_8);
__pyx_v_err = __pyx_t_8;
/*try:*/ {
/* "uvloop/loop.pyx":880
* tcp.listen(backlog)
* except OSError as err:
* pyaddr = __convert_sockaddr_to_pyaddr(addr) # <<<<<<<<<<<<<<
* tcp._close()
* raise OSError(err.errno, 'error while attempting '
*/
__pyx_t_10 = __pyx_f_6uvloop_4loop___convert_sockaddr_to_pyaddr(__pyx_v_addr); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 880, __pyx_L18_error)
__Pyx_GOTREF(__pyx_t_10);
__pyx_v_pyaddr = __pyx_t_10;
__pyx_t_10 = 0;
/* "uvloop/loop.pyx":881
* except OSError as err:
* pyaddr = __convert_sockaddr_to_pyaddr(addr)
* tcp._close() # <<<<<<<<<<<<<<
* raise OSError(err.errno, 'error while attempting '
* 'to bind on address %r: %s'
*/
__pyx_t_10 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPServer *)__pyx_v_tcp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_tcp)); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 881, __pyx_L18_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
/* "uvloop/loop.pyx":882
* pyaddr = __convert_sockaddr_to_pyaddr(addr)
* tcp._close()
* raise OSError(err.errno, 'error while attempting ' # <<<<<<<<<<<<<<
* 'to bind on address %r: %s'
* % (pyaddr, err.strerror.lower()))
*/
__pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_err, __pyx_n_s_errno); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 882, __pyx_L18_error)
__Pyx_GOTREF(__pyx_t_10);
/* "uvloop/loop.pyx":884
* raise OSError(err.errno, 'error while attempting '
* 'to bind on address %r: %s'
* % (pyaddr, err.strerror.lower())) # <<<<<<<<<<<<<<
* except:
* tcp._close()
*/
__pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_v_err, __pyx_n_s_strerror); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 884, __pyx_L18_error)
__Pyx_GOTREF(__pyx_t_12);
__pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_n_s_lower); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 884, __pyx_L18_error)
__Pyx_GOTREF(__pyx_t_13);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
__pyx_t_12 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) {
__pyx_t_12 = PyMethod_GET_SELF(__pyx_t_13);
if (likely(__pyx_t_12)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13);
__Pyx_INCREF(__pyx_t_12);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_13, function);
}
}
if (__pyx_t_12) {
__pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_12); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 884, __pyx_L18_error)
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
} else {
__pyx_t_11 = __Pyx_PyObject_CallNoArg(__pyx_t_13); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 884, __pyx_L18_error)
}
__Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
__pyx_t_13 = PyTuple_New(2); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 884, __pyx_L18_error)
__Pyx_GOTREF(__pyx_t_13);
__Pyx_INCREF(__pyx_v_pyaddr);
__Pyx_GIVEREF(__pyx_v_pyaddr);
PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_v_pyaddr);
__Pyx_GIVEREF(__pyx_t_11);
PyTuple_SET_ITEM(__pyx_t_13, 1, __pyx_t_11);
__pyx_t_11 = 0;
__pyx_t_11 = PyUnicode_Format(__pyx_kp_u_error_while_attempting_to_bind_o, __pyx_t_13); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 884, __pyx_L18_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
/* "uvloop/loop.pyx":882
* pyaddr = __convert_sockaddr_to_pyaddr(addr)
* tcp._close()
* raise OSError(err.errno, 'error while attempting ' # <<<<<<<<<<<<<<
* 'to bind on address %r: %s'
* % (pyaddr, err.strerror.lower()))
*/
__pyx_t_13 = PyTuple_New(2); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 882, __pyx_L18_error)
__Pyx_GOTREF(__pyx_t_13);
__Pyx_GIVEREF(__pyx_t_10);
PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_10);
__Pyx_GIVEREF(__pyx_t_11);
PyTuple_SET_ITEM(__pyx_t_13, 1, __pyx_t_11);
__pyx_t_10 = 0;
__pyx_t_11 = 0;
__pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_13, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 882, __pyx_L18_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
__Pyx_Raise(__pyx_t_11, 0, 0, 0);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__PYX_ERR(1, 882, __pyx_L18_error)
}
/* "uvloop/loop.pyx":879
* tcp.bind(addr, bind_flags)
* tcp.listen(backlog)
* except OSError as err: # <<<<<<<<<<<<<<
* pyaddr = __convert_sockaddr_to_pyaddr(addr)
* tcp._close()
*/
/*finally:*/ {
/*exception exit:*/{
__Pyx_PyThreadState_declare
__pyx_L18_error:;
__pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_19, &__pyx_t_20, &__pyx_t_21);
if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18) < 0)) __Pyx_ErrFetch(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
__Pyx_XGOTREF(__pyx_t_16);
__Pyx_XGOTREF(__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_18);
__Pyx_XGOTREF(__pyx_t_19);
__Pyx_XGOTREF(__pyx_t_20);
__Pyx_XGOTREF(__pyx_t_21);
__pyx_t_3 = __pyx_lineno; __pyx_t_14 = __pyx_clineno; __pyx_t_15 = __pyx_filename;
{
__Pyx_DECREF(__pyx_v_err);
__pyx_v_err = NULL;
}
__Pyx_PyThreadState_assign
if (PY_MAJOR_VERSION >= 3) {
__Pyx_XGIVEREF(__pyx_t_19);
__Pyx_XGIVEREF(__pyx_t_20);
__Pyx_XGIVEREF(__pyx_t_21);
__Pyx_ExceptionReset(__pyx_t_19, __pyx_t_20, __pyx_t_21);
}
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_ErrRestore(__pyx_t_16, __pyx_t_17, __pyx_t_18);
__pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0;
__pyx_lineno = __pyx_t_3; __pyx_clineno = __pyx_t_14; __pyx_filename = __pyx_t_15;
goto __pyx_L7_except_error;
}
}
}
/* "uvloop/loop.pyx":885
* 'to bind on address %r: %s'
* % (pyaddr, err.strerror.lower()))
* except: # <<<<<<<<<<<<<<
* tcp._close()
* raise
*/
/*except:*/ {
__Pyx_AddTraceback("uvloop.loop.Loop._create_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_8, &__pyx_t_1) < 0) __PYX_ERR(1, 885, __pyx_L7_except_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_GOTREF(__pyx_t_8);
__Pyx_GOTREF(__pyx_t_1);
/* "uvloop/loop.pyx":886
* % (pyaddr, err.strerror.lower()))
* except:
* tcp._close() # <<<<<<<<<<<<<<
* raise
*
*/
__pyx_t_11 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPServer *)__pyx_v_tcp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_tcp)); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 886, __pyx_L7_except_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
/* "uvloop/loop.pyx":887
* except:
* tcp._close()
* raise # <<<<<<<<<<<<<<
*
* return tcp
*/
__Pyx_GIVEREF(__pyx_t_9);
__Pyx_GIVEREF(__pyx_t_8);
__Pyx_XGIVEREF(__pyx_t_1);
__Pyx_ErrRestoreWithState(__pyx_t_9, __pyx_t_8, __pyx_t_1);
__pyx_t_9 = 0; __pyx_t_8 = 0; __pyx_t_1 = 0;
__PYX_ERR(1, 887, __pyx_L7_except_error)
}
__pyx_L7_except_error:;
/* "uvloop/loop.pyx":876
* bind_flags = 0
*
* try: # <<<<<<<<<<<<<<
* tcp.bind(addr, bind_flags)
* tcp.listen(backlog)
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
goto __pyx_L1_error;
__pyx_L12_try_end:;
}
/* "uvloop/loop.pyx":889
* raise
*
* return tcp # <<<<<<<<<<<<<<
*
* def _get_backend_id(self):
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(((PyObject *)__pyx_v_tcp));
__pyx_r = ((PyObject *)__pyx_v_tcp);
goto __pyx_L0;
/* "uvloop/loop.pyx":852
* self._coroutine_wrapper_set = False
*
* cdef _create_server(self, system.sockaddr *addr, # <<<<<<<<<<<<<<
* object protocol_factory,
* Server server,
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_XDECREF(__pyx_t_9);
__Pyx_XDECREF(__pyx_t_10);
__Pyx_XDECREF(__pyx_t_11);
__Pyx_XDECREF(__pyx_t_12);
__Pyx_XDECREF(__pyx_t_13);
__Pyx_AddTraceback("uvloop.loop.Loop._create_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_tcp);
__Pyx_XDECREF(__pyx_v_err);
__Pyx_XDECREF(__pyx_v_pyaddr);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":891
* return tcp
*
* def _get_backend_id(self): # <<<<<<<<<<<<<<
* """This method is used by uvloop tests and is not part of the API."""
* return uv.uv_backend_fd(self.uvloop)
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_7_get_backend_id(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_6_get_backend_id[] = "Loop._get_backend_id(self)\nThis method is used by uvloop tests and is not part of the API.";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_7_get_backend_id(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("_get_backend_id (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_6_get_backend_id(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_6_get_backend_id(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("_get_backend_id", 0);
/* "uvloop/loop.pyx":893
* def _get_backend_id(self):
* """This method is used by uvloop tests and is not part of the API."""
* return uv.uv_backend_fd(self.uvloop) # <<<<<<<<<<<<<<
*
* def print_debug_info(self):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_int(uv_backend_fd(__pyx_v_self->uvloop)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 893, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* "uvloop/loop.pyx":891
* return tcp
*
* def _get_backend_id(self): # <<<<<<<<<<<<<<
* """This method is used by uvloop tests and is not part of the API."""
* return uv.uv_backend_fd(self.uvloop)
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._get_backend_id", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":895
* return uv.uv_backend_fd(self.uvloop)
*
* def print_debug_info(self): # <<<<<<<<<<<<<<
* cdef:
* int err
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_9print_debug_info(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_8print_debug_info[] = "Loop.print_debug_info(self)";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_9print_debug_info(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("print_debug_info (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_8print_debug_info(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_8print_debug_info(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
int __pyx_v_err;
uv_rusage_t __pyx_v_rusage;
PyObject *__pyx_v_name = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
int __pyx_t_7;
PyObject *__pyx_t_8 = NULL;
int __pyx_t_9;
Py_ssize_t __pyx_t_10;
PyObject *__pyx_t_11 = NULL;
PyObject *__pyx_t_12 = NULL;
__Pyx_RefNannySetupContext("print_debug_info", 0);
/* "uvloop/loop.pyx":900
* uv.uv_rusage_t rusage
*
* if not UVLOOP_DEBUG: # <<<<<<<<<<<<<<
* raise NotImplementedError
*
*/
__pyx_t_1 = ((!(UVLOOP_DEBUG != 0)) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":901
*
* if not UVLOOP_DEBUG:
* raise NotImplementedError # <<<<<<<<<<<<<<
*
* err = uv.uv_getrusage(&rusage)
*/
__Pyx_Raise(__pyx_builtin_NotImplementedError, 0, 0, 0);
__PYX_ERR(1, 901, __pyx_L1_error)
/* "uvloop/loop.pyx":900
* uv.uv_rusage_t rusage
*
* if not UVLOOP_DEBUG: # <<<<<<<<<<<<<<
* raise NotImplementedError
*
*/
}
/* "uvloop/loop.pyx":903
* raise NotImplementedError
*
* err = uv.uv_getrusage(&rusage) # <<<<<<<<<<<<<<
* if err < 0:
* raise convert_error(err)
*/
__pyx_v_err = uv_getrusage((&__pyx_v_rusage));
/* "uvloop/loop.pyx":904
*
* err = uv.uv_getrusage(&rusage)
* if err < 0: # <<<<<<<<<<<<<<
* raise convert_error(err)
*
*/
__pyx_t_1 = ((__pyx_v_err < 0) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":905
* err = uv.uv_getrusage(&rusage)
* if err < 0:
* raise convert_error(err) # <<<<<<<<<<<<<<
*
* ################### OS
*/
__pyx_t_2 = __pyx_f_6uvloop_4loop_convert_error(__pyx_v_err); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 905, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__PYX_ERR(1, 905, __pyx_L1_error)
/* "uvloop/loop.pyx":904
*
* err = uv.uv_getrusage(&rusage)
* if err < 0: # <<<<<<<<<<<<<<
* raise convert_error(err)
*
*/
}
/* "uvloop/loop.pyx":909
* ################### OS
*
* print('---- Process info: -----') # <<<<<<<<<<<<<<
* print('Process memory: {}'.format(rusage.ru_maxrss))
* print('Number of signals: {}'.format(rusage.ru_nsignals))
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__29, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 909, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":910
*
* print('---- Process info: -----')
* print('Process memory: {}'.format(rusage.ru_maxrss)) # <<<<<<<<<<<<<<
* print('Number of signals: {}'.format(rusage.ru_nsignals))
* print('')
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Process_memory, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 910, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = __Pyx_PyInt_From_uint64_t(__pyx_v_rusage.ru_maxrss); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 910, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (!__pyx_t_5) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 910, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 910, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 910, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
{
__pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 910, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_4);
__pyx_t_4 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 910, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 910, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
__pyx_t_2 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 910, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":911
* print('---- Process info: -----')
* print('Process memory: {}'.format(rusage.ru_maxrss))
* print('Number of signals: {}'.format(rusage.ru_nsignals)) # <<<<<<<<<<<<<<
* print('')
*
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Number_of_signals, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 911, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_6 = __Pyx_PyInt_From_uint64_t(__pyx_v_rusage.ru_nsignals); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 911, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (!__pyx_t_4) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 911, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_6};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 911, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_6};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 911, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else
#endif
{
__pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 911, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_6);
__pyx_t_6 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 911, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 911, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
__pyx_t_2 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 911, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":912
* print('Process memory: {}'.format(rusage.ru_maxrss))
* print('Number of signals: {}'.format(rusage.ru_nsignals))
* print('') # <<<<<<<<<<<<<<
*
* ################### Loop
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__31, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 912, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":916
* ################### Loop
*
* print('--- Loop debug info: ---') # <<<<<<<<<<<<<<
* print('Loop time: {}'.format(self.time()))
* print('Errors logged: {}'.format(
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__32, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 916, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":917
*
* print('--- Loop debug info: ---')
* print('Loop time: {}'.format(self.time())) # <<<<<<<<<<<<<<
* print('Errors logged: {}'.format(
* self._debug_exception_handler_cnt))
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Loop_time, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 917, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_time); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 917, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_6, function);
}
}
if (__pyx_t_4) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 917, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
__pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 917, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (!__pyx_t_6) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 917, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 917, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 917, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else
#endif
{
__pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 917, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 917, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 917, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
__pyx_t_2 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 917, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":918
* print('--- Loop debug info: ---')
* print('Loop time: {}'.format(self.time()))
* print('Errors logged: {}'.format( # <<<<<<<<<<<<<<
* self._debug_exception_handler_cnt))
* print()
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Errors_logged, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 918, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
/* "uvloop/loop.pyx":919
* print('Loop time: {}'.format(self.time()))
* print('Errors logged: {}'.format(
* self._debug_exception_handler_cnt)) # <<<<<<<<<<<<<<
* print()
* print('Callback handles: {: <8} | {}'.format(
*/
__pyx_t_4 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_exception_handler_cnt); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 919, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (!__pyx_t_5) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 918, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 918, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_4};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 918, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
{
__pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 918, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_4);
__pyx_t_4 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 918, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":918
* print('--- Loop debug info: ---')
* print('Loop time: {}'.format(self.time()))
* print('Errors logged: {}'.format( # <<<<<<<<<<<<<<
* self._debug_exception_handler_cnt))
* print()
*/
__pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 918, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
__pyx_t_2 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 918, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":920
* print('Errors logged: {}'.format(
* self._debug_exception_handler_cnt))
* print() # <<<<<<<<<<<<<<
* print('Callback handles: {: <8} | {}'.format(
* self._debug_cb_handles_count,
*/
__pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_builtin_print); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 920, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":921
* self._debug_exception_handler_cnt))
* print()
* print('Callback handles: {: <8} | {}'.format( # <<<<<<<<<<<<<<
* self._debug_cb_handles_count,
* self._debug_cb_handles_total))
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Callback_handles_8, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 921, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
/* "uvloop/loop.pyx":922
* print()
* print('Callback handles: {: <8} | {}'.format(
* self._debug_cb_handles_count, # <<<<<<<<<<<<<<
* self._debug_cb_handles_total))
* print('Timer handles: {: <8} | {}'.format(
*/
__pyx_t_6 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_cb_handles_count); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 922, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
/* "uvloop/loop.pyx":923
* print('Callback handles: {: <8} | {}'.format(
* self._debug_cb_handles_count,
* self._debug_cb_handles_total)) # <<<<<<<<<<<<<<
* print('Timer handles: {: <8} | {}'.format(
* self._debug_cb_timer_handles_count,
*/
__pyx_t_4 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_cb_handles_total); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 923, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
__pyx_t_7 = 0;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
__pyx_t_7 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_6, __pyx_t_4};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 921, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_6, __pyx_t_4};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 921, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
{
__pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 921, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
if (__pyx_t_5) {
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL;
}
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_6);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_t_4);
__pyx_t_6 = 0;
__pyx_t_4 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 921, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":921
* self._debug_exception_handler_cnt))
* print()
* print('Callback handles: {: <8} | {}'.format( # <<<<<<<<<<<<<<
* self._debug_cb_handles_count,
* self._debug_cb_handles_total))
*/
__pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 921, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
__pyx_t_2 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 921, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":924
* self._debug_cb_handles_count,
* self._debug_cb_handles_total))
* print('Timer handles: {: <8} | {}'.format( # <<<<<<<<<<<<<<
* self._debug_cb_timer_handles_count,
* self._debug_cb_timer_handles_total))
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Timer_handles_8, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 924, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
/* "uvloop/loop.pyx":925
* self._debug_cb_handles_total))
* print('Timer handles: {: <8} | {}'.format(
* self._debug_cb_timer_handles_count, # <<<<<<<<<<<<<<
* self._debug_cb_timer_handles_total))
* print()
*/
__pyx_t_8 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_cb_timer_handles_count); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 925, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
/* "uvloop/loop.pyx":926
* print('Timer handles: {: <8} | {}'.format(
* self._debug_cb_timer_handles_count,
* self._debug_cb_timer_handles_total)) # <<<<<<<<<<<<<<
* print()
*
*/
__pyx_t_4 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_cb_timer_handles_total); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 926, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_6 = NULL;
__pyx_t_7 = 0;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
__pyx_t_7 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_8, __pyx_t_4};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 924, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_t_8, __pyx_t_4};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 924, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
{
__pyx_t_5 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 924, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
if (__pyx_t_6) {
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6); __pyx_t_6 = NULL;
}
__Pyx_GIVEREF(__pyx_t_8);
PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_7, __pyx_t_8);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_7, __pyx_t_4);
__pyx_t_8 = 0;
__pyx_t_4 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 924, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":924
* self._debug_cb_handles_count,
* self._debug_cb_handles_total))
* print('Timer handles: {: <8} | {}'.format( # <<<<<<<<<<<<<<
* self._debug_cb_timer_handles_count,
* self._debug_cb_timer_handles_total))
*/
__pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 924, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
__pyx_t_2 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 924, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":927
* self._debug_cb_timer_handles_count,
* self._debug_cb_timer_handles_total))
* print() # <<<<<<<<<<<<<<
*
* print(' alive | closed |')
*/
__pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_builtin_print); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 927, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":929
* print()
*
* print(' alive | closed |') # <<<<<<<<<<<<<<
* print('UVHandles python | libuv | total')
* print(' objs | handles |')
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__33, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 929, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":930
*
* print(' alive | closed |')
* print('UVHandles python | libuv | total') # <<<<<<<<<<<<<<
* print(' objs | handles |')
* print('-------------------------------+---------+---------')
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__34, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 930, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":931
* print(' alive | closed |')
* print('UVHandles python | libuv | total')
* print(' objs | handles |') # <<<<<<<<<<<<<<
* print('-------------------------------+---------+---------')
* for name in sorted(self._debug_handles_total):
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__35, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 931, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":932
* print('UVHandles python | libuv | total')
* print(' objs | handles |')
* print('-------------------------------+---------+---------') # <<<<<<<<<<<<<<
* for name in sorted(self._debug_handles_total):
* print(' {: <18} {: >7} | {: >7} | {: >7}'.format(
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__37, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 932, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":933
* print(' objs | handles |')
* print('-------------------------------+---------+---------')
* for name in sorted(self._debug_handles_total): # <<<<<<<<<<<<<<
* print(' {: <18} {: >7} | {: >7} | {: >7}'.format(
* name,
*/
__pyx_t_3 = __pyx_v_self->_debug_handles_total;
__Pyx_INCREF(__pyx_t_3);
__pyx_t_5 = PySequence_List(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 933, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_2 = ((PyObject*)__pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_9 = PyList_Sort(__pyx_t_2); if (unlikely(__pyx_t_9 == -1)) __PYX_ERR(1, 933, __pyx_L1_error)
if (unlikely(__pyx_t_2 == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
__PYX_ERR(1, 933, __pyx_L1_error)
}
__pyx_t_5 = __pyx_t_2; __Pyx_INCREF(__pyx_t_5); __pyx_t_10 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
for (;;) {
if (__pyx_t_10 >= PyList_GET_SIZE(__pyx_t_5)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_2 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_10); __Pyx_INCREF(__pyx_t_2); __pyx_t_10++; if (unlikely(0 < 0)) __PYX_ERR(1, 933, __pyx_L1_error)
#else
__pyx_t_2 = PySequence_ITEM(__pyx_t_5, __pyx_t_10); __pyx_t_10++; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 933, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
__Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_2);
__pyx_t_2 = 0;
/* "uvloop/loop.pyx":934
* print('-------------------------------+---------+---------')
* for name in sorted(self._debug_handles_total):
* print(' {: <18} {: >7} | {: >7} | {: >7}'.format( # <<<<<<<<<<<<<<
* name,
* self._debug_handles_current[name],
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_18_7_7_7, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 934, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
/* "uvloop/loop.pyx":936
* print(' {: <18} {: >7} | {: >7} | {: >7}'.format(
* name,
* self._debug_handles_current[name], # <<<<<<<<<<<<<<
* self._debug_handles_closed[name],
* self._debug_handles_total[name]))
*/
__pyx_t_4 = PyObject_GetItem(__pyx_v_self->_debug_handles_current, __pyx_v_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 936, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
/* "uvloop/loop.pyx":937
* name,
* self._debug_handles_current[name],
* self._debug_handles_closed[name], # <<<<<<<<<<<<<<
* self._debug_handles_total[name]))
* print()
*/
__pyx_t_8 = PyObject_GetItem(__pyx_v_self->_debug_handles_closed, __pyx_v_name); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 937, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
/* "uvloop/loop.pyx":938
* self._debug_handles_current[name],
* self._debug_handles_closed[name],
* self._debug_handles_total[name])) # <<<<<<<<<<<<<<
* print()
*
*/
__pyx_t_6 = PyObject_GetItem(__pyx_v_self->_debug_handles_total, __pyx_v_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 938, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_11 = NULL;
__pyx_t_7 = 0;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_11 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_11)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_11);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
__pyx_t_7 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[5] = {__pyx_t_11, __pyx_v_name, __pyx_t_4, __pyx_t_8, __pyx_t_6};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 4+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 934, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[5] = {__pyx_t_11, __pyx_v_name, __pyx_t_4, __pyx_t_8, __pyx_t_6};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 4+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 934, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else
#endif
{
__pyx_t_12 = PyTuple_New(4+__pyx_t_7); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 934, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
if (__pyx_t_11) {
__Pyx_GIVEREF(__pyx_t_11); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_11); __pyx_t_11 = NULL;
}
__Pyx_INCREF(__pyx_v_name);
__Pyx_GIVEREF(__pyx_v_name);
PyTuple_SET_ITEM(__pyx_t_12, 0+__pyx_t_7, __pyx_v_name);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_7, __pyx_t_4);
__Pyx_GIVEREF(__pyx_t_8);
PyTuple_SET_ITEM(__pyx_t_12, 2+__pyx_t_7, __pyx_t_8);
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_12, 3+__pyx_t_7, __pyx_t_6);
__pyx_t_4 = 0;
__pyx_t_8 = 0;
__pyx_t_6 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_12, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 934, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":934
* print('-------------------------------+---------+---------')
* for name in sorted(self._debug_handles_total):
* print(' {: <18} {: >7} | {: >7} | {: >7}'.format( # <<<<<<<<<<<<<<
* name,
* self._debug_handles_current[name],
*/
__pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 934, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
__pyx_t_2 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 934, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":933
* print(' objs | handles |')
* print('-------------------------------+---------+---------')
* for name in sorted(self._debug_handles_total): # <<<<<<<<<<<<<<
* print(' {: <18} {: >7} | {: >7} | {: >7}'.format(
* name,
*/
}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":939
* self._debug_handles_closed[name],
* self._debug_handles_total[name]))
* print() # <<<<<<<<<<<<<<
*
* print('uv_handle_t (current: {}; freed: {}; total: {})'.format(
*/
__pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_builtin_print); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 939, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":941
* print()
*
* print('uv_handle_t (current: {}; freed: {}; total: {})'.format( # <<<<<<<<<<<<<<
* self._debug_uv_handles_total - self._debug_uv_handles_freed,
* self._debug_uv_handles_freed,
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_uv_handle_t_current_freed_total, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 941, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
/* "uvloop/loop.pyx":942
*
* print('uv_handle_t (current: {}; freed: {}; total: {})'.format(
* self._debug_uv_handles_total - self._debug_uv_handles_freed, # <<<<<<<<<<<<<<
* self._debug_uv_handles_freed,
* self._debug_uv_handles_total))
*/
__pyx_t_3 = __Pyx_PyInt_From_uint64_t((__pyx_v_self->_debug_uv_handles_total - __pyx_v_self->_debug_uv_handles_freed)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 942, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
/* "uvloop/loop.pyx":943
* print('uv_handle_t (current: {}; freed: {}; total: {})'.format(
* self._debug_uv_handles_total - self._debug_uv_handles_freed,
* self._debug_uv_handles_freed, # <<<<<<<<<<<<<<
* self._debug_uv_handles_total))
* print()
*/
__pyx_t_12 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_uv_handles_freed); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 943, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
/* "uvloop/loop.pyx":944
* self._debug_uv_handles_total - self._debug_uv_handles_freed,
* self._debug_uv_handles_freed,
* self._debug_uv_handles_total)) # <<<<<<<<<<<<<<
* print()
*
*/
__pyx_t_6 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_uv_handles_total); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 944, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_8 = NULL;
__pyx_t_7 = 0;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_8)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_8);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
__pyx_t_7 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_t_3, __pyx_t_12, __pyx_t_6};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 941, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_t_3, __pyx_t_12, __pyx_t_6};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 941, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else
#endif
{
__pyx_t_4 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 941, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
if (__pyx_t_8) {
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_8); __pyx_t_8 = NULL;
}
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_7, __pyx_t_3);
__Pyx_GIVEREF(__pyx_t_12);
PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_7, __pyx_t_12);
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_4, 2+__pyx_t_7, __pyx_t_6);
__pyx_t_3 = 0;
__pyx_t_12 = 0;
__pyx_t_6 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 941, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":941
* print()
*
* print('uv_handle_t (current: {}; freed: {}; total: {})'.format( # <<<<<<<<<<<<<<
* self._debug_uv_handles_total - self._debug_uv_handles_freed,
* self._debug_uv_handles_freed,
*/
__pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 941, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 941, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":945
* self._debug_uv_handles_freed,
* self._debug_uv_handles_total))
* print() # <<<<<<<<<<<<<<
*
* print('--- Streams debug info: ---')
*/
__pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_builtin_print); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 945, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":947
* print()
*
* print('--- Streams debug info: ---') # <<<<<<<<<<<<<<
* print('Write errors: {}'.format(
* self._debug_stream_write_errors_total))
*/
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__38, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 947, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":948
*
* print('--- Streams debug info: ---')
* print('Write errors: {}'.format( # <<<<<<<<<<<<<<
* self._debug_stream_write_errors_total))
* print('Write without poll: {}'.format(
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Write_errors, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 948, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
/* "uvloop/loop.pyx":949
* print('--- Streams debug info: ---')
* print('Write errors: {}'.format(
* self._debug_stream_write_errors_total)) # <<<<<<<<<<<<<<
* print('Write without poll: {}'.format(
* self._debug_stream_write_tries))
*/
__pyx_t_4 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_write_errors_total); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 949, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (!__pyx_t_6) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 948, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_4};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 948, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_4};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 948, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
{
__pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 948, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_4);
__pyx_t_4 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_12, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 948, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
}
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":948
*
* print('--- Streams debug info: ---')
* print('Write errors: {}'.format( # <<<<<<<<<<<<<<
* self._debug_stream_write_errors_total))
* print('Write without poll: {}'.format(
*/
__pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 948, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 948, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":950
* print('Write errors: {}'.format(
* self._debug_stream_write_errors_total))
* print('Write without poll: {}'.format( # <<<<<<<<<<<<<<
* self._debug_stream_write_tries))
* print('Write contexts: {: <8} | {}'.format(
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Write_without_poll, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 950, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
/* "uvloop/loop.pyx":951
* self._debug_stream_write_errors_total))
* print('Write without poll: {}'.format(
* self._debug_stream_write_tries)) # <<<<<<<<<<<<<<
* print('Write contexts: {: <8} | {}'.format(
* self._debug_stream_write_ctx_cnt,
*/
__pyx_t_12 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_write_tries); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 951, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (!__pyx_t_4) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_12); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 950, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_12};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 950, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_12};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 950, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
} else
#endif
{
__pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 950, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL;
__Pyx_GIVEREF(__pyx_t_12);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_12);
__pyx_t_12 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 950, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":950
* print('Write errors: {}'.format(
* self._debug_stream_write_errors_total))
* print('Write without poll: {}'.format( # <<<<<<<<<<<<<<
* self._debug_stream_write_tries))
* print('Write contexts: {: <8} | {}'.format(
*/
__pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 950, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 950, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":952
* print('Write without poll: {}'.format(
* self._debug_stream_write_tries))
* print('Write contexts: {: <8} | {}'.format( # <<<<<<<<<<<<<<
* self._debug_stream_write_ctx_cnt,
* self._debug_stream_write_ctx_total))
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Write_contexts_8, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 952, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
/* "uvloop/loop.pyx":953
* self._debug_stream_write_tries))
* print('Write contexts: {: <8} | {}'.format(
* self._debug_stream_write_ctx_cnt, # <<<<<<<<<<<<<<
* self._debug_stream_write_ctx_total))
* print('Write failed callbacks: {}'.format(
*/
__pyx_t_6 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_write_ctx_cnt); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 953, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
/* "uvloop/loop.pyx":954
* print('Write contexts: {: <8} | {}'.format(
* self._debug_stream_write_ctx_cnt,
* self._debug_stream_write_ctx_total)) # <<<<<<<<<<<<<<
* print('Write failed callbacks: {}'.format(
* self._debug_stream_write_cb_errors_total))
*/
__pyx_t_12 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_write_ctx_total); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 954, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__pyx_t_4 = NULL;
__pyx_t_7 = 0;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
__pyx_t_7 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_6, __pyx_t_12};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 952, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_6, __pyx_t_12};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 952, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
} else
#endif
{
__pyx_t_3 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 952, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
if (__pyx_t_4) {
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __pyx_t_4 = NULL;
}
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_3, 0+__pyx_t_7, __pyx_t_6);
__Pyx_GIVEREF(__pyx_t_12);
PyTuple_SET_ITEM(__pyx_t_3, 1+__pyx_t_7, __pyx_t_12);
__pyx_t_6 = 0;
__pyx_t_12 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 952, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":952
* print('Write without poll: {}'.format(
* self._debug_stream_write_tries))
* print('Write contexts: {: <8} | {}'.format( # <<<<<<<<<<<<<<
* self._debug_stream_write_ctx_cnt,
* self._debug_stream_write_ctx_total))
*/
__pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 952, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 952, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":955
* self._debug_stream_write_ctx_cnt,
* self._debug_stream_write_ctx_total))
* print('Write failed callbacks: {}'.format( # <<<<<<<<<<<<<<
* self._debug_stream_write_cb_errors_total))
* print()
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Write_failed_callbacks, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 955, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
/* "uvloop/loop.pyx":956
* self._debug_stream_write_ctx_total))
* print('Write failed callbacks: {}'.format(
* self._debug_stream_write_cb_errors_total)) # <<<<<<<<<<<<<<
* print()
* print('Read errors: {}'.format(
*/
__pyx_t_3 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_write_cb_errors_total); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 956, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_12 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_12 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_12)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_12);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (!__pyx_t_12) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 955, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_t_3};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 955, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_t_3};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 955, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else
#endif
{
__pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 955, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_12); __pyx_t_12 = NULL;
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3);
__pyx_t_3 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 955, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":955
* self._debug_stream_write_ctx_cnt,
* self._debug_stream_write_ctx_total))
* print('Write failed callbacks: {}'.format( # <<<<<<<<<<<<<<
* self._debug_stream_write_cb_errors_total))
* print()
*/
__pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 955, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 955, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":957
* print('Write failed callbacks: {}'.format(
* self._debug_stream_write_cb_errors_total))
* print() # <<<<<<<<<<<<<<
* print('Read errors: {}'.format(
* self._debug_stream_read_errors_total))
*/
__pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_builtin_print); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 957, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":958
* self._debug_stream_write_cb_errors_total))
* print()
* print('Read errors: {}'.format( # <<<<<<<<<<<<<<
* self._debug_stream_read_errors_total))
* print('Read callbacks: {}'.format(
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Read_errors, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 958, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
/* "uvloop/loop.pyx":959
* print()
* print('Read errors: {}'.format(
* self._debug_stream_read_errors_total)) # <<<<<<<<<<<<<<
* print('Read callbacks: {}'.format(
* self._debug_stream_read_cb_total))
*/
__pyx_t_6 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_read_errors_total); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 959, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (!__pyx_t_3) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 958, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_6};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 958, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_6};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 958, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else
#endif
{
__pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 958, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_6);
__pyx_t_6 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_12, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 958, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
}
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":958
* self._debug_stream_write_cb_errors_total))
* print()
* print('Read errors: {}'.format( # <<<<<<<<<<<<<<
* self._debug_stream_read_errors_total))
* print('Read callbacks: {}'.format(
*/
__pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 958, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 958, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":960
* print('Read errors: {}'.format(
* self._debug_stream_read_errors_total))
* print('Read callbacks: {}'.format( # <<<<<<<<<<<<<<
* self._debug_stream_read_cb_total))
* print('Read failed callbacks: {}'.format(
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Read_callbacks, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 960, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
/* "uvloop/loop.pyx":961
* self._debug_stream_read_errors_total))
* print('Read callbacks: {}'.format(
* self._debug_stream_read_cb_total)) # <<<<<<<<<<<<<<
* print('Read failed callbacks: {}'.format(
* self._debug_stream_read_cb_errors_total))
*/
__pyx_t_12 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_read_cb_total); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 961, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (!__pyx_t_6) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_12); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 960, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_12};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 960, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_12};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 960, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
} else
#endif
{
__pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 960, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_GIVEREF(__pyx_t_12);
PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_t_12);
__pyx_t_12 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 960, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":960
* print('Read errors: {}'.format(
* self._debug_stream_read_errors_total))
* print('Read callbacks: {}'.format( # <<<<<<<<<<<<<<
* self._debug_stream_read_cb_total))
* print('Read failed callbacks: {}'.format(
*/
__pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 960, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 960, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":962
* print('Read callbacks: {}'.format(
* self._debug_stream_read_cb_total))
* print('Read failed callbacks: {}'.format( # <<<<<<<<<<<<<<
* self._debug_stream_read_cb_errors_total))
* print('Read EOFs: {}'.format(
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Read_failed_callbacks, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 962, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
/* "uvloop/loop.pyx":963
* self._debug_stream_read_cb_total))
* print('Read failed callbacks: {}'.format(
* self._debug_stream_read_cb_errors_total)) # <<<<<<<<<<<<<<
* print('Read EOFs: {}'.format(
* self._debug_stream_read_eof_total))
*/
__pyx_t_3 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_read_cb_errors_total); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 963, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_12 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_12 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_12)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_12);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (!__pyx_t_12) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 962, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_t_3};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 962, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_t_3};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 962, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else
#endif
{
__pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 962, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_12); __pyx_t_12 = NULL;
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3);
__pyx_t_3 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 962, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":962
* print('Read callbacks: {}'.format(
* self._debug_stream_read_cb_total))
* print('Read failed callbacks: {}'.format( # <<<<<<<<<<<<<<
* self._debug_stream_read_cb_errors_total))
* print('Read EOFs: {}'.format(
*/
__pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 962, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 962, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":964
* print('Read failed callbacks: {}'.format(
* self._debug_stream_read_cb_errors_total))
* print('Read EOFs: {}'.format( # <<<<<<<<<<<<<<
* self._debug_stream_read_eof_total))
* print('Read EOF failed callbacks: {}'.format(
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Read_EOFs, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 964, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
/* "uvloop/loop.pyx":965
* self._debug_stream_read_cb_errors_total))
* print('Read EOFs: {}'.format(
* self._debug_stream_read_eof_total)) # <<<<<<<<<<<<<<
* print('Read EOF failed callbacks: {}'.format(
* self._debug_stream_read_eof_cb_errors_total))
*/
__pyx_t_6 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_read_eof_total); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 965, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (!__pyx_t_3) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 964, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_6};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 964, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_6};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 964, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else
#endif
{
__pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 964, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_6);
__pyx_t_6 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_12, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 964, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
}
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":964
* print('Read failed callbacks: {}'.format(
* self._debug_stream_read_cb_errors_total))
* print('Read EOFs: {}'.format( # <<<<<<<<<<<<<<
* self._debug_stream_read_eof_total))
* print('Read EOF failed callbacks: {}'.format(
*/
__pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 964, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 964, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":966
* print('Read EOFs: {}'.format(
* self._debug_stream_read_eof_total))
* print('Read EOF failed callbacks: {}'.format( # <<<<<<<<<<<<<<
* self._debug_stream_read_eof_cb_errors_total))
* print()
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Read_EOF_failed_callbacks, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 966, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
/* "uvloop/loop.pyx":967
* self._debug_stream_read_eof_total))
* print('Read EOF failed callbacks: {}'.format(
* self._debug_stream_read_eof_cb_errors_total)) # <<<<<<<<<<<<<<
* print()
* print('Listen errors: {}'.format(
*/
__pyx_t_12 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_read_eof_cb_errors_total); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 967, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (!__pyx_t_6) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_12); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 966, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_12};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 966, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_12};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 966, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
} else
#endif
{
__pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 966, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_GIVEREF(__pyx_t_12);
PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_t_12);
__pyx_t_12 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 966, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":966
* print('Read EOFs: {}'.format(
* self._debug_stream_read_eof_total))
* print('Read EOF failed callbacks: {}'.format( # <<<<<<<<<<<<<<
* self._debug_stream_read_eof_cb_errors_total))
* print()
*/
__pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 966, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 966, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":968
* print('Read EOF failed callbacks: {}'.format(
* self._debug_stream_read_eof_cb_errors_total))
* print() # <<<<<<<<<<<<<<
* print('Listen errors: {}'.format(
* self._debug_stream_listen_errors_total))
*/
__pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_builtin_print); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 968, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":969
* self._debug_stream_read_eof_cb_errors_total))
* print()
* print('Listen errors: {}'.format( # <<<<<<<<<<<<<<
* self._debug_stream_listen_errors_total))
* print('Shutdown errors {}'.format(
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Listen_errors, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 969, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
/* "uvloop/loop.pyx":970
* print()
* print('Listen errors: {}'.format(
* self._debug_stream_listen_errors_total)) # <<<<<<<<<<<<<<
* print('Shutdown errors {}'.format(
* self._debug_stream_shutdown_errors_total))
*/
__pyx_t_3 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_listen_errors_total); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 970, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_12 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_12 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_12)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_12);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (!__pyx_t_12) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 969, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_t_3};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 969, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_t_3};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 969, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else
#endif
{
__pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 969, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_12); __pyx_t_12 = NULL;
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3);
__pyx_t_3 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 969, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":969
* self._debug_stream_read_eof_cb_errors_total))
* print()
* print('Listen errors: {}'.format( # <<<<<<<<<<<<<<
* self._debug_stream_listen_errors_total))
* print('Shutdown errors {}'.format(
*/
__pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 969, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 969, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":971
* print('Listen errors: {}'.format(
* self._debug_stream_listen_errors_total))
* print('Shutdown errors {}'.format( # <<<<<<<<<<<<<<
* self._debug_stream_shutdown_errors_total))
* print()
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Shutdown_errors, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 971, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
/* "uvloop/loop.pyx":972
* self._debug_stream_listen_errors_total))
* print('Shutdown errors {}'.format(
* self._debug_stream_shutdown_errors_total)) # <<<<<<<<<<<<<<
* print()
*
*/
__pyx_t_6 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_shutdown_errors_total); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 972, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (!__pyx_t_3) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 971, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_6};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 971, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_6};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 971, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else
#endif
{
__pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 971, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_6);
__pyx_t_6 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_12, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 971, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
}
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":971
* print('Listen errors: {}'.format(
* self._debug_stream_listen_errors_total))
* print('Shutdown errors {}'.format( # <<<<<<<<<<<<<<
* self._debug_stream_shutdown_errors_total))
* print()
*/
__pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 971, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 971, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":973
* print('Shutdown errors {}'.format(
* self._debug_stream_shutdown_errors_total))
* print() # <<<<<<<<<<<<<<
*
* print('--- Polls debug info: ---')
*/
__pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_builtin_print); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 973, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":975
* print()
*
* print('--- Polls debug info: ---') # <<<<<<<<<<<<<<
* print('Read events: {}'.format(
* self._poll_read_events_total))
*/
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__39, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 975, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":976
*
* print('--- Polls debug info: ---')
* print('Read events: {}'.format( # <<<<<<<<<<<<<<
* self._poll_read_events_total))
* print('Read callbacks failed: {}'.format(
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Read_events, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 976, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
/* "uvloop/loop.pyx":977
* print('--- Polls debug info: ---')
* print('Read events: {}'.format(
* self._poll_read_events_total)) # <<<<<<<<<<<<<<
* print('Read callbacks failed: {}'.format(
* self._poll_read_cb_errors_total))
*/
__pyx_t_12 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_poll_read_events_total); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 977, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (!__pyx_t_6) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_12); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 976, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_12};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 976, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_12};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 976, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
} else
#endif
{
__pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 976, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_GIVEREF(__pyx_t_12);
PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_t_12);
__pyx_t_12 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 976, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":976
*
* print('--- Polls debug info: ---')
* print('Read events: {}'.format( # <<<<<<<<<<<<<<
* self._poll_read_events_total))
* print('Read callbacks failed: {}'.format(
*/
__pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 976, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 976, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":978
* print('Read events: {}'.format(
* self._poll_read_events_total))
* print('Read callbacks failed: {}'.format( # <<<<<<<<<<<<<<
* self._poll_read_cb_errors_total))
* print('Write events: {}'.format(
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Read_callbacks_failed, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 978, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
/* "uvloop/loop.pyx":979
* self._poll_read_events_total))
* print('Read callbacks failed: {}'.format(
* self._poll_read_cb_errors_total)) # <<<<<<<<<<<<<<
* print('Write events: {}'.format(
* self._poll_write_events_total))
*/
__pyx_t_3 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_poll_read_cb_errors_total); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 979, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_12 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_12 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_12)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_12);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (!__pyx_t_12) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 978, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_t_3};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 978, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_t_3};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 978, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else
#endif
{
__pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 978, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_12); __pyx_t_12 = NULL;
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3);
__pyx_t_3 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 978, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":978
* print('Read events: {}'.format(
* self._poll_read_events_total))
* print('Read callbacks failed: {}'.format( # <<<<<<<<<<<<<<
* self._poll_read_cb_errors_total))
* print('Write events: {}'.format(
*/
__pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 978, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 978, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":980
* print('Read callbacks failed: {}'.format(
* self._poll_read_cb_errors_total))
* print('Write events: {}'.format( # <<<<<<<<<<<<<<
* self._poll_write_events_total))
* print('Write callbacks failed: {}'.format(
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Write_events, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 980, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
/* "uvloop/loop.pyx":981
* self._poll_read_cb_errors_total))
* print('Write events: {}'.format(
* self._poll_write_events_total)) # <<<<<<<<<<<<<<
* print('Write callbacks failed: {}'.format(
* self._poll_write_cb_errors_total))
*/
__pyx_t_6 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_poll_write_events_total); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 981, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (!__pyx_t_3) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 980, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_6};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 980, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_6};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 980, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else
#endif
{
__pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 980, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_6);
__pyx_t_6 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_12, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 980, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
}
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":980
* print('Read callbacks failed: {}'.format(
* self._poll_read_cb_errors_total))
* print('Write events: {}'.format( # <<<<<<<<<<<<<<
* self._poll_write_events_total))
* print('Write callbacks failed: {}'.format(
*/
__pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 980, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 980, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":982
* print('Write events: {}'.format(
* self._poll_write_events_total))
* print('Write callbacks failed: {}'.format( # <<<<<<<<<<<<<<
* self._poll_write_cb_errors_total))
* print()
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Write_callbacks_failed, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 982, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
/* "uvloop/loop.pyx":983
* self._poll_write_events_total))
* print('Write callbacks failed: {}'.format(
* self._poll_write_cb_errors_total)) # <<<<<<<<<<<<<<
* print()
*
*/
__pyx_t_12 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_poll_write_cb_errors_total); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 983, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (!__pyx_t_6) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_12); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 982, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_12};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 982, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_12};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 982, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
} else
#endif
{
__pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 982, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_GIVEREF(__pyx_t_12);
PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_t_12);
__pyx_t_12 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 982, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":982
* print('Write events: {}'.format(
* self._poll_write_events_total))
* print('Write callbacks failed: {}'.format( # <<<<<<<<<<<<<<
* self._poll_write_cb_errors_total))
* print()
*/
__pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 982, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 982, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":984
* print('Write callbacks failed: {}'.format(
* self._poll_write_cb_errors_total))
* print() # <<<<<<<<<<<<<<
*
* print('--- Sock ops successfull on 1st try: ---')
*/
__pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_builtin_print); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 984, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":986
* print()
*
* print('--- Sock ops successfull on 1st try: ---') # <<<<<<<<<<<<<<
* print('Socket try-writes: {}'.format(
* self._sock_try_write_total))
*/
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_tuple__40, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 986, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":987
*
* print('--- Sock ops successfull on 1st try: ---')
* print('Socket try-writes: {}'.format( # <<<<<<<<<<<<<<
* self._sock_try_write_total))
*
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Socket_try_writes, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 987, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
/* "uvloop/loop.pyx":988
* print('--- Sock ops successfull on 1st try: ---')
* print('Socket try-writes: {}'.format(
* self._sock_try_write_total)) # <<<<<<<<<<<<<<
*
* print(flush=True)
*/
__pyx_t_3 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_sock_try_write_total); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 988, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_12 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_12 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_12)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_12);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (!__pyx_t_12) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 987, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_t_3};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 987, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_t_3};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 987, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else
#endif
{
__pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 987, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_12); __pyx_t_12 = NULL;
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3);
__pyx_t_3 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 987, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":987
*
* print('--- Sock ops successfull on 1st try: ---')
* print('Socket try-writes: {}'.format( # <<<<<<<<<<<<<<
* self._sock_try_write_total))
*
*/
__pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 987, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 987, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":990
* self._sock_try_write_total))
*
* print(flush=True) # <<<<<<<<<<<<<<
*
* # Public API
*/
__pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 990, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_flush, Py_True) < 0) __PYX_ERR(1, 990, __pyx_L1_error)
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_print, __pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 990, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":895
* return uv.uv_backend_fd(self.uvloop)
*
* def print_debug_info(self): # <<<<<<<<<<<<<<
* cdef:
* int err
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_XDECREF(__pyx_t_11);
__Pyx_XDECREF(__pyx_t_12);
__Pyx_AddTraceback("uvloop.loop.Loop.print_debug_info", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_name);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":994
* # Public API
*
* def __repr__(self): # <<<<<<<<<<<<<<
* return '<{}.{} running={} closed={} debug={}>'.format(
* self.__class__.__module__,
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_11__repr__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_11__repr__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__repr__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_10__repr__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_10__repr__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
int __pyx_t_10;
__Pyx_RefNannySetupContext("__repr__", 0);
/* "uvloop/loop.pyx":995
*
* def __repr__(self):
* return '<{}.{} running={} closed={} debug={}>'.format( # <<<<<<<<<<<<<<
* self.__class__.__module__,
* self.__class__.__name__,
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_running_closed_debug, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 995, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
/* "uvloop/loop.pyx":996
* def __repr__(self):
* return '<{}.{} running={} closed={} debug={}>'.format(
* self.__class__.__module__, # <<<<<<<<<<<<<<
* self.__class__.__name__,
* self.is_running(),
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 996, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_module); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 996, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":997
* return '<{}.{} running={} closed={} debug={}>'.format(
* self.__class__.__module__,
* self.__class__.__name__, # <<<<<<<<<<<<<<
* self.is_running(),
* self.is_closed(),
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 997, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_name); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 997, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":998
* self.__class__.__module__,
* self.__class__.__name__,
* self.is_running(), # <<<<<<<<<<<<<<
* self.is_closed(),
* self.get_debug())
*/
__pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_is_running); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 998, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_7 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
__pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
if (likely(__pyx_t_7)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
__Pyx_INCREF(__pyx_t_7);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_6, function);
}
}
if (__pyx_t_7) {
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 998, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else {
__pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 998, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "uvloop/loop.pyx":999
* self.__class__.__name__,
* self.is_running(),
* self.is_closed(), # <<<<<<<<<<<<<<
* self.get_debug())
*
*/
__pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_is_closed); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 999, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_8 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
__pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_8)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_8);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_7, function);
}
}
if (__pyx_t_8) {
__pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 999, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
} else {
__pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 999, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "uvloop/loop.pyx":1000
* self.is_running(),
* self.is_closed(),
* self.get_debug()) # <<<<<<<<<<<<<<
*
* def call_soon(self, callback, *args):
*/
__pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_debug); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1000, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__pyx_t_9 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) {
__pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8);
if (likely(__pyx_t_9)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
__Pyx_INCREF(__pyx_t_9);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_8, function);
}
}
if (__pyx_t_9) {
__pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1000, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
} else {
__pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1000, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__pyx_t_8 = NULL;
__pyx_t_10 = 0;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_8)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_8);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
__pyx_t_10 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[6] = {__pyx_t_8, __pyx_t_4, __pyx_t_5, __pyx_t_3, __pyx_t_6, __pyx_t_7};
__pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_10, 5+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 995, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[6] = {__pyx_t_8, __pyx_t_4, __pyx_t_5, __pyx_t_3, __pyx_t_6, __pyx_t_7};
__pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_10, 5+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 995, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else
#endif
{
__pyx_t_9 = PyTuple_New(5+__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 995, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
if (__pyx_t_8) {
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL;
}
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_10, __pyx_t_4);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_10, __pyx_t_5);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_10, __pyx_t_3);
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_9, 3+__pyx_t_10, __pyx_t_6);
__Pyx_GIVEREF(__pyx_t_7);
PyTuple_SET_ITEM(__pyx_t_9, 4+__pyx_t_10, __pyx_t_7);
__pyx_t_4 = 0;
__pyx_t_5 = 0;
__pyx_t_3 = 0;
__pyx_t_6 = 0;
__pyx_t_7 = 0;
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 995, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* "uvloop/loop.pyx":994
* # Public API
*
* def __repr__(self): # <<<<<<<<<<<<<<
* return '<{}.{} running={} closed={} debug={}>'.format(
* self.__class__.__module__,
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_XDECREF(__pyx_t_9);
__Pyx_AddTraceback("uvloop.loop.Loop.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1002
* self.get_debug())
*
* def call_soon(self, callback, *args): # <<<<<<<<<<<<<<
* """Arrange for a callback to be called as soon as possible.
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_13call_soon(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_12call_soon[] = "Loop.call_soon(self, callback, *args)\nArrange for a callback to be called as soon as possible.\n\n This operates as a FIFO queue: callbacks are called in the\n order in which they are registered. Each callback will be\n called exactly once.\n\n Any positional arguments after the callback will be passed to\n the callback when it is called.\n ";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_13call_soon(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_callback = 0;
PyObject *__pyx_v_args = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("call_soon (wrapper)", 0);
if (PyTuple_GET_SIZE(__pyx_args) > 1) {
__pyx_v_args = PyTuple_GetSlice(__pyx_args, 1, PyTuple_GET_SIZE(__pyx_args));
if (unlikely(!__pyx_v_args)) {
__Pyx_RefNannyFinishContext();
return NULL;
}
__Pyx_GOTREF(__pyx_v_args);
} else {
__pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple);
}
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,0};
PyObject* values[1] = {0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
default:
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
case 0: break;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
}
if (unlikely(kw_args > 0)) {
const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1;
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "call_soon") < 0)) __PYX_ERR(1, 1002, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) < 1) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
}
__pyx_v_callback = values[0];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("call_soon", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1002, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0;
__Pyx_AddTraceback("uvloop.loop.Loop.call_soon", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_12call_soon(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_callback, __pyx_v_args);
/* function exit code */
__Pyx_XDECREF(__pyx_v_args);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_12call_soon(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
__Pyx_RefNannySetupContext("call_soon", 0);
/* "uvloop/loop.pyx":1012
* the callback when it is called.
* """
* if self._debug == 1: # <<<<<<<<<<<<<<
* self._check_thread()
* if args:
*/
__pyx_t_1 = ((__pyx_v_self->_debug == 1) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":1013
* """
* if self._debug == 1:
* self._check_thread() # <<<<<<<<<<<<<<
* if args:
* return self._call_soon(callback, args)
*/
__pyx_t_2 = __pyx_f_6uvloop_4loop_4Loop__check_thread(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1013, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":1012
* the callback when it is called.
* """
* if self._debug == 1: # <<<<<<<<<<<<<<
* self._check_thread()
* if args:
*/
}
/* "uvloop/loop.pyx":1014
* if self._debug == 1:
* self._check_thread()
* if args: # <<<<<<<<<<<<<<
* return self._call_soon(callback, args)
* else:
*/
__pyx_t_1 = (__pyx_v_args != Py_None) && (PyTuple_GET_SIZE(__pyx_v_args) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":1015
* self._check_thread()
* if args:
* return self._call_soon(callback, args) # <<<<<<<<<<<<<<
* else:
* return self._call_soon(callback, None)
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_2 = __pyx_f_6uvloop_4loop_4Loop__call_soon(__pyx_v_self, __pyx_v_callback, __pyx_v_args); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1015, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
/* "uvloop/loop.pyx":1014
* if self._debug == 1:
* self._check_thread()
* if args: # <<<<<<<<<<<<<<
* return self._call_soon(callback, args)
* else:
*/
}
/* "uvloop/loop.pyx":1017
* return self._call_soon(callback, args)
* else:
* return self._call_soon(callback, None) # <<<<<<<<<<<<<<
*
* def call_soon_threadsafe(self, callback, *args):
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
__pyx_t_2 = __pyx_f_6uvloop_4loop_4Loop__call_soon(__pyx_v_self, __pyx_v_callback, Py_None); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1017, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
}
/* "uvloop/loop.pyx":1002
* self.get_debug())
*
* def call_soon(self, callback, *args): # <<<<<<<<<<<<<<
* """Arrange for a callback to be called as soon as possible.
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_AddTraceback("uvloop.loop.Loop.call_soon", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1019
* return self._call_soon(callback, None)
*
* def call_soon_threadsafe(self, callback, *args): # <<<<<<<<<<<<<<
* """Like call_soon(), but thread-safe."""
* if not args:
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_15call_soon_threadsafe(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_14call_soon_threadsafe[] = "Loop.call_soon_threadsafe(self, callback, *args)\nLike call_soon(), but thread-safe.";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_15call_soon_threadsafe(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_callback = 0;
PyObject *__pyx_v_args = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("call_soon_threadsafe (wrapper)", 0);
if (PyTuple_GET_SIZE(__pyx_args) > 1) {
__pyx_v_args = PyTuple_GetSlice(__pyx_args, 1, PyTuple_GET_SIZE(__pyx_args));
if (unlikely(!__pyx_v_args)) {
__Pyx_RefNannyFinishContext();
return NULL;
}
__Pyx_GOTREF(__pyx_v_args);
} else {
__pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple);
}
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,0};
PyObject* values[1] = {0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
default:
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
case 0: break;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
}
if (unlikely(kw_args > 0)) {
const Py_ssize_t used_pos_args = (pos_args < 1) ? pos_args : 1;
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "call_soon_threadsafe") < 0)) __PYX_ERR(1, 1019, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) < 1) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
}
__pyx_v_callback = values[0];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("call_soon_threadsafe", 0, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1019, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0;
__Pyx_AddTraceback("uvloop.loop.Loop.call_soon_threadsafe", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_14call_soon_threadsafe(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_callback, __pyx_v_args);
/* function exit code */
__Pyx_XDECREF(__pyx_v_args);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_14call_soon_threadsafe(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) {
PyObject *__pyx_v_handle = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
__Pyx_RefNannySetupContext("call_soon_threadsafe", 0);
__Pyx_INCREF(__pyx_v_args);
/* "uvloop/loop.pyx":1021
* def call_soon_threadsafe(self, callback, *args):
* """Like call_soon(), but thread-safe."""
* if not args: # <<<<<<<<<<<<<<
* args = None
* handle = self._call_soon(callback, args)
*/
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_args); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 1021, __pyx_L1_error)
__pyx_t_2 = ((!__pyx_t_1) != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":1022
* """Like call_soon(), but thread-safe."""
* if not args:
* args = None # <<<<<<<<<<<<<<
* handle = self._call_soon(callback, args)
* self.handler_async.send()
*/
__Pyx_INCREF(Py_None);
__Pyx_DECREF_SET(__pyx_v_args, Py_None);
/* "uvloop/loop.pyx":1021
* def call_soon_threadsafe(self, callback, *args):
* """Like call_soon(), but thread-safe."""
* if not args: # <<<<<<<<<<<<<<
* args = None
* handle = self._call_soon(callback, args)
*/
}
/* "uvloop/loop.pyx":1023
* if not args:
* args = None
* handle = self._call_soon(callback, args) # <<<<<<<<<<<<<<
* self.handler_async.send()
* return handle
*/
__pyx_t_3 = __pyx_f_6uvloop_4loop_4Loop__call_soon(__pyx_v_self, __pyx_v_callback, __pyx_v_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1023, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_v_handle = __pyx_t_3;
__pyx_t_3 = 0;
/* "uvloop/loop.pyx":1024
* args = None
* handle = self._call_soon(callback, args)
* self.handler_async.send() # <<<<<<<<<<<<<<
* return handle
*
*/
__pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVAsync *)__pyx_v_self->handler_async->__pyx_base.__pyx_vtab)->send(__pyx_v_self->handler_async); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1024, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":1025
* handle = self._call_soon(callback, args)
* self.handler_async.send()
* return handle # <<<<<<<<<<<<<<
*
* def call_later(self, delay, callback, *args):
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v_handle);
__pyx_r = __pyx_v_handle;
goto __pyx_L0;
/* "uvloop/loop.pyx":1019
* return self._call_soon(callback, None)
*
* def call_soon_threadsafe(self, callback, *args): # <<<<<<<<<<<<<<
* """Like call_soon(), but thread-safe."""
* if not args:
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_AddTraceback("uvloop.loop.Loop.call_soon_threadsafe", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_args);
__Pyx_XDECREF(__pyx_v_handle);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1027
* return handle
*
* def call_later(self, delay, callback, *args): # <<<<<<<<<<<<<<
* """Arrange for a callback to be called at a given time.
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_17call_later(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_16call_later[] = "Loop.call_later(self, delay, callback, *args)\nArrange for a callback to be called at a given time.\n\n Return a Handle: an opaque object with a cancel() method that\n can be used to cancel the call.\n\n The delay can be an int or float, expressed in seconds. It is\n always relative to the current time.\n\n Each callback will be called exactly once. If two callbacks\n are scheduled for exactly the same time, it undefined which\n will be called first.\n\n Any positional arguments after the callback will be passed to\n the callback when it is called.\n ";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_17call_later(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_delay = 0;
PyObject *__pyx_v_callback = 0;
PyObject *__pyx_v_args = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("call_later (wrapper)", 0);
if (PyTuple_GET_SIZE(__pyx_args) > 2) {
__pyx_v_args = PyTuple_GetSlice(__pyx_args, 2, PyTuple_GET_SIZE(__pyx_args));
if (unlikely(!__pyx_v_args)) {
__Pyx_RefNannyFinishContext();
return NULL;
}
__Pyx_GOTREF(__pyx_v_args);
} else {
__pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple);
}
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_delay,&__pyx_n_s_callback,0};
PyObject* values[2] = {0,0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
default:
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
case 0: break;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_delay)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("call_later", 0, 2, 2, 1); __PYX_ERR(1, 1027, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
const Py_ssize_t used_pos_args = (pos_args < 2) ? pos_args : 2;
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "call_later") < 0)) __PYX_ERR(1, 1027, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) < 2) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
}
__pyx_v_delay = values[0];
__pyx_v_callback = values[1];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("call_later", 0, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1027, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0;
__Pyx_AddTraceback("uvloop.loop.Loop.call_later", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_16call_later(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_delay, __pyx_v_callback, __pyx_v_args);
/* function exit code */
__Pyx_XDECREF(__pyx_v_args);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_16call_later(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_delay, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) {
uint64_t __pyx_v_when;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_t_2;
uint64_t __pyx_t_3;
int __pyx_t_4;
__Pyx_RefNannySetupContext("call_later", 0);
__Pyx_INCREF(__pyx_v_delay);
__Pyx_INCREF(__pyx_v_args);
/* "uvloop/loop.pyx":1043
* the callback when it is called.
* """
* self._check_closed() # <<<<<<<<<<<<<<
* if self._debug == 1:
* self._check_thread()
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__check_closed(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1043, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1044
* """
* self._check_closed()
* if self._debug == 1: # <<<<<<<<<<<<<<
* self._check_thread()
* if delay < 0:
*/
__pyx_t_2 = ((__pyx_v_self->_debug == 1) != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":1045
* self._check_closed()
* if self._debug == 1:
* self._check_thread() # <<<<<<<<<<<<<<
* if delay < 0:
* delay = 0
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__check_thread(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1045, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1044
* """
* self._check_closed()
* if self._debug == 1: # <<<<<<<<<<<<<<
* self._check_thread()
* if delay < 0:
*/
}
/* "uvloop/loop.pyx":1046
* if self._debug == 1:
* self._check_thread()
* if delay < 0: # <<<<<<<<<<<<<<
* delay = 0
* cdef uint64_t when = (delay * 1000)
*/
__pyx_t_1 = PyObject_RichCompare(__pyx_v_delay, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1046, __pyx_L1_error)
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 1046, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_2) {
/* "uvloop/loop.pyx":1047
* self._check_thread()
* if delay < 0:
* delay = 0 # <<<<<<<<<<<<<<
* cdef uint64_t when = (delay * 1000)
* if not args:
*/
__Pyx_INCREF(__pyx_int_0);
__Pyx_DECREF_SET(__pyx_v_delay, __pyx_int_0);
/* "uvloop/loop.pyx":1046
* if self._debug == 1:
* self._check_thread()
* if delay < 0: # <<<<<<<<<<<<<<
* delay = 0
* cdef uint64_t when = (delay * 1000)
*/
}
/* "uvloop/loop.pyx":1048
* if delay < 0:
* delay = 0
* cdef uint64_t when = (delay * 1000) # <<<<<<<<<<<<<<
* if not args:
* args = None
*/
__pyx_t_1 = PyNumber_Multiply(__pyx_v_delay, __pyx_int_1000); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1048, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_3 = __Pyx_PyInt_As_uint64_t(__pyx_t_1); if (unlikely((__pyx_t_3 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(1, 1048, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_when = ((uint64_t)__pyx_t_3);
/* "uvloop/loop.pyx":1049
* delay = 0
* cdef uint64_t when = (delay * 1000)
* if not args: # <<<<<<<<<<<<<<
* args = None
* if when == 0:
*/
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_args); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 1049, __pyx_L1_error)
__pyx_t_4 = ((!__pyx_t_2) != 0);
if (__pyx_t_4) {
/* "uvloop/loop.pyx":1050
* cdef uint64_t when = (delay * 1000)
* if not args:
* args = None # <<<<<<<<<<<<<<
* if when == 0:
* return self._call_soon(callback, args)
*/
__Pyx_INCREF(Py_None);
__Pyx_DECREF_SET(__pyx_v_args, Py_None);
/* "uvloop/loop.pyx":1049
* delay = 0
* cdef uint64_t when = (delay * 1000)
* if not args: # <<<<<<<<<<<<<<
* args = None
* if when == 0:
*/
}
/* "uvloop/loop.pyx":1051
* if not args:
* args = None
* if when == 0: # <<<<<<<<<<<<<<
* return self._call_soon(callback, args)
* else:
*/
__pyx_t_4 = ((__pyx_v_when == 0) != 0);
if (__pyx_t_4) {
/* "uvloop/loop.pyx":1052
* args = None
* if when == 0:
* return self._call_soon(callback, args) # <<<<<<<<<<<<<<
* else:
* return self._call_later(when, callback, args)
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__call_soon(__pyx_v_self, __pyx_v_callback, __pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1052, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* "uvloop/loop.pyx":1051
* if not args:
* args = None
* if when == 0: # <<<<<<<<<<<<<<
* return self._call_soon(callback, args)
* else:
*/
}
/* "uvloop/loop.pyx":1054
* return self._call_soon(callback, args)
* else:
* return self._call_later(when, callback, args) # <<<<<<<<<<<<<<
*
* def call_at(self, when, callback, *args):
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_call_later(__pyx_v_self, __pyx_v_when, __pyx_v_callback, __pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1054, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
}
/* "uvloop/loop.pyx":1027
* return handle
*
* def call_later(self, delay, callback, *args): # <<<<<<<<<<<<<<
* """Arrange for a callback to be called at a given time.
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop.call_later", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_args);
__Pyx_XDECREF(__pyx_v_delay);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1056
* return self._call_later(when, callback, args)
*
* def call_at(self, when, callback, *args): # <<<<<<<<<<<<<<
* """Like call_later(), but uses an absolute time.
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_19call_at(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_18call_at[] = "Loop.call_at(self, when, callback, *args)\nLike call_later(), but uses an absolute time.\n\n Absolute time corresponds to the event loop's time() method.\n ";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_19call_at(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_when = 0;
PyObject *__pyx_v_callback = 0;
PyObject *__pyx_v_args = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("call_at (wrapper)", 0);
if (PyTuple_GET_SIZE(__pyx_args) > 2) {
__pyx_v_args = PyTuple_GetSlice(__pyx_args, 2, PyTuple_GET_SIZE(__pyx_args));
if (unlikely(!__pyx_v_args)) {
__Pyx_RefNannyFinishContext();
return NULL;
}
__Pyx_GOTREF(__pyx_v_args);
} else {
__pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple);
}
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_when,&__pyx_n_s_callback,0};
PyObject* values[2] = {0,0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
default:
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
case 0: break;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_when)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("call_at", 0, 2, 2, 1); __PYX_ERR(1, 1056, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
const Py_ssize_t used_pos_args = (pos_args < 2) ? pos_args : 2;
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "call_at") < 0)) __PYX_ERR(1, 1056, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) < 2) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
}
__pyx_v_when = values[0];
__pyx_v_callback = values[1];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("call_at", 0, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1056, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0;
__Pyx_AddTraceback("uvloop.loop.Loop.call_at", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_18call_at(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_when, __pyx_v_callback, __pyx_v_args);
/* function exit code */
__Pyx_XDECREF(__pyx_v_args);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_18call_at(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_when, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
__Pyx_RefNannySetupContext("call_at", 0);
/* "uvloop/loop.pyx":1061
* Absolute time corresponds to the event loop's time() method.
* """
* return self.call_later(when - self.time(), callback, *args) # <<<<<<<<<<<<<<
*
* def time(self):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_call_later); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1061, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_time); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1061, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (__pyx_t_4) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1061, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
__pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1061, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = PyNumber_Subtract(__pyx_v_when, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1061, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1061, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3);
__Pyx_INCREF(__pyx_v_callback);
__Pyx_GIVEREF(__pyx_v_callback);
PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_callback);
__pyx_t_3 = 0;
__pyx_t_3 = PyNumber_Add(__pyx_t_2, __pyx_v_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1061, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1061, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
/* "uvloop/loop.pyx":1056
* return self._call_later(when, callback, args)
*
* def call_at(self, when, callback, *args): # <<<<<<<<<<<<<<
* """Like call_later(), but uses an absolute time.
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_AddTraceback("uvloop.loop.Loop.call_at", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1063
* return self.call_later(when - self.time(), callback, *args)
*
* def time(self): # <<<<<<<<<<<<<<
* """Return the time according to the event loop's clock.
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_21time(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_20time[] = "Loop.time(self)\nReturn the time according to the event loop's clock.\n\n This is a float expressed in seconds since an epoch, but the\n epoch, precision, accuracy and drift are unspecified and may\n differ per event loop.\n ";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_21time(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("time (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_20time(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_20time(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("time", 0);
/* "uvloop/loop.pyx":1070
* differ per event loop.
* """
* return self._time() / 1000 # <<<<<<<<<<<<<<
*
* def stop(self):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = PyFloat_FromDouble((((double)((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_time(__pyx_v_self)) / 1000.0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1070, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* "uvloop/loop.pyx":1063
* return self.call_later(when - self.time(), callback, *args)
*
* def time(self): # <<<<<<<<<<<<<<
* """Return the time according to the event loop's clock.
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop.time", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1072
* return self._time() / 1000
*
* def stop(self): # <<<<<<<<<<<<<<
* """Stop running the event loop.
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_23stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_22stop[] = "Loop.stop(self)\nStop running the event loop.\n\n Every callback already scheduled will still run. This simply informs\n run_forever to stop looping after a complete iteration.\n ";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_23stop(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("stop (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_22stop(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_22stop(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
__Pyx_RefNannySetupContext("stop", 0);
/* "uvloop/loop.pyx":1079
* """
* self._call_soon_handle(
* new_MethodHandle1( # <<<<<<<<<<<<<<
* self,
* "Loop._stop",
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_new_MethodHandle1(__pyx_v_self, __pyx_kp_u_Loop__stop, ((__pyx_t_6uvloop_4loop_method1_t)((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_stop), ((PyObject *)__pyx_v_self), Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1079, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(1, 1079, __pyx_L1_error)
/* "uvloop/loop.pyx":1078
* run_forever to stop looping after a complete iteration.
* """
* self._call_soon_handle( # <<<<<<<<<<<<<<
* new_MethodHandle1(
* self,
*/
__pyx_t_2 = __pyx_f_6uvloop_4loop_4Loop__call_soon_handle(__pyx_v_self, ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1078, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":1072
* return self._time() / 1000
*
* def stop(self): # <<<<<<<<<<<<<<
* """Stop running the event loop.
*
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_AddTraceback("uvloop.loop.Loop.stop", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1086
* None))
*
* def run_forever(self): # <<<<<<<<<<<<<<
* """Run the event loop until stop() is called."""
* self._check_closed()
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_25run_forever(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_24run_forever[] = "Loop.run_forever(self)\nRun the event loop until stop() is called.";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_25run_forever(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("run_forever (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_24run_forever(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_24run_forever(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
uv_run_mode __pyx_v_mode;
PyObject *__pyx_v_old_agen_hooks = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_t_2;
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_t_6;
int __pyx_t_7;
char const *__pyx_t_8;
PyObject *__pyx_t_9 = NULL;
PyObject *__pyx_t_10 = NULL;
PyObject *__pyx_t_11 = NULL;
PyObject *__pyx_t_12 = NULL;
PyObject *__pyx_t_13 = NULL;
PyObject *__pyx_t_14 = NULL;
__Pyx_RefNannySetupContext("run_forever", 0);
/* "uvloop/loop.pyx":1088
* def run_forever(self):
* """Run the event loop until stop() is called."""
* self._check_closed() # <<<<<<<<<<<<<<
* mode = uv.UV_RUN_DEFAULT
* if self._stopping:
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__check_closed(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1088, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1089
* """Run the event loop until stop() is called."""
* self._check_closed()
* mode = uv.UV_RUN_DEFAULT # <<<<<<<<<<<<<<
* if self._stopping:
* # loop.stop() was called right before loop.run_forever().
*/
__pyx_v_mode = UV_RUN_DEFAULT;
/* "uvloop/loop.pyx":1090
* self._check_closed()
* mode = uv.UV_RUN_DEFAULT
* if self._stopping: # <<<<<<<<<<<<<<
* # loop.stop() was called right before loop.run_forever().
* # This is how asyncio loop behaves.
*/
__pyx_t_2 = (__pyx_v_self->_stopping != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":1093
* # loop.stop() was called right before loop.run_forever().
* # This is how asyncio loop behaves.
* mode = uv.UV_RUN_NOWAIT # <<<<<<<<<<<<<<
* self._set_coroutine_wrapper(self._debug)
* if self._asyncgens is not None:
*/
__pyx_v_mode = UV_RUN_NOWAIT;
/* "uvloop/loop.pyx":1090
* self._check_closed()
* mode = uv.UV_RUN_DEFAULT
* if self._stopping: # <<<<<<<<<<<<<<
* # loop.stop() was called right before loop.run_forever().
* # This is how asyncio loop behaves.
*/
}
/* "uvloop/loop.pyx":1094
* # This is how asyncio loop behaves.
* mode = uv.UV_RUN_NOWAIT
* self._set_coroutine_wrapper(self._debug) # <<<<<<<<<<<<<<
* if self._asyncgens is not None:
* old_agen_hooks = sys.get_asyncgen_hooks()
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_set_coroutine_wrapper(__pyx_v_self, __pyx_v_self->_debug); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1094, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1095
* mode = uv.UV_RUN_NOWAIT
* self._set_coroutine_wrapper(self._debug)
* if self._asyncgens is not None: # <<<<<<<<<<<<<<
* old_agen_hooks = sys.get_asyncgen_hooks()
* sys.set_asyncgen_hooks(firstiter=self._asyncgen_firstiter_hook,
*/
__pyx_t_2 = (__pyx_v_self->_asyncgens != Py_None);
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1096
* self._set_coroutine_wrapper(self._debug)
* if self._asyncgens is not None:
* old_agen_hooks = sys.get_asyncgen_hooks() # <<<<<<<<<<<<<<
* sys.set_asyncgen_hooks(firstiter=self._asyncgen_firstiter_hook,
* finalizer=self._asyncgen_finalizer_hook)
*/
__pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1096, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_get_asyncgen_hooks); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1096, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_5, function);
}
}
if (__pyx_t_4) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1096, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1096, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_v_old_agen_hooks = __pyx_t_1;
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":1097
* if self._asyncgens is not None:
* old_agen_hooks = sys.get_asyncgen_hooks()
* sys.set_asyncgen_hooks(firstiter=self._asyncgen_firstiter_hook, # <<<<<<<<<<<<<<
* finalizer=self._asyncgen_finalizer_hook)
* try:
*/
__pyx_t_1 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1097, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_set_asyncgen_hooks); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1097, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1097, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_asyncgen_firstiter_hook); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1097, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_firstiter, __pyx_t_4) < 0) __PYX_ERR(1, 1097, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":1098
* old_agen_hooks = sys.get_asyncgen_hooks()
* sys.set_asyncgen_hooks(firstiter=self._asyncgen_firstiter_hook,
* finalizer=self._asyncgen_finalizer_hook) # <<<<<<<<<<<<<<
* try:
* self._run(mode)
*/
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_asyncgen_finalizer_hook); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1098, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_finalizer, __pyx_t_4) < 0) __PYX_ERR(1, 1097, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":1097
* if self._asyncgens is not None:
* old_agen_hooks = sys.get_asyncgen_hooks()
* sys.set_asyncgen_hooks(firstiter=self._asyncgen_firstiter_hook, # <<<<<<<<<<<<<<
* finalizer=self._asyncgen_finalizer_hook)
* try:
*/
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1097, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":1095
* mode = uv.UV_RUN_NOWAIT
* self._set_coroutine_wrapper(self._debug)
* if self._asyncgens is not None: # <<<<<<<<<<<<<<
* old_agen_hooks = sys.get_asyncgen_hooks()
* sys.set_asyncgen_hooks(firstiter=self._asyncgen_firstiter_hook,
*/
}
/* "uvloop/loop.pyx":1099
* sys.set_asyncgen_hooks(firstiter=self._asyncgen_firstiter_hook,
* finalizer=self._asyncgen_finalizer_hook)
* try: # <<<<<<<<<<<<<<
* self._run(mode)
* finally:
*/
/*try:*/ {
/* "uvloop/loop.pyx":1100
* finalizer=self._asyncgen_finalizer_hook)
* try:
* self._run(mode) # <<<<<<<<<<<<<<
* finally:
* self._set_coroutine_wrapper(False)
*/
__pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_run(__pyx_v_self, __pyx_v_mode); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1100, __pyx_L6_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
/* "uvloop/loop.pyx":1102
* self._run(mode)
* finally:
* self._set_coroutine_wrapper(False) # <<<<<<<<<<<<<<
* if self._asyncgens is not None:
* sys.set_asyncgen_hooks(*old_agen_hooks)
*/
/*finally:*/ {
/*normal exit:*/{
__pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_set_coroutine_wrapper(__pyx_v_self, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1102, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":1103
* finally:
* self._set_coroutine_wrapper(False)
* if self._asyncgens is not None: # <<<<<<<<<<<<<<
* sys.set_asyncgen_hooks(*old_agen_hooks)
*
*/
__pyx_t_3 = (__pyx_v_self->_asyncgens != Py_None);
__pyx_t_2 = (__pyx_t_3 != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":1104
* self._set_coroutine_wrapper(False)
* if self._asyncgens is not None:
* sys.set_asyncgen_hooks(*old_agen_hooks) # <<<<<<<<<<<<<<
*
* def close(self):
*/
__pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1104, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_set_asyncgen_hooks); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1104, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (unlikely(!__pyx_v_old_agen_hooks)) { __Pyx_RaiseUnboundLocalError("old_agen_hooks"); __PYX_ERR(1, 1104, __pyx_L1_error) }
__pyx_t_4 = PySequence_Tuple(__pyx_v_old_agen_hooks); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1104, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1104, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":1103
* finally:
* self._set_coroutine_wrapper(False)
* if self._asyncgens is not None: # <<<<<<<<<<<<<<
* sys.set_asyncgen_hooks(*old_agen_hooks)
*
*/
}
goto __pyx_L7;
}
/*exception exit:*/{
__Pyx_PyThreadState_declare
__pyx_L6_error:;
__pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14);
if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11) < 0)) __Pyx_ErrFetch(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11);
__Pyx_XGOTREF(__pyx_t_9);
__Pyx_XGOTREF(__pyx_t_10);
__Pyx_XGOTREF(__pyx_t_11);
__Pyx_XGOTREF(__pyx_t_12);
__Pyx_XGOTREF(__pyx_t_13);
__Pyx_XGOTREF(__pyx_t_14);
__pyx_t_6 = __pyx_lineno; __pyx_t_7 = __pyx_clineno; __pyx_t_8 = __pyx_filename;
{
/* "uvloop/loop.pyx":1102
* self._run(mode)
* finally:
* self._set_coroutine_wrapper(False) # <<<<<<<<<<<<<<
* if self._asyncgens is not None:
* sys.set_asyncgen_hooks(*old_agen_hooks)
*/
__pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_set_coroutine_wrapper(__pyx_v_self, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1102, __pyx_L10_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":1103
* finally:
* self._set_coroutine_wrapper(False)
* if self._asyncgens is not None: # <<<<<<<<<<<<<<
* sys.set_asyncgen_hooks(*old_agen_hooks)
*
*/
__pyx_t_2 = (__pyx_v_self->_asyncgens != Py_None);
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1104
* self._set_coroutine_wrapper(False)
* if self._asyncgens is not None:
* sys.set_asyncgen_hooks(*old_agen_hooks) # <<<<<<<<<<<<<<
*
* def close(self):
*/
__pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_sys); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1104, __pyx_L10_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_set_asyncgen_hooks); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1104, __pyx_L10_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
if (unlikely(!__pyx_v_old_agen_hooks)) { __Pyx_RaiseUnboundLocalError("old_agen_hooks"); __PYX_ERR(1, 1104, __pyx_L10_error) }
__pyx_t_5 = PySequence_Tuple(__pyx_v_old_agen_hooks); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1104, __pyx_L10_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1104, __pyx_L10_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1103
* finally:
* self._set_coroutine_wrapper(False)
* if self._asyncgens is not None: # <<<<<<<<<<<<<<
* sys.set_asyncgen_hooks(*old_agen_hooks)
*
*/
}
}
__Pyx_PyThreadState_assign
if (PY_MAJOR_VERSION >= 3) {
__Pyx_XGIVEREF(__pyx_t_12);
__Pyx_XGIVEREF(__pyx_t_13);
__Pyx_XGIVEREF(__pyx_t_14);
__Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14);
}
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_XGIVEREF(__pyx_t_10);
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_ErrRestore(__pyx_t_9, __pyx_t_10, __pyx_t_11);
__pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
__pyx_lineno = __pyx_t_6; __pyx_clineno = __pyx_t_7; __pyx_filename = __pyx_t_8;
goto __pyx_L1_error;
__pyx_L10_error:;
__Pyx_PyThreadState_assign
if (PY_MAJOR_VERSION >= 3) {
__Pyx_XGIVEREF(__pyx_t_12);
__Pyx_XGIVEREF(__pyx_t_13);
__Pyx_XGIVEREF(__pyx_t_14);
__Pyx_ExceptionReset(__pyx_t_12, __pyx_t_13, __pyx_t_14);
}
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0;
goto __pyx_L1_error;
}
__pyx_L7:;
}
/* "uvloop/loop.pyx":1086
* None))
*
* def run_forever(self): # <<<<<<<<<<<<<<
* """Run the event loop until stop() is called."""
* self._check_closed()
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("uvloop.loop.Loop.run_forever", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_old_agen_hooks);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1106
* sys.set_asyncgen_hooks(*old_agen_hooks)
*
* def close(self): # <<<<<<<<<<<<<<
* """Close the event loop.
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_27close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_26close[] = "Loop.close(self)\nClose the event loop.\n\n The event loop must not be running.\n\n This is idempotent and irreversible.\n\n No other methods should be called after this one.\n ";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_27close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("close (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_26close(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_26close(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("close", 0);
/* "uvloop/loop.pyx":1115
* No other methods should be called after this one.
* """
* self._close() # <<<<<<<<<<<<<<
*
* def get_debug(self):
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_close(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1115, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1106
* sys.set_asyncgen_hooks(*old_agen_hooks)
*
* def close(self): # <<<<<<<<<<<<<<
* """Close the event loop.
*
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop.close", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1117
* self._close()
*
* def get_debug(self): # <<<<<<<<<<<<<<
* return bool(self._debug)
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_29get_debug(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_28get_debug[] = "Loop.get_debug(self)";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_29get_debug(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("get_debug (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_28get_debug(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_28get_debug(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
__Pyx_RefNannySetupContext("get_debug", 0);
/* "uvloop/loop.pyx":1118
*
* def get_debug(self):
* return bool(self._debug) # <<<<<<<<<<<<<<
*
* def set_debug(self, enabled):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __pyx_v_self->_debug;
__pyx_t_2 = __Pyx_PyBool_FromLong((!(!__pyx_t_1))); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1118, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
/* "uvloop/loop.pyx":1117
* self._close()
*
* def get_debug(self): # <<<<<<<<<<<<<<
* return bool(self._debug)
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_AddTraceback("uvloop.loop.Loop.get_debug", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1120
* return bool(self._debug)
*
* def set_debug(self, enabled): # <<<<<<<<<<<<<<
* self._debug = bool(enabled)
* if self.is_running():
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_31set_debug(PyObject *__pyx_v_self, PyObject *__pyx_v_enabled); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_30set_debug[] = "Loop.set_debug(self, enabled)";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_31set_debug(PyObject *__pyx_v_self, PyObject *__pyx_v_enabled) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("set_debug (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_30set_debug(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_enabled));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_30set_debug(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_enabled) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
__Pyx_RefNannySetupContext("set_debug", 0);
/* "uvloop/loop.pyx":1121
*
* def set_debug(self, enabled):
* self._debug = bool(enabled) # <<<<<<<<<<<<<<
* if self.is_running():
* self._set_coroutine_wrapper(self._debug)
*/
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_enabled); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 1121, __pyx_L1_error)
__pyx_v_self->_debug = (!(!__pyx_t_1));
/* "uvloop/loop.pyx":1122
* def set_debug(self, enabled):
* self._debug = bool(enabled)
* if self.is_running(): # <<<<<<<<<<<<<<
* self._set_coroutine_wrapper(self._debug)
*
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_is_running); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1122, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (__pyx_t_4) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1122, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
__pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1122, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 1122, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
if (__pyx_t_1) {
/* "uvloop/loop.pyx":1123
* self._debug = bool(enabled)
* if self.is_running():
* self._set_coroutine_wrapper(self._debug) # <<<<<<<<<<<<<<
*
* def is_running(self):
*/
__pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_set_coroutine_wrapper(__pyx_v_self, __pyx_v_self->_debug); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1123, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":1122
* def set_debug(self, enabled):
* self._debug = bool(enabled)
* if self.is_running(): # <<<<<<<<<<<<<<
* self._set_coroutine_wrapper(self._debug)
*
*/
}
/* "uvloop/loop.pyx":1120
* return bool(self._debug)
*
* def set_debug(self, enabled): # <<<<<<<<<<<<<<
* self._debug = bool(enabled)
* if self.is_running():
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_AddTraceback("uvloop.loop.Loop.set_debug", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1125
* self._set_coroutine_wrapper(self._debug)
*
* def is_running(self): # <<<<<<<<<<<<<<
* """Return whether the event loop is currently running."""
* return bool(self._running)
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_33is_running(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_32is_running[] = "Loop.is_running(self)\nReturn whether the event loop is currently running.";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_33is_running(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("is_running (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_32is_running(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_32is_running(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
__Pyx_RefNannySetupContext("is_running", 0);
/* "uvloop/loop.pyx":1127
* def is_running(self):
* """Return whether the event loop is currently running."""
* return bool(self._running) # <<<<<<<<<<<<<<
*
* def is_closed(self):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __pyx_v_self->_running;
__pyx_t_2 = __Pyx_PyBool_FromLong((!(!__pyx_t_1))); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1127, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
/* "uvloop/loop.pyx":1125
* self._set_coroutine_wrapper(self._debug)
*
* def is_running(self): # <<<<<<<<<<<<<<
* """Return whether the event loop is currently running."""
* return bool(self._running)
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_AddTraceback("uvloop.loop.Loop.is_running", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1129
* return bool(self._running)
*
* def is_closed(self): # <<<<<<<<<<<<<<
* """Returns True if the event loop was closed."""
* return bool(self._closed)
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_35is_closed(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_34is_closed[] = "Loop.is_closed(self)\nReturns True if the event loop was closed.";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_35is_closed(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("is_closed (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_34is_closed(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_34is_closed(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
__Pyx_RefNannySetupContext("is_closed", 0);
/* "uvloop/loop.pyx":1131
* def is_closed(self):
* """Returns True if the event loop was closed."""
* return bool(self._closed) # <<<<<<<<<<<<<<
*
* def create_future(self):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __pyx_v_self->_closed;
__pyx_t_2 = __Pyx_PyBool_FromLong((!(!__pyx_t_1))); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1131, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_r = __pyx_t_2;
__pyx_t_2 = 0;
goto __pyx_L0;
/* "uvloop/loop.pyx":1129
* return bool(self._running)
*
* def is_closed(self): # <<<<<<<<<<<<<<
* """Returns True if the event loop was closed."""
* return bool(self._closed)
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_AddTraceback("uvloop.loop.Loop.is_closed", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1133
* return bool(self._closed)
*
* def create_future(self): # <<<<<<<<<<<<<<
* """Create a Future object attached to the loop."""
* return self._new_future()
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_37create_future(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_36create_future[] = "Loop.create_future(self)\nCreate a Future object attached to the loop.";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_37create_future(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("create_future (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_36create_future(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_36create_future(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("create_future", 0);
/* "uvloop/loop.pyx":1135
* def create_future(self):
* """Create a Future object attached to the loop."""
* return self._new_future() # <<<<<<<<<<<<<<
*
* def create_task(self, coro):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1135, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* "uvloop/loop.pyx":1133
* return bool(self._closed)
*
* def create_future(self): # <<<<<<<<<<<<<<
* """Create a Future object attached to the loop."""
* return self._new_future()
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop.create_future", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1137
* return self._new_future()
*
* def create_task(self, coro): # <<<<<<<<<<<<<<
* """Schedule a coroutine object.
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_39create_task(PyObject *__pyx_v_self, PyObject *__pyx_v_coro); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_38create_task[] = "Loop.create_task(self, coro)\nSchedule a coroutine object.\n\n Return a task object.\n ";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_39create_task(PyObject *__pyx_v_self, PyObject *__pyx_v_coro) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("create_task (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_38create_task(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_coro));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_38create_task(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_coro) {
PyObject *__pyx_v_task = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_t_2;
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_t_6;
PyObject *__pyx_t_7 = NULL;
__Pyx_RefNannySetupContext("create_task", 0);
/* "uvloop/loop.pyx":1142
* Return a task object.
* """
* self._check_closed() # <<<<<<<<<<<<<<
* if self._task_factory is None:
* task = task_factory(coro, loop=self)
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__check_closed(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1142, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1143
* """
* self._check_closed()
* if self._task_factory is None: # <<<<<<<<<<<<<<
* task = task_factory(coro, loop=self)
* else:
*/
__pyx_t_2 = (__pyx_v_self->_task_factory == Py_None);
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1144
* self._check_closed()
* if self._task_factory is None:
* task = task_factory(coro, loop=self) # <<<<<<<<<<<<<<
* else:
* task = self._task_factory(self, coro)
*/
__pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1144, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_coro);
__Pyx_GIVEREF(__pyx_v_coro);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_coro);
__pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1144, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_loop, ((PyObject *)__pyx_v_self)) < 0) __PYX_ERR(1, 1144, __pyx_L1_error)
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_v_6uvloop_4loop_task_factory, __pyx_t_1, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1144, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_v_task = __pyx_t_5;
__pyx_t_5 = 0;
/* "uvloop/loop.pyx":1143
* """
* self._check_closed()
* if self._task_factory is None: # <<<<<<<<<<<<<<
* task = task_factory(coro, loop=self)
* else:
*/
goto __pyx_L3;
}
/* "uvloop/loop.pyx":1146
* task = task_factory(coro, loop=self)
* else:
* task = self._task_factory(self, coro) # <<<<<<<<<<<<<<
* return task
*
*/
/*else*/ {
__Pyx_INCREF(__pyx_v_self->_task_factory);
__pyx_t_4 = __pyx_v_self->_task_factory; __pyx_t_1 = NULL;
__pyx_t_6 = 0;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_1 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_1)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_1);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
__pyx_t_6 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[3] = {__pyx_t_1, ((PyObject *)__pyx_v_self), __pyx_v_coro};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1146, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[3] = {__pyx_t_1, ((PyObject *)__pyx_v_self), __pyx_v_coro};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1146, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else
#endif
{
__pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1146, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
if (__pyx_t_1) {
__Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_1); __pyx_t_1 = NULL;
}
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_v_self));
PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, ((PyObject *)__pyx_v_self));
__Pyx_INCREF(__pyx_v_coro);
__Pyx_GIVEREF(__pyx_v_coro);
PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_v_coro);
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1146, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_v_task = __pyx_t_5;
__pyx_t_5 = 0;
}
__pyx_L3:;
/* "uvloop/loop.pyx":1147
* else:
* task = self._task_factory(self, coro)
* return task # <<<<<<<<<<<<<<
*
* def set_task_factory(self, factory):
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v_task);
__pyx_r = __pyx_v_task;
goto __pyx_L0;
/* "uvloop/loop.pyx":1137
* return self._new_future()
*
* def create_task(self, coro): # <<<<<<<<<<<<<<
* """Schedule a coroutine object.
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_AddTraceback("uvloop.loop.Loop.create_task", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_task);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1149
* return task
*
* def set_task_factory(self, factory): # <<<<<<<<<<<<<<
* """Set a task factory that will be used by loop.create_task().
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_41set_task_factory(PyObject *__pyx_v_self, PyObject *__pyx_v_factory); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_40set_task_factory[] = "Loop.set_task_factory(self, factory)\nSet a task factory that will be used by loop.create_task().\n\n If factory is None the default task factory will be set.\n\n If factory is a callable, it should have a signature matching\n '(loop, coro)', where 'loop' will be a reference to the active\n event loop, 'coro' will be a coroutine object. The callable\n must return a Future.\n ";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_41set_task_factory(PyObject *__pyx_v_self, PyObject *__pyx_v_factory) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("set_task_factory (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_40set_task_factory(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_factory));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_40set_task_factory(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_factory) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
__Pyx_RefNannySetupContext("set_task_factory", 0);
/* "uvloop/loop.pyx":1159
* must return a Future.
* """
* if factory is not None and not callable(factory): # <<<<<<<<<<<<<<
* raise TypeError('task factory must be a callable or None')
* self._task_factory = factory
*/
__pyx_t_2 = (__pyx_v_factory != Py_None);
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
} else {
__pyx_t_1 = __pyx_t_3;
goto __pyx_L4_bool_binop_done;
}
__pyx_t_3 = __Pyx_PyCallable_Check(__pyx_v_factory); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(1, 1159, __pyx_L1_error)
__pyx_t_2 = ((!(__pyx_t_3 != 0)) != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L4_bool_binop_done:;
if (__pyx_t_1) {
/* "uvloop/loop.pyx":1160
* """
* if factory is not None and not callable(factory):
* raise TypeError('task factory must be a callable or None') # <<<<<<<<<<<<<<
* self._task_factory = factory
*
*/
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__41, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1160, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__PYX_ERR(1, 1160, __pyx_L1_error)
/* "uvloop/loop.pyx":1159
* must return a Future.
* """
* if factory is not None and not callable(factory): # <<<<<<<<<<<<<<
* raise TypeError('task factory must be a callable or None')
* self._task_factory = factory
*/
}
/* "uvloop/loop.pyx":1161
* if factory is not None and not callable(factory):
* raise TypeError('task factory must be a callable or None')
* self._task_factory = factory # <<<<<<<<<<<<<<
*
* def get_task_factory(self):
*/
__Pyx_INCREF(__pyx_v_factory);
__Pyx_GIVEREF(__pyx_v_factory);
__Pyx_GOTREF(__pyx_v_self->_task_factory);
__Pyx_DECREF(__pyx_v_self->_task_factory);
__pyx_v_self->_task_factory = __pyx_v_factory;
/* "uvloop/loop.pyx":1149
* return task
*
* def set_task_factory(self, factory): # <<<<<<<<<<<<<<
* """Set a task factory that will be used by loop.create_task().
*
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_4);
__Pyx_AddTraceback("uvloop.loop.Loop.set_task_factory", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1163
* self._task_factory = factory
*
* def get_task_factory(self): # <<<<<<<<<<<<<<
* """Return a task factory, or None if the default one is in use."""
* return self._task_factory
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_43get_task_factory(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_42get_task_factory[] = "Loop.get_task_factory(self)\nReturn a task factory, or None if the default one is in use.";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_43get_task_factory(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("get_task_factory (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_42get_task_factory(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_42get_task_factory(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("get_task_factory", 0);
/* "uvloop/loop.pyx":1165
* def get_task_factory(self):
* """Return a task factory, or None if the default one is in use."""
* return self._task_factory # <<<<<<<<<<<<<<
*
* def run_until_complete(self, future):
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v_self->_task_factory);
__pyx_r = __pyx_v_self->_task_factory;
goto __pyx_L0;
/* "uvloop/loop.pyx":1163
* self._task_factory = factory
*
* def get_task_factory(self): # <<<<<<<<<<<<<<
* """Return a task factory, or None if the default one is in use."""
* return self._task_factory
*/
/* function exit code */
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1167
* return self._task_factory
*
* def run_until_complete(self, future): # <<<<<<<<<<<<<<
* """Run until the Future is done.
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_45run_until_complete(PyObject *__pyx_v_self, PyObject *__pyx_v_future); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_44run_until_complete[] = "Loop.run_until_complete(self, future)\nRun until the Future is done.\n\n If the argument is a coroutine, it is wrapped in a Task.\n\n WARNING: It would be disastrous to call run_until_complete()\n with the same coroutine twice -- it would wrap it in two\n different Tasks and that can't be good.\n\n Return the Future's result, or raise its exception.\n ";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_45run_until_complete(PyObject *__pyx_v_self, PyObject *__pyx_v_future) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("run_until_complete (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_44run_until_complete(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_future));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1187
* future._log_destroy_pending = False
*
* done_cb = lambda fut: self.stop() # <<<<<<<<<<<<<<
*
* future.add_done_callback(done_cb)
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_18run_until_complete_lambda1(PyObject *__pyx_self, PyObject *__pyx_v_fut); /*proto*/
static PyMethodDef __pyx_mdef_6uvloop_4loop_4Loop_18run_until_complete_lambda1 = {"lambda1", (PyCFunction)__pyx_pw_6uvloop_4loop_4Loop_18run_until_complete_lambda1, METH_O, 0};
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_18run_until_complete_lambda1(PyObject *__pyx_self, PyObject *__pyx_v_fut) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("lambda1 (wrapper)", 0);
__pyx_r = __pyx_lambda_funcdef_lambda1(__pyx_self, ((PyObject *)__pyx_v_fut));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_lambda_funcdef_lambda1(PyObject *__pyx_self, CYTHON_UNUSED PyObject *__pyx_v_fut) {
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete *__pyx_cur_scope;
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete *__pyx_outer_scope;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
__Pyx_RefNannySetupContext("lambda1", 0);
__pyx_outer_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete *) __Pyx_CyFunction_GetClosure(__pyx_self);
__pyx_cur_scope = __pyx_outer_scope;
__Pyx_XDECREF(__pyx_r);
if (unlikely(!__pyx_cur_scope->__pyx_v_self)) { __Pyx_RaiseClosureNameError("self"); __PYX_ERR(1, 1187, __pyx_L1_error) }
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_stop); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1187, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (__pyx_t_3) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1187, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1187, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_AddTraceback("uvloop.loop.Loop.run_until_complete.lambda1", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1167
* return self._task_factory
*
* def run_until_complete(self, future): # <<<<<<<<<<<<<<
* """Run until the Future is done.
*
*/
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_44run_until_complete(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_future) {
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete *__pyx_cur_scope;
int __pyx_v_new_task;
PyObject *__pyx_v_done_cb = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
int __pyx_t_9;
PyObject *__pyx_t_10 = NULL;
PyObject *__pyx_t_11 = NULL;
int __pyx_t_12;
__Pyx_RefNannySetupContext("run_until_complete", 0);
__pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_3_run_until_complete(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_3_run_until_complete, __pyx_empty_tuple, NULL);
if (unlikely(!__pyx_cur_scope)) {
__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_3_run_until_complete *)Py_None);
__Pyx_INCREF(Py_None);
__PYX_ERR(1, 1167, __pyx_L1_error)
} else {
__Pyx_GOTREF(__pyx_cur_scope);
}
__pyx_cur_scope->__pyx_v_self = __pyx_v_self;
__Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__Pyx_INCREF(__pyx_v_future);
/* "uvloop/loop.pyx":1178
* Return the Future's result, or raise its exception.
* """
* self._check_closed() # <<<<<<<<<<<<<<
*
* new_task = not isfuture(future)
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__check_closed(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1178, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1180
* self._check_closed()
*
* new_task = not isfuture(future) # <<<<<<<<<<<<<<
* future = aio_ensure_future(future, loop=self)
* if new_task:
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_isfuture(__pyx_v_future); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1180, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 1180, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_new_task = (!__pyx_t_2);
/* "uvloop/loop.pyx":1181
*
* new_task = not isfuture(future)
* future = aio_ensure_future(future, loop=self) # <<<<<<<<<<<<<<
* if new_task:
* # An exception is raised if the future didn't complete, so there
*/
__pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1181, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_future);
__Pyx_GIVEREF(__pyx_v_future);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_future);
__pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1181, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_loop, ((PyObject *)__pyx_cur_scope->__pyx_v_self)) < 0) __PYX_ERR(1, 1181, __pyx_L1_error)
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_v_6uvloop_4loop_aio_ensure_future, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1181, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF_SET(__pyx_v_future, __pyx_t_4);
__pyx_t_4 = 0;
/* "uvloop/loop.pyx":1182
* new_task = not isfuture(future)
* future = aio_ensure_future(future, loop=self)
* if new_task: # <<<<<<<<<<<<<<
* # An exception is raised if the future didn't complete, so there
* # is no need to log the "destroy pending task" message
*/
__pyx_t_2 = (__pyx_v_new_task != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":1185
* # An exception is raised if the future didn't complete, so there
* # is no need to log the "destroy pending task" message
* future._log_destroy_pending = False # <<<<<<<<<<<<<<
*
* done_cb = lambda fut: self.stop()
*/
if (__Pyx_PyObject_SetAttrStr(__pyx_v_future, __pyx_n_s_log_destroy_pending, Py_False) < 0) __PYX_ERR(1, 1185, __pyx_L1_error)
/* "uvloop/loop.pyx":1182
* new_task = not isfuture(future)
* future = aio_ensure_future(future, loop=self)
* if new_task: # <<<<<<<<<<<<<<
* # An exception is raised if the future didn't complete, so there
* # is no need to log the "destroy pending task" message
*/
}
/* "uvloop/loop.pyx":1187
* future._log_destroy_pending = False
*
* done_cb = lambda fut: self.stop() # <<<<<<<<<<<<<<
*
* future.add_done_callback(done_cb)
*/
__pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_6uvloop_4loop_4Loop_18run_until_complete_lambda1, 0, __pyx_n_s_run_until_complete_locals_lambda, ((PyObject*)__pyx_cur_scope), __pyx_n_s_uvloop_loop, __pyx_d, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1187, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_v_done_cb = __pyx_t_4;
__pyx_t_4 = 0;
/* "uvloop/loop.pyx":1189
* done_cb = lambda fut: self.stop()
*
* future.add_done_callback(done_cb) # <<<<<<<<<<<<<<
* try:
* self.run_forever()
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_future, __pyx_n_s_add_done_callback); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1189, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_1 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_1)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_1);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (!__pyx_t_1) {
__pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_done_cb); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1189, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_v_done_cb};
__pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1189, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_GOTREF(__pyx_t_4);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_1, __pyx_v_done_cb};
__pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1189, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_GOTREF(__pyx_t_4);
} else
#endif
{
__pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1189, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1); __pyx_t_1 = NULL;
__Pyx_INCREF(__pyx_v_done_cb);
__Pyx_GIVEREF(__pyx_v_done_cb);
PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_done_cb);
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1189, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":1190
*
* future.add_done_callback(done_cb)
* try: # <<<<<<<<<<<<<<
* self.run_forever()
* except:
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8);
__Pyx_XGOTREF(__pyx_t_6);
__Pyx_XGOTREF(__pyx_t_7);
__Pyx_XGOTREF(__pyx_t_8);
/*try:*/ {
/* "uvloop/loop.pyx":1191
* future.add_done_callback(done_cb)
* try:
* self.run_forever() # <<<<<<<<<<<<<<
* except:
* if new_task and future.done() and not future.cancelled():
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_run_forever); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1191, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (__pyx_t_5) {
__pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1191, __pyx_L4_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
__pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1191, __pyx_L4_error)
}
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":1190
*
* future.add_done_callback(done_cb)
* try: # <<<<<<<<<<<<<<
* self.run_forever()
* except:
*/
}
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
goto __pyx_L11_try_end;
__pyx_L4_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":1192
* try:
* self.run_forever()
* except: # <<<<<<<<<<<<<<
* if new_task and future.done() and not future.cancelled():
* # The coroutine raised a BaseException. Consume the exception
*/
/*except:*/ {
__Pyx_AddTraceback("uvloop.loop.Loop.run_until_complete", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_3, &__pyx_t_5) < 0) __PYX_ERR(1, 1192, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GOTREF(__pyx_t_5);
/* "uvloop/loop.pyx":1193
* self.run_forever()
* except:
* if new_task and future.done() and not future.cancelled(): # <<<<<<<<<<<<<<
* # The coroutine raised a BaseException. Consume the exception
* # to not log a warning, the caller doesn't have access to the
*/
__pyx_t_9 = (__pyx_v_new_task != 0);
if (__pyx_t_9) {
} else {
__pyx_t_2 = __pyx_t_9;
goto __pyx_L15_bool_binop_done;
}
__pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_future, __pyx_n_s_done); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 1193, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_10);
__pyx_t_11 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) {
__pyx_t_11 = PyMethod_GET_SELF(__pyx_t_10);
if (likely(__pyx_t_11)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
__Pyx_INCREF(__pyx_t_11);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_10, function);
}
}
if (__pyx_t_11) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1193, __pyx_L6_except_error)
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1193, __pyx_L6_except_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(1, 1193, __pyx_L6_except_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (__pyx_t_9) {
} else {
__pyx_t_2 = __pyx_t_9;
goto __pyx_L15_bool_binop_done;
}
__pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_future, __pyx_n_s_cancelled); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 1193, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_10);
__pyx_t_11 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) {
__pyx_t_11 = PyMethod_GET_SELF(__pyx_t_10);
if (likely(__pyx_t_11)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
__Pyx_INCREF(__pyx_t_11);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_10, function);
}
}
if (__pyx_t_11) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1193, __pyx_L6_except_error)
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1193, __pyx_L6_except_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(1, 1193, __pyx_L6_except_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_12 = ((!__pyx_t_9) != 0);
__pyx_t_2 = __pyx_t_12;
__pyx_L15_bool_binop_done:;
if (__pyx_t_2) {
/* "uvloop/loop.pyx":1197
* # to not log a warning, the caller doesn't have access to the
* # local task.
* future.exception() # <<<<<<<<<<<<<<
* raise
* future.remove_done_callback(done_cb)
*/
__pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_future, __pyx_n_s_exception); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 1197, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_10);
__pyx_t_11 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) {
__pyx_t_11 = PyMethod_GET_SELF(__pyx_t_10);
if (likely(__pyx_t_11)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
__Pyx_INCREF(__pyx_t_11);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_10, function);
}
}
if (__pyx_t_11) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1197, __pyx_L6_except_error)
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1197, __pyx_L6_except_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1193
* self.run_forever()
* except:
* if new_task and future.done() and not future.cancelled(): # <<<<<<<<<<<<<<
* # The coroutine raised a BaseException. Consume the exception
* # to not log a warning, the caller doesn't have access to the
*/
}
/* "uvloop/loop.pyx":1198
* # local task.
* future.exception()
* raise # <<<<<<<<<<<<<<
* future.remove_done_callback(done_cb)
* if not future.done():
*/
__Pyx_GIVEREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_3);
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_ErrRestoreWithState(__pyx_t_4, __pyx_t_3, __pyx_t_5);
__pyx_t_4 = 0; __pyx_t_3 = 0; __pyx_t_5 = 0;
__PYX_ERR(1, 1198, __pyx_L6_except_error)
}
__pyx_L6_except_error:;
/* "uvloop/loop.pyx":1190
*
* future.add_done_callback(done_cb)
* try: # <<<<<<<<<<<<<<
* self.run_forever()
* except:
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
goto __pyx_L1_error;
__pyx_L11_try_end:;
}
/* "uvloop/loop.pyx":1199
* future.exception()
* raise
* future.remove_done_callback(done_cb) # <<<<<<<<<<<<<<
* if not future.done():
* raise RuntimeError('Event loop stopped before Future completed.')
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_future, __pyx_n_s_remove_done_callback); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1199, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (!__pyx_t_4) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_done_cb); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1199, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_done_cb};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1199, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_done_cb};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1199, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else
#endif
{
__pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1199, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_4); __pyx_t_4 = NULL;
__Pyx_INCREF(__pyx_v_done_cb);
__Pyx_GIVEREF(__pyx_v_done_cb);
PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_v_done_cb);
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_1, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1199, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":1200
* raise
* future.remove_done_callback(done_cb)
* if not future.done(): # <<<<<<<<<<<<<<
* raise RuntimeError('Event loop stopped before Future completed.')
*
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_future, __pyx_n_s_done); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1200, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_1 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_1)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_1);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (__pyx_t_1) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1200, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
__pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1200, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 1200, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_12 = ((!__pyx_t_2) != 0);
if (__pyx_t_12) {
/* "uvloop/loop.pyx":1201
* future.remove_done_callback(done_cb)
* if not future.done():
* raise RuntimeError('Event loop stopped before Future completed.') # <<<<<<<<<<<<<<
*
* return future.result()
*/
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__42, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1201, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_Raise(__pyx_t_5, 0, 0, 0);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__PYX_ERR(1, 1201, __pyx_L1_error)
/* "uvloop/loop.pyx":1200
* raise
* future.remove_done_callback(done_cb)
* if not future.done(): # <<<<<<<<<<<<<<
* raise RuntimeError('Event loop stopped before Future completed.')
*
*/
}
/* "uvloop/loop.pyx":1203
* raise RuntimeError('Event loop stopped before Future completed.')
*
* return future.result() # <<<<<<<<<<<<<<
*
* def getaddrinfo(self, object host, object port, *,
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_future, __pyx_n_s_result); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1203, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_1 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_1 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_1)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_1);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (__pyx_t_1) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1203, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else {
__pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1203, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_r = __pyx_t_5;
__pyx_t_5 = 0;
goto __pyx_L0;
/* "uvloop/loop.pyx":1167
* return self._task_factory
*
* def run_until_complete(self, future): # <<<<<<<<<<<<<<
* """Run until the Future is done.
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_10);
__Pyx_XDECREF(__pyx_t_11);
__Pyx_AddTraceback("uvloop.loop.Loop.run_until_complete", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_done_cb);
__Pyx_XDECREF(__pyx_v_future);
__Pyx_DECREF(((PyObject *)__pyx_cur_scope));
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1205
* return future.result()
*
* def getaddrinfo(self, object host, object port, *, # <<<<<<<<<<<<<<
* int family=0, int type=0, int proto=0, int flags=0):
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_47getaddrinfo(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_46getaddrinfo[] = "Loop.getaddrinfo(self, host, port, *, int family=0, int type=0, int proto=0, int flags=0)";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_47getaddrinfo(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_host = 0;
PyObject *__pyx_v_port = 0;
int __pyx_v_family;
int __pyx_v_type;
int __pyx_v_proto;
int __pyx_v_flags;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("getaddrinfo (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_host,&__pyx_n_s_port,&__pyx_n_s_family,&__pyx_n_s_type,&__pyx_n_s_proto,&__pyx_n_s_flags,0};
PyObject* values[6] = {0,0,0,0,0,0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_host)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_port)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("getaddrinfo", 1, 2, 2, 1); __PYX_ERR(1, 1205, __pyx_L3_error)
}
}
if (kw_args > 0 && likely(kw_args <= 4)) {
Py_ssize_t index;
for (index = 2; index < 6 && kw_args > 0; index++) {
PyObject* value = PyDict_GetItem(__pyx_kwds, *__pyx_pyargnames[index]);
if (value) { values[index] = value; kw_args--; }
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getaddrinfo") < 0)) __PYX_ERR(1, 1205, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
}
__pyx_v_host = values[0];
__pyx_v_port = values[1];
if (values[2]) {
__pyx_v_family = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_family == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1206, __pyx_L3_error)
} else {
__pyx_v_family = ((int)0);
}
if (values[3]) {
__pyx_v_type = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_type == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1206, __pyx_L3_error)
} else {
__pyx_v_type = ((int)0);
}
if (values[4]) {
__pyx_v_proto = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_proto == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1206, __pyx_L3_error)
} else {
__pyx_v_proto = ((int)0);
}
if (values[5]) {
__pyx_v_flags = __Pyx_PyInt_As_int(values[5]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1206, __pyx_L3_error)
} else {
__pyx_v_flags = ((int)0);
}
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("getaddrinfo", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1205, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.getaddrinfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_46getaddrinfo(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_host, __pyx_v_port, __pyx_v_family, __pyx_v_type, __pyx_v_proto, __pyx_v_flags);
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_46getaddrinfo(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_host, PyObject *__pyx_v_port, int __pyx_v_family, int __pyx_v_type, int __pyx_v_proto, int __pyx_v_flags) {
PyObject *__pyx_v_addr = NULL;
PyObject *__pyx_v_fut = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_t_2;
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
__Pyx_RefNannySetupContext("getaddrinfo", 0);
/* "uvloop/loop.pyx":1208
* int family=0, int type=0, int proto=0, int flags=0):
*
* addr = __static_getaddrinfo_pyaddr(host, port, family, # <<<<<<<<<<<<<<
* type, proto, flags)
* if addr is not None:
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop___static_getaddrinfo_pyaddr(__pyx_v_host, __pyx_v_port, __pyx_v_family, __pyx_v_type, __pyx_v_proto, __pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1208, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_addr = __pyx_t_1;
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":1210
* addr = __static_getaddrinfo_pyaddr(host, port, family,
* type, proto, flags)
* if addr is not None: # <<<<<<<<<<<<<<
* fut = self._new_future()
* fut.set_result([addr])
*/
__pyx_t_2 = (__pyx_v_addr != Py_None);
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1211
* type, proto, flags)
* if addr is not None:
* fut = self._new_future() # <<<<<<<<<<<<<<
* fut.set_result([addr])
* return fut
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1211, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_fut = __pyx_t_1;
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":1212
* if addr is not None:
* fut = self._new_future()
* fut.set_result([addr]) # <<<<<<<<<<<<<<
* return fut
*
*/
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_fut, __pyx_n_s_set_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1212, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = PyList_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1212, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_v_addr);
__Pyx_GIVEREF(__pyx_v_addr);
PyList_SET_ITEM(__pyx_t_5, 0, __pyx_v_addr);
__pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (!__pyx_t_6) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1212, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5};
__pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1212, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_5};
__pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1212, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else
#endif
{
__pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1212, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1212, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1213
* fut = self._new_future()
* fut.set_result([addr])
* return fut # <<<<<<<<<<<<<<
*
* return self._getaddrinfo(host, port, family, type, proto, flags, 1)
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v_fut);
__pyx_r = __pyx_v_fut;
goto __pyx_L0;
/* "uvloop/loop.pyx":1210
* addr = __static_getaddrinfo_pyaddr(host, port, family,
* type, proto, flags)
* if addr is not None: # <<<<<<<<<<<<<<
* fut = self._new_future()
* fut.set_result([addr])
*/
}
/* "uvloop/loop.pyx":1215
* return fut
*
* return self._getaddrinfo(host, port, family, type, proto, flags, 1) # <<<<<<<<<<<<<<
*
* async def getnameinfo(self, sockaddr, int flags=0):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_getaddrinfo(__pyx_v_self, __pyx_v_host, __pyx_v_port, __pyx_v_family, __pyx_v_type, __pyx_v_proto, __pyx_v_flags, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1215, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* "uvloop/loop.pyx":1205
* return future.result()
*
* def getaddrinfo(self, object host, object port, *, # <<<<<<<<<<<<<<
* int family=0, int type=0, int proto=0, int flags=0):
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_AddTraceback("uvloop.loop.Loop.getaddrinfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_addr);
__Pyx_XDECREF(__pyx_v_fut);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_50generator(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */
/* "uvloop/loop.pyx":1217
* return self._getaddrinfo(host, port, family, type, proto, flags, 1)
*
* async def getnameinfo(self, sockaddr, int flags=0): # <<<<<<<<<<<<<<
* cdef:
* AddrInfo ai_cnt
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_49getnameinfo(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_48getnameinfo[] = "Loop.getnameinfo(self, sockaddr, int flags=0)";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_49getnameinfo(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_sockaddr = 0;
int __pyx_v_flags;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("getnameinfo (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sockaddr,&__pyx_n_s_flags,0};
PyObject* values[2] = {0,0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_sockaddr)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
case 1:
if (kw_args > 0) {
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_flags);
if (value) { values[1] = value; kw_args--; }
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getnameinfo") < 0)) __PYX_ERR(1, 1217, __pyx_L3_error)
}
} else {
switch (PyTuple_GET_SIZE(__pyx_args)) {
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
break;
default: goto __pyx_L5_argtuple_error;
}
}
__pyx_v_sockaddr = values[0];
if (values[1]) {
__pyx_v_flags = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1217, __pyx_L3_error)
} else {
__pyx_v_flags = ((int)0);
}
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("getnameinfo", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1217, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.getnameinfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_48getnameinfo(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_sockaddr, __pyx_v_flags);
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_48getnameinfo(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sockaddr, int __pyx_v_flags) {
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_4_getnameinfo *__pyx_cur_scope;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("getnameinfo", 0);
__pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_4_getnameinfo *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_4_getnameinfo(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_4_getnameinfo, __pyx_empty_tuple, NULL);
if (unlikely(!__pyx_cur_scope)) {
__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_4_getnameinfo *)Py_None);
__Pyx_INCREF(Py_None);
__PYX_ERR(1, 1217, __pyx_L1_error)
} else {
__Pyx_GOTREF(__pyx_cur_scope);
}
__pyx_cur_scope->__pyx_v_self = __pyx_v_self;
__Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__pyx_cur_scope->__pyx_v_sockaddr = __pyx_v_sockaddr;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_sockaddr);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sockaddr);
__pyx_cur_scope->__pyx_v_flags = __pyx_v_flags;
{
__pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_50generator, (PyObject *) __pyx_cur_scope, __pyx_n_s_getnameinfo, __pyx_n_s_Loop_getnameinfo, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(1, 1217, __pyx_L1_error)
__Pyx_DECREF(__pyx_cur_scope);
__Pyx_RefNannyFinishContext();
return (PyObject *) gen;
}
/* function exit code */
__pyx_L1_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.getnameinfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__Pyx_DECREF(((PyObject *)__pyx_cur_scope));
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_50generator(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */
{
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_4_getnameinfo *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_4_getnameinfo *)__pyx_generator->closure);
PyObject *__pyx_r = NULL;
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
Py_ssize_t __pyx_t_4;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
struct addrinfo *__pyx_t_7;
int __pyx_t_8;
unsigned long __pyx_t_9;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("None", 0);
switch (__pyx_generator->resume_label) {
case 0: goto __pyx_L3_first_run;
case 1: goto __pyx_L16_resume_from_yield;
case 2: goto __pyx_L20_resume_from_yield;
default: /* CPython raises the right error here */
__Pyx_RefNannyFinishContext();
return NULL;
}
__pyx_L3_first_run:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 1217, __pyx_L1_error)
/* "uvloop/loop.pyx":1223
* system.sockaddr_in6 *sin6
*
* if not isinstance(sockaddr, tuple): # <<<<<<<<<<<<<<
* raise TypeError('getnameinfo() argument 1 must be a tuple')
*
*/
__pyx_t_1 = PyTuple_Check(__pyx_cur_scope->__pyx_v_sockaddr);
__pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":1224
*
* if not isinstance(sockaddr, tuple):
* raise TypeError('getnameinfo() argument 1 must be a tuple') # <<<<<<<<<<<<<<
*
* sl = len(sockaddr)
*/
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__43, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1224, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 1224, __pyx_L1_error)
/* "uvloop/loop.pyx":1223
* system.sockaddr_in6 *sin6
*
* if not isinstance(sockaddr, tuple): # <<<<<<<<<<<<<<
* raise TypeError('getnameinfo() argument 1 must be a tuple')
*
*/
}
/* "uvloop/loop.pyx":1226
* raise TypeError('getnameinfo() argument 1 must be a tuple')
*
* sl = len(sockaddr) # <<<<<<<<<<<<<<
*
* if sl < 2 or sl > 4:
*/
__pyx_t_4 = PyObject_Length(__pyx_cur_scope->__pyx_v_sockaddr); if (unlikely(__pyx_t_4 == -1)) __PYX_ERR(1, 1226, __pyx_L1_error)
__pyx_cur_scope->__pyx_v_sl = __pyx_t_4;
/* "uvloop/loop.pyx":1228
* sl = len(sockaddr)
*
* if sl < 2 or sl > 4: # <<<<<<<<<<<<<<
* raise ValueError('sockaddr must be a tuple of 2, 3 or 4 values')
*
*/
__pyx_t_1 = ((__pyx_cur_scope->__pyx_v_sl < 2) != 0);
if (!__pyx_t_1) {
} else {
__pyx_t_2 = __pyx_t_1;
goto __pyx_L6_bool_binop_done;
}
__pyx_t_1 = ((__pyx_cur_scope->__pyx_v_sl > 4) != 0);
__pyx_t_2 = __pyx_t_1;
__pyx_L6_bool_binop_done:;
if (__pyx_t_2) {
/* "uvloop/loop.pyx":1229
*
* if sl < 2 or sl > 4:
* raise ValueError('sockaddr must be a tuple of 2, 3 or 4 values') # <<<<<<<<<<<<<<
*
* if sl > 2:
*/
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__44, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1229, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 1229, __pyx_L1_error)
/* "uvloop/loop.pyx":1228
* sl = len(sockaddr)
*
* if sl < 2 or sl > 4: # <<<<<<<<<<<<<<
* raise ValueError('sockaddr must be a tuple of 2, 3 or 4 values')
*
*/
}
/* "uvloop/loop.pyx":1231
* raise ValueError('sockaddr must be a tuple of 2, 3 or 4 values')
*
* if sl > 2: # <<<<<<<<<<<<<<
* flowinfo = sockaddr[2]
* if flowinfo < 0 or flowinfo > 0xfffff:
*/
__pyx_t_2 = ((__pyx_cur_scope->__pyx_v_sl > 2) != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":1232
*
* if sl > 2:
* flowinfo = sockaddr[2] # <<<<<<<<<<<<<<
* if flowinfo < 0 or flowinfo > 0xfffff:
* raise OverflowError(
*/
__pyx_t_3 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_sockaddr, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1232, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
__pyx_cur_scope->__pyx_v_flowinfo = __pyx_t_3;
__pyx_t_3 = 0;
/* "uvloop/loop.pyx":1233
* if sl > 2:
* flowinfo = sockaddr[2]
* if flowinfo < 0 or flowinfo > 0xfffff: # <<<<<<<<<<<<<<
* raise OverflowError(
* 'getsockaddrarg: flowinfo must be 0-1048575.')
*/
__pyx_t_3 = PyObject_RichCompare(__pyx_cur_scope->__pyx_v_flowinfo, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1233, __pyx_L1_error)
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 1233, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (!__pyx_t_1) {
} else {
__pyx_t_2 = __pyx_t_1;
goto __pyx_L10_bool_binop_done;
}
__pyx_t_3 = PyObject_RichCompare(__pyx_cur_scope->__pyx_v_flowinfo, __pyx_int_1048575, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1233, __pyx_L1_error)
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 1233, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_2 = __pyx_t_1;
__pyx_L10_bool_binop_done:;
if (__pyx_t_2) {
/* "uvloop/loop.pyx":1234
* flowinfo = sockaddr[2]
* if flowinfo < 0 or flowinfo > 0xfffff:
* raise OverflowError( # <<<<<<<<<<<<<<
* 'getsockaddrarg: flowinfo must be 0-1048575.')
* else:
*/
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_OverflowError, __pyx_tuple__45, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1234, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 1234, __pyx_L1_error)
/* "uvloop/loop.pyx":1233
* if sl > 2:
* flowinfo = sockaddr[2]
* if flowinfo < 0 or flowinfo > 0xfffff: # <<<<<<<<<<<<<<
* raise OverflowError(
* 'getsockaddrarg: flowinfo must be 0-1048575.')
*/
}
/* "uvloop/loop.pyx":1231
* raise ValueError('sockaddr must be a tuple of 2, 3 or 4 values')
*
* if sl > 2: # <<<<<<<<<<<<<<
* flowinfo = sockaddr[2]
* if flowinfo < 0 or flowinfo > 0xfffff:
*/
goto __pyx_L8;
}
/* "uvloop/loop.pyx":1237
* 'getsockaddrarg: flowinfo must be 0-1048575.')
* else:
* flowinfo = 0 # <<<<<<<<<<<<<<
*
* if sl > 3:
*/
/*else*/ {
__Pyx_INCREF(__pyx_int_0);
__Pyx_GIVEREF(__pyx_int_0);
__pyx_cur_scope->__pyx_v_flowinfo = __pyx_int_0;
}
__pyx_L8:;
/* "uvloop/loop.pyx":1239
* flowinfo = 0
*
* if sl > 3: # <<<<<<<<<<<<<<
* scope_id = sockaddr[3]
* if scope_id < 0 or scope_id > 2 ** 32:
*/
__pyx_t_2 = ((__pyx_cur_scope->__pyx_v_sl > 3) != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":1240
*
* if sl > 3:
* scope_id = sockaddr[3] # <<<<<<<<<<<<<<
* if scope_id < 0 or scope_id > 2 ** 32:
* raise OverflowError(
*/
__pyx_t_3 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_sockaddr, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1240, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
__pyx_cur_scope->__pyx_v_scope_id = __pyx_t_3;
__pyx_t_3 = 0;
/* "uvloop/loop.pyx":1241
* if sl > 3:
* scope_id = sockaddr[3]
* if scope_id < 0 or scope_id > 2 ** 32: # <<<<<<<<<<<<<<
* raise OverflowError(
* 'getsockaddrarg: scope_id must be unsigned 32 bit integer')
*/
__pyx_t_3 = PyObject_RichCompare(__pyx_cur_scope->__pyx_v_scope_id, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1241, __pyx_L1_error)
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 1241, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (!__pyx_t_1) {
} else {
__pyx_t_2 = __pyx_t_1;
goto __pyx_L14_bool_binop_done;
}
__pyx_t_3 = PyObject_RichCompare(__pyx_cur_scope->__pyx_v_scope_id, __pyx_int_4294967296, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1241, __pyx_L1_error)
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 1241, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_2 = __pyx_t_1;
__pyx_L14_bool_binop_done:;
if (__pyx_t_2) {
/* "uvloop/loop.pyx":1242
* scope_id = sockaddr[3]
* if scope_id < 0 or scope_id > 2 ** 32:
* raise OverflowError( # <<<<<<<<<<<<<<
* 'getsockaddrarg: scope_id must be unsigned 32 bit integer')
* else:
*/
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_OverflowError, __pyx_tuple__46, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1242, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 1242, __pyx_L1_error)
/* "uvloop/loop.pyx":1241
* if sl > 3:
* scope_id = sockaddr[3]
* if scope_id < 0 or scope_id > 2 ** 32: # <<<<<<<<<<<<<<
* raise OverflowError(
* 'getsockaddrarg: scope_id must be unsigned 32 bit integer')
*/
}
/* "uvloop/loop.pyx":1239
* flowinfo = 0
*
* if sl > 3: # <<<<<<<<<<<<<<
* scope_id = sockaddr[3]
* if scope_id < 0 or scope_id > 2 ** 32:
*/
goto __pyx_L12;
}
/* "uvloop/loop.pyx":1245
* 'getsockaddrarg: scope_id must be unsigned 32 bit integer')
* else:
* scope_id = 0 # <<<<<<<<<<<<<<
*
* ai_cnt = await self._getaddrinfo(
*/
/*else*/ {
__Pyx_INCREF(__pyx_int_0);
__Pyx_GIVEREF(__pyx_int_0);
__pyx_cur_scope->__pyx_v_scope_id = __pyx_int_0;
}
__pyx_L12:;
/* "uvloop/loop.pyx":1248
*
* ai_cnt = await self._getaddrinfo(
* sockaddr[0], sockaddr[1], # <<<<<<<<<<<<<<
* uv.AF_UNSPEC, # family
* uv.SOCK_DGRAM, # type
*/
__pyx_t_3 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_sockaddr, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1248, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_5 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_sockaddr, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1248, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
/* "uvloop/loop.pyx":1247
* scope_id = 0
*
* ai_cnt = await self._getaddrinfo( # <<<<<<<<<<<<<<
* sockaddr[0], sockaddr[1],
* uv.AF_UNSPEC, # family
*/
__pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_getaddrinfo(__pyx_cur_scope->__pyx_v_self, __pyx_t_3, __pyx_t_5, AF_UNSPEC, SOCK_DGRAM, 0, AI_NUMERICHOST, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1247, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_6);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XGOTREF(__pyx_r);
if (likely(__pyx_r)) {
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
/* return from generator, yielding value */
__pyx_generator->resume_label = 1;
return __pyx_r;
__pyx_L16_resume_from_yield:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 1247, __pyx_L1_error)
__pyx_t_6 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_6);
} else {
__pyx_t_6 = NULL;
if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_6) < 0) __PYX_ERR(1, 1247, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
}
if (!(likely(((__pyx_t_6) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_6, __pyx_ptype_6uvloop_4loop_AddrInfo))))) __PYX_ERR(1, 1247, __pyx_L1_error)
__Pyx_GIVEREF(__pyx_t_6);
__pyx_cur_scope->__pyx_v_ai_cnt = ((struct __pyx_obj_6uvloop_4loop_AddrInfo *)__pyx_t_6);
__pyx_t_6 = 0;
/* "uvloop/loop.pyx":1255
* 0) # unpack
*
* ai = ai_cnt.data # <<<<<<<<<<<<<<
*
* if ai.ai_next:
*/
__pyx_t_7 = __pyx_cur_scope->__pyx_v_ai_cnt->data;
__pyx_cur_scope->__pyx_v_ai = __pyx_t_7;
/* "uvloop/loop.pyx":1257
* ai = ai_cnt.data
*
* if ai.ai_next: # <<<<<<<<<<<<<<
* raise OSError("sockaddr resolved to multiple addresses")
*
*/
__pyx_t_2 = (__pyx_cur_scope->__pyx_v_ai->ai_next != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":1258
*
* if ai.ai_next:
* raise OSError("sockaddr resolved to multiple addresses") # <<<<<<<<<<<<<<
*
* if ai.ai_family == uv.AF_INET:
*/
__pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_tuple__47, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1258, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_Raise(__pyx_t_6, 0, 0, 0);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__PYX_ERR(1, 1258, __pyx_L1_error)
/* "uvloop/loop.pyx":1257
* ai = ai_cnt.data
*
* if ai.ai_next: # <<<<<<<<<<<<<<
* raise OSError("sockaddr resolved to multiple addresses")
*
*/
}
/* "uvloop/loop.pyx":1260
* raise OSError("sockaddr resolved to multiple addresses")
*
* if ai.ai_family == uv.AF_INET: # <<<<<<<<<<<<<<
* if sl > 2:
* raise OSError("IPv4 sockaddr must be 2 tuple")
*/
__pyx_t_2 = ((__pyx_cur_scope->__pyx_v_ai->ai_family == AF_INET) != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":1261
*
* if ai.ai_family == uv.AF_INET:
* if sl > 2: # <<<<<<<<<<<<<<
* raise OSError("IPv4 sockaddr must be 2 tuple")
* elif ai.ai_family == uv.AF_INET6:
*/
__pyx_t_2 = ((__pyx_cur_scope->__pyx_v_sl > 2) != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":1262
* if ai.ai_family == uv.AF_INET:
* if sl > 2:
* raise OSError("IPv4 sockaddr must be 2 tuple") # <<<<<<<<<<<<<<
* elif ai.ai_family == uv.AF_INET6:
* # Modify some fields in `ai`
*/
__pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_tuple__48, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1262, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_Raise(__pyx_t_6, 0, 0, 0);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__PYX_ERR(1, 1262, __pyx_L1_error)
/* "uvloop/loop.pyx":1261
*
* if ai.ai_family == uv.AF_INET:
* if sl > 2: # <<<<<<<<<<<<<<
* raise OSError("IPv4 sockaddr must be 2 tuple")
* elif ai.ai_family == uv.AF_INET6:
*/
}
/* "uvloop/loop.pyx":1260
* raise OSError("sockaddr resolved to multiple addresses")
*
* if ai.ai_family == uv.AF_INET: # <<<<<<<<<<<<<<
* if sl > 2:
* raise OSError("IPv4 sockaddr must be 2 tuple")
*/
goto __pyx_L18;
}
/* "uvloop/loop.pyx":1263
* if sl > 2:
* raise OSError("IPv4 sockaddr must be 2 tuple")
* elif ai.ai_family == uv.AF_INET6: # <<<<<<<<<<<<<<
* # Modify some fields in `ai`
* sin6 = ai.ai_addr
*/
__pyx_t_2 = ((__pyx_cur_scope->__pyx_v_ai->ai_family == AF_INET6) != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":1265
* elif ai.ai_family == uv.AF_INET6:
* # Modify some fields in `ai`
* sin6 = ai.ai_addr # <<<<<<<<<<<<<<
* sin6.sin6_flowinfo = system.htonl(flowinfo)
* sin6.sin6_scope_id = scope_id
*/
__pyx_cur_scope->__pyx_v_sin6 = ((struct sockaddr_in6 *)__pyx_cur_scope->__pyx_v_ai->ai_addr);
/* "uvloop/loop.pyx":1266
* # Modify some fields in `ai`
* sin6 = ai.ai_addr
* sin6.sin6_flowinfo = system.htonl(flowinfo) # <<<<<<<<<<<<<<
* sin6.sin6_scope_id = scope_id
*
*/
__pyx_t_8 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_flowinfo); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1266, __pyx_L1_error)
__pyx_cur_scope->__pyx_v_sin6->sin6_flowinfo = htonl(__pyx_t_8);
/* "uvloop/loop.pyx":1267
* sin6 = ai.ai_addr
* sin6.sin6_flowinfo = system.htonl(flowinfo)
* sin6.sin6_scope_id = scope_id # <<<<<<<<<<<<<<
*
* return await self._getnameinfo(ai.ai_addr, flags)
*/
__pyx_t_9 = __Pyx_PyInt_As_unsigned_long(__pyx_cur_scope->__pyx_v_scope_id); if (unlikely((__pyx_t_9 == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1267, __pyx_L1_error)
__pyx_cur_scope->__pyx_v_sin6->sin6_scope_id = __pyx_t_9;
/* "uvloop/loop.pyx":1263
* if sl > 2:
* raise OSError("IPv4 sockaddr must be 2 tuple")
* elif ai.ai_family == uv.AF_INET6: # <<<<<<<<<<<<<<
* # Modify some fields in `ai`
* sin6 = ai.ai_addr
*/
}
__pyx_L18:;
/* "uvloop/loop.pyx":1269
* sin6.sin6_scope_id = scope_id
*
* return await self._getnameinfo(ai.ai_addr, flags) # <<<<<<<<<<<<<<
*
* async def create_server(self, protocol_factory, host=None, port=None,
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_getnameinfo(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_ai->ai_addr, __pyx_cur_scope->__pyx_v_flags); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1269, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_6);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XGOTREF(__pyx_r);
if (likely(__pyx_r)) {
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
/* return from generator, yielding value */
__pyx_generator->resume_label = 2;
return __pyx_r;
__pyx_L20_resume_from_yield:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 1269, __pyx_L1_error)
__pyx_t_6 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_6);
} else {
__pyx_t_6 = NULL;
if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_6) < 0) __PYX_ERR(1, 1269, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
}
__pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_6);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_6 = 0;
goto __pyx_L0;
CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
/* "uvloop/loop.pyx":1217
* return self._getaddrinfo(host, port, family, type, proto, flags, 1)
*
* async def getnameinfo(self, sockaddr, int flags=0): # <<<<<<<<<<<<<<
* cdef:
* AddrInfo ai_cnt
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_AddTraceback("getnameinfo", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_L0:;
__Pyx_XDECREF(__pyx_r); __pyx_r = 0;
__pyx_generator->resume_label = -1;
__Pyx_Coroutine_clear((PyObject*)__pyx_generator);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_53generator1(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */
/* "uvloop/loop.pyx":1271
* return await self._getnameinfo(ai.ai_addr, flags)
*
* async def create_server(self, protocol_factory, host=None, port=None, # <<<<<<<<<<<<<<
* *,
* int family=uv.AF_UNSPEC,
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_52create_server(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_51create_server[] = "Loop.create_server(self, protocol_factory, host=None, port=None, *, int family=uv.AF_UNSPEC, int flags=uv.AI_PASSIVE, sock=None, backlog=100, ssl=None, reuse_address=None, reuse_port=None)\nA coroutine which creates a TCP server bound to host and port.\n\n The return value is a Server object which can be used to stop\n the service.\n\n If host is an empty string or None all interfaces are assumed\n and a list of multiple sockets will be returned (most likely\n one for IPv4 and another one for IPv6). The host parameter can also be a\n sequence (e.g. list) of hosts to bind to.\n\n family can be set to either AF_INET or AF_INET6 to force the\n socket to use IPv4 or IPv6. If not set it will be determined\n from host (defaults to AF_UNSPEC).\n\n flags is a bitmask for getaddrinfo().\n\n sock can optionally be specified in order to use a preexisting\n socket object.\n\n backlog is the maximum number of queued connections passed to\n listen() (defaults to 100).\n\n ssl can be set to an SSLContext to enable SSL over the\n accepted connections.\n\n reuse_address tells the kernel to reuse a local socket in\n TIME_WAIT state, without waiting for its natural timeout to\n expire. If not specified will automatically be set to True on\n UNIX.\n\n reuse_port tells the kernel to allow this endpoint to be bound to\n the same port as other existing endpoints are bound to, so long as\n they all set this flag when being created. This option is not\n supported on Windows.\n ";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_52create_server(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_protocol_factory = 0;
PyObject *__pyx_v_host = 0;
PyObject *__pyx_v_port = 0;
int __pyx_v_family;
int __pyx_v_flags;
PyObject *__pyx_v_sock = 0;
PyObject *__pyx_v_backlog = 0;
PyObject *__pyx_v_ssl = 0;
CYTHON_UNUSED PyObject *__pyx_v_reuse_address = 0;
PyObject *__pyx_v_reuse_port = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("create_server (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_protocol_factory,&__pyx_n_s_host,&__pyx_n_s_port,&__pyx_n_s_family,&__pyx_n_s_flags,&__pyx_n_s_sock,&__pyx_n_s_backlog,&__pyx_n_s_ssl,&__pyx_n_s_reuse_address,&__pyx_n_s_reuse_port,0};
PyObject* values[10] = {0,0,0,0,0,0,0,0,0,0};
values[1] = ((PyObject *)Py_None);
values[2] = ((PyObject *)Py_None);
/* "uvloop/loop.pyx":1275
* int family=uv.AF_UNSPEC,
* int flags=uv.AI_PASSIVE,
* sock=None, # <<<<<<<<<<<<<<
* backlog=100,
* ssl=None,
*/
values[5] = ((PyObject *)Py_None);
values[6] = ((PyObject *)__pyx_int_100);
/* "uvloop/loop.pyx":1277
* sock=None,
* backlog=100,
* ssl=None, # <<<<<<<<<<<<<<
* reuse_address=None, # ignored, libuv sets it
* reuse_port=None):
*/
values[7] = ((PyObject *)Py_None);
/* "uvloop/loop.pyx":1278
* backlog=100,
* ssl=None,
* reuse_address=None, # ignored, libuv sets it # <<<<<<<<<<<<<<
* reuse_port=None):
* """A coroutine which creates a TCP server bound to host and port.
*/
values[8] = ((PyObject *)Py_None);
/* "uvloop/loop.pyx":1279
* ssl=None,
* reuse_address=None, # ignored, libuv sets it
* reuse_port=None): # <<<<<<<<<<<<<<
* """A coroutine which creates a TCP server bound to host and port.
*
*/
values[9] = ((PyObject *)Py_None);
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_protocol_factory)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
case 1:
if (kw_args > 0) {
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_host);
if (value) { values[1] = value; kw_args--; }
}
case 2:
if (kw_args > 0) {
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_port);
if (value) { values[2] = value; kw_args--; }
}
}
if (kw_args > 0 && likely(kw_args <= 7)) {
Py_ssize_t index;
for (index = 3; index < 10 && kw_args > 0; index++) {
PyObject* value = PyDict_GetItem(__pyx_kwds, *__pyx_pyargnames[index]);
if (value) { values[index] = value; kw_args--; }
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create_server") < 0)) __PYX_ERR(1, 1271, __pyx_L3_error)
}
} else {
switch (PyTuple_GET_SIZE(__pyx_args)) {
case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
break;
default: goto __pyx_L5_argtuple_error;
}
}
__pyx_v_protocol_factory = values[0];
__pyx_v_host = values[1];
__pyx_v_port = values[2];
if (values[3]) {
__pyx_v_family = __Pyx_PyInt_As_int(values[3]); if (unlikely((__pyx_v_family == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1273, __pyx_L3_error)
} else {
__pyx_v_family = __pyx_k__49;
}
if (values[4]) {
__pyx_v_flags = __Pyx_PyInt_As_int(values[4]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1274, __pyx_L3_error)
} else {
__pyx_v_flags = __pyx_k__50;
}
__pyx_v_sock = values[5];
__pyx_v_backlog = values[6];
__pyx_v_ssl = values[7];
__pyx_v_reuse_address = values[8];
__pyx_v_reuse_port = values[9];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("create_server", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1271, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.create_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_51create_server(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_protocol_factory, __pyx_v_host, __pyx_v_port, __pyx_v_family, __pyx_v_flags, __pyx_v_sock, __pyx_v_backlog, __pyx_v_ssl, __pyx_v_reuse_address, __pyx_v_reuse_port);
/* "uvloop/loop.pyx":1271
* return await self._getnameinfo(ai.ai_addr, flags)
*
* async def create_server(self, protocol_factory, host=None, port=None, # <<<<<<<<<<<<<<
* *,
* int family=uv.AF_UNSPEC,
*/
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_51create_server(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_host, PyObject *__pyx_v_port, int __pyx_v_family, int __pyx_v_flags, PyObject *__pyx_v_sock, PyObject *__pyx_v_backlog, PyObject *__pyx_v_ssl, CYTHON_UNUSED PyObject *__pyx_v_reuse_address, PyObject *__pyx_v_reuse_port) {
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_5_create_server *__pyx_cur_scope;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("create_server", 0);
__pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_5_create_server *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_5_create_server(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_5_create_server, __pyx_empty_tuple, NULL);
if (unlikely(!__pyx_cur_scope)) {
__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_5_create_server *)Py_None);
__Pyx_INCREF(Py_None);
__PYX_ERR(1, 1271, __pyx_L1_error)
} else {
__Pyx_GOTREF(__pyx_cur_scope);
}
__pyx_cur_scope->__pyx_v_self = __pyx_v_self;
__Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__pyx_cur_scope->__pyx_v_protocol_factory = __pyx_v_protocol_factory;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol_factory);
__pyx_cur_scope->__pyx_v_host = __pyx_v_host;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_host);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_host);
__pyx_cur_scope->__pyx_v_port = __pyx_v_port;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_port);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_port);
__pyx_cur_scope->__pyx_v_family = __pyx_v_family;
__pyx_cur_scope->__pyx_v_flags = __pyx_v_flags;
__pyx_cur_scope->__pyx_v_sock = __pyx_v_sock;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
__pyx_cur_scope->__pyx_v_backlog = __pyx_v_backlog;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_backlog);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_backlog);
__pyx_cur_scope->__pyx_v_ssl = __pyx_v_ssl;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl);
__pyx_cur_scope->__pyx_v_reuse_address = __pyx_v_reuse_address;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_reuse_address);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_reuse_address);
__pyx_cur_scope->__pyx_v_reuse_port = __pyx_v_reuse_port;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_reuse_port);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_reuse_port);
{
__pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_53generator1, (PyObject *) __pyx_cur_scope, __pyx_n_s_create_server, __pyx_n_s_Loop_create_server, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(1, 1271, __pyx_L1_error)
__Pyx_DECREF(__pyx_cur_scope);
__Pyx_RefNannyFinishContext();
return (PyObject *) gen;
}
/* function exit code */
__pyx_L1_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.create_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__Pyx_DECREF(((PyObject *)__pyx_cur_scope));
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_53generator1(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */
{
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_5_create_server *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_5_create_server *)__pyx_generator->closure);
PyObject *__pyx_r = NULL;
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
Py_ssize_t __pyx_t_8;
PyObject *(*__pyx_t_9)(PyObject *);
struct addrinfo *__pyx_t_10;
int __pyx_t_11;
int __pyx_t_12;
char const *__pyx_t_13;
PyObject *__pyx_t_14 = NULL;
PyObject *__pyx_t_15 = NULL;
PyObject *__pyx_t_16 = NULL;
PyObject *__pyx_t_17 = NULL;
PyObject *__pyx_t_18 = NULL;
PyObject *__pyx_t_19 = NULL;
PyObject *__pyx_t_20 = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("None", 0);
switch (__pyx_generator->resume_label) {
case 0: goto __pyx_L3_first_run;
case 1: goto __pyx_L10_resume_from_yield;
case 2: goto __pyx_L30_resume_from_yield;
default: /* CPython raises the right error here */
__Pyx_RefNannyFinishContext();
return NULL;
}
__pyx_L3_first_run:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 1271, __pyx_L1_error)
/* "uvloop/loop.pyx":1320
* Server server
*
* if sock is not None and sock.family == uv.AF_UNIX: # <<<<<<<<<<<<<<
* if host is not None or port is not None:
* raise ValueError(
*/
__pyx_t_2 = (__pyx_cur_scope->__pyx_v_sock != Py_None);
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
} else {
__pyx_t_1 = __pyx_t_3;
goto __pyx_L5_bool_binop_done;
}
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_family); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1320, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = __Pyx_PyInt_From_int(AF_UNIX); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1320, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = PyObject_RichCompare(__pyx_t_4, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1320, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(1, 1320, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_1 = __pyx_t_3;
__pyx_L5_bool_binop_done:;
if (__pyx_t_1) {
/* "uvloop/loop.pyx":1321
*
* if sock is not None and sock.family == uv.AF_UNIX:
* if host is not None or port is not None: # <<<<<<<<<<<<<<
* raise ValueError(
* 'host/port and sock can not be specified at the same time')
*/
__pyx_t_3 = (__pyx_cur_scope->__pyx_v_host != Py_None);
__pyx_t_2 = (__pyx_t_3 != 0);
if (!__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L8_bool_binop_done;
}
__pyx_t_2 = (__pyx_cur_scope->__pyx_v_port != Py_None);
__pyx_t_3 = (__pyx_t_2 != 0);
__pyx_t_1 = __pyx_t_3;
__pyx_L8_bool_binop_done:;
if (__pyx_t_1) {
/* "uvloop/loop.pyx":1322
* if sock is not None and sock.family == uv.AF_UNIX:
* if host is not None or port is not None:
* raise ValueError( # <<<<<<<<<<<<<<
* 'host/port and sock can not be specified at the same time')
* return await self.create_unix_server(
*/
__pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__51, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1322, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_Raise(__pyx_t_6, 0, 0, 0);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__PYX_ERR(1, 1322, __pyx_L1_error)
/* "uvloop/loop.pyx":1321
*
* if sock is not None and sock.family == uv.AF_UNIX:
* if host is not None or port is not None: # <<<<<<<<<<<<<<
* raise ValueError(
* 'host/port and sock can not be specified at the same time')
*/
}
/* "uvloop/loop.pyx":1324
* raise ValueError(
* 'host/port and sock can not be specified at the same time')
* return await self.create_unix_server( # <<<<<<<<<<<<<<
* protocol_factory, sock=sock, ssl=ssl)
*
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_create_unix_server); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1324, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
/* "uvloop/loop.pyx":1325
* 'host/port and sock can not be specified at the same time')
* return await self.create_unix_server(
* protocol_factory, sock=sock, ssl=ssl) # <<<<<<<<<<<<<<
*
* server = Server(self)
*/
__pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1324, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol_factory);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_cur_scope->__pyx_v_protocol_factory);
__pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1325, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_sock, __pyx_cur_scope->__pyx_v_sock) < 0) __PYX_ERR(1, 1325, __pyx_L1_error)
if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_ssl, __pyx_cur_scope->__pyx_v_ssl) < 0) __PYX_ERR(1, 1325, __pyx_L1_error)
/* "uvloop/loop.pyx":1324
* raise ValueError(
* 'host/port and sock can not be specified at the same time')
* return await self.create_unix_server( # <<<<<<<<<<<<<<
* protocol_factory, sock=sock, ssl=ssl)
*
*/
__pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1324, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_7);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XGOTREF(__pyx_r);
if (likely(__pyx_r)) {
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
/* return from generator, yielding value */
__pyx_generator->resume_label = 1;
return __pyx_r;
__pyx_L10_resume_from_yield:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 1324, __pyx_L1_error)
__pyx_t_7 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_7);
} else {
__pyx_t_7 = NULL;
if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_7) < 0) __PYX_ERR(1, 1324, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
}
__pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_7);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_7 = 0;
goto __pyx_L0;
/* "uvloop/loop.pyx":1320
* Server server
*
* if sock is not None and sock.family == uv.AF_UNIX: # <<<<<<<<<<<<<<
* if host is not None or port is not None:
* raise ValueError(
*/
}
/* "uvloop/loop.pyx":1327
* protocol_factory, sock=sock, ssl=ssl)
*
* server = Server(self) # <<<<<<<<<<<<<<
*
* if ssl is not None and not isinstance(ssl, ssl_SSLContext):
*/
__pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1327, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
PyTuple_SET_ITEM(__pyx_t_7, 0, ((PyObject *)__pyx_cur_scope->__pyx_v_self));
__pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6uvloop_4loop_Server), __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1327, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GIVEREF(__pyx_t_4);
__pyx_cur_scope->__pyx_v_server = ((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_t_4);
__pyx_t_4 = 0;
/* "uvloop/loop.pyx":1329
* server = Server(self)
*
* if ssl is not None and not isinstance(ssl, ssl_SSLContext): # <<<<<<<<<<<<<<
* raise TypeError('ssl argument must be an SSLContext or None')
*
*/
__pyx_t_3 = (__pyx_cur_scope->__pyx_v_ssl != Py_None);
__pyx_t_2 = (__pyx_t_3 != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L12_bool_binop_done;
}
__pyx_t_4 = __pyx_v_6uvloop_4loop_ssl_SSLContext;
__Pyx_INCREF(__pyx_t_4);
__pyx_t_2 = PyObject_IsInstance(__pyx_cur_scope->__pyx_v_ssl, __pyx_t_4); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(1, 1329, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_3 = ((!(__pyx_t_2 != 0)) != 0);
__pyx_t_1 = __pyx_t_3;
__pyx_L12_bool_binop_done:;
if (__pyx_t_1) {
/* "uvloop/loop.pyx":1330
*
* if ssl is not None and not isinstance(ssl, ssl_SSLContext):
* raise TypeError('ssl argument must be an SSLContext or None') # <<<<<<<<<<<<<<
*
* if host is not None or port is not None:
*/
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__52, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1330, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__PYX_ERR(1, 1330, __pyx_L1_error)
/* "uvloop/loop.pyx":1329
* server = Server(self)
*
* if ssl is not None and not isinstance(ssl, ssl_SSLContext): # <<<<<<<<<<<<<<
* raise TypeError('ssl argument must be an SSLContext or None')
*
*/
}
/* "uvloop/loop.pyx":1332
* raise TypeError('ssl argument must be an SSLContext or None')
*
* if host is not None or port is not None: # <<<<<<<<<<<<<<
* if sock is not None:
* raise ValueError(
*/
__pyx_t_3 = (__pyx_cur_scope->__pyx_v_host != Py_None);
__pyx_t_2 = (__pyx_t_3 != 0);
if (!__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L15_bool_binop_done;
}
__pyx_t_2 = (__pyx_cur_scope->__pyx_v_port != Py_None);
__pyx_t_3 = (__pyx_t_2 != 0);
__pyx_t_1 = __pyx_t_3;
__pyx_L15_bool_binop_done:;
if (__pyx_t_1) {
/* "uvloop/loop.pyx":1333
*
* if host is not None or port is not None:
* if sock is not None: # <<<<<<<<<<<<<<
* raise ValueError(
* 'host/port and sock can not be specified at the same time')
*/
__pyx_t_1 = (__pyx_cur_scope->__pyx_v_sock != Py_None);
__pyx_t_3 = (__pyx_t_1 != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1334
* if host is not None or port is not None:
* if sock is not None:
* raise ValueError( # <<<<<<<<<<<<<<
* 'host/port and sock can not be specified at the same time')
*
*/
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__53, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1334, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__PYX_ERR(1, 1334, __pyx_L1_error)
/* "uvloop/loop.pyx":1333
*
* if host is not None or port is not None:
* if sock is not None: # <<<<<<<<<<<<<<
* raise ValueError(
* 'host/port and sock can not be specified at the same time')
*/
}
/* "uvloop/loop.pyx":1337
* 'host/port and sock can not be specified at the same time')
*
* reuse_port = bool(reuse_port) # <<<<<<<<<<<<<<
* if reuse_port and not has_SO_REUSEPORT:
* raise ValueError(
*/
__pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_reuse_port); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(1, 1337, __pyx_L1_error)
__pyx_t_4 = __Pyx_PyBool_FromLong((!(!__pyx_t_3))); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1337, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_reuse_port);
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_reuse_port, __pyx_t_4);
__Pyx_GIVEREF(__pyx_t_4);
__pyx_t_4 = 0;
/* "uvloop/loop.pyx":1338
*
* reuse_port = bool(reuse_port)
* if reuse_port and not has_SO_REUSEPORT: # <<<<<<<<<<<<<<
* raise ValueError(
* 'reuse_port not supported by socket module')
*/
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_reuse_port); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 1338, __pyx_L1_error)
if (__pyx_t_1) {
} else {
__pyx_t_3 = __pyx_t_1;
goto __pyx_L19_bool_binop_done;
}
__pyx_t_1 = ((!(__pyx_v_6uvloop_4loop_has_SO_REUSEPORT != 0)) != 0);
__pyx_t_3 = __pyx_t_1;
__pyx_L19_bool_binop_done:;
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1339
* reuse_port = bool(reuse_port)
* if reuse_port and not has_SO_REUSEPORT:
* raise ValueError( # <<<<<<<<<<<<<<
* 'reuse_port not supported by socket module')
*
*/
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__54, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1339, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__PYX_ERR(1, 1339, __pyx_L1_error)
/* "uvloop/loop.pyx":1338
*
* reuse_port = bool(reuse_port)
* if reuse_port and not has_SO_REUSEPORT: # <<<<<<<<<<<<<<
* raise ValueError(
* 'reuse_port not supported by socket module')
*/
}
/* "uvloop/loop.pyx":1342
* 'reuse_port not supported by socket module')
*
* if host == '': # <<<<<<<<<<<<<<
* hosts = [None]
* elif (isinstance(host, str) or not isinstance(host, col_Iterable)):
*/
__pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_cur_scope->__pyx_v_host, __pyx_kp_u__30, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(1, 1342, __pyx_L1_error)
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1343
*
* if host == '':
* hosts = [None] # <<<<<<<<<<<<<<
* elif (isinstance(host, str) or not isinstance(host, col_Iterable)):
* hosts = [host]
*/
__pyx_t_4 = PyList_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1343, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
PyList_SET_ITEM(__pyx_t_4, 0, Py_None);
__Pyx_GIVEREF(__pyx_t_4);
__pyx_cur_scope->__pyx_v_hosts = __pyx_t_4;
__pyx_t_4 = 0;
/* "uvloop/loop.pyx":1342
* 'reuse_port not supported by socket module')
*
* if host == '': # <<<<<<<<<<<<<<
* hosts = [None]
* elif (isinstance(host, str) or not isinstance(host, col_Iterable)):
*/
goto __pyx_L21;
}
/* "uvloop/loop.pyx":1344
* if host == '':
* hosts = [None]
* elif (isinstance(host, str) or not isinstance(host, col_Iterable)): # <<<<<<<<<<<<<<
* hosts = [host]
* else:
*/
__pyx_t_1 = PyUnicode_Check(__pyx_cur_scope->__pyx_v_host);
__pyx_t_2 = (__pyx_t_1 != 0);
if (!__pyx_t_2) {
} else {
__pyx_t_3 = __pyx_t_2;
goto __pyx_L22_bool_binop_done;
}
__pyx_t_4 = __pyx_v_6uvloop_4loop_col_Iterable;
__Pyx_INCREF(__pyx_t_4);
__pyx_t_2 = PyObject_IsInstance(__pyx_cur_scope->__pyx_v_host, __pyx_t_4); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(1, 1344, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_1 = ((!(__pyx_t_2 != 0)) != 0);
__pyx_t_3 = __pyx_t_1;
__pyx_L22_bool_binop_done:;
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1345
* hosts = [None]
* elif (isinstance(host, str) or not isinstance(host, col_Iterable)):
* hosts = [host] # <<<<<<<<<<<<<<
* else:
* hosts = host
*/
__pyx_t_4 = PyList_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1345, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_host);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_host);
PyList_SET_ITEM(__pyx_t_4, 0, __pyx_cur_scope->__pyx_v_host);
__Pyx_GIVEREF(__pyx_t_4);
__pyx_cur_scope->__pyx_v_hosts = __pyx_t_4;
__pyx_t_4 = 0;
/* "uvloop/loop.pyx":1344
* if host == '':
* hosts = [None]
* elif (isinstance(host, str) or not isinstance(host, col_Iterable)): # <<<<<<<<<<<<<<
* hosts = [host]
* else:
*/
goto __pyx_L21;
}
/* "uvloop/loop.pyx":1347
* hosts = [host]
* else:
* hosts = host # <<<<<<<<<<<<<<
*
* fs = [self._getaddrinfo(host, port, family,
*/
/*else*/ {
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_host);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_host);
__pyx_cur_scope->__pyx_v_hosts = __pyx_cur_scope->__pyx_v_host;
}
__pyx_L21:;
/* "uvloop/loop.pyx":1349
* hosts = host
*
* fs = [self._getaddrinfo(host, port, family, # <<<<<<<<<<<<<<
* uv.SOCK_STREAM, 0, flags,
* 0) for host in hosts]
*/
{ /* enter inner scope */
PyObject *__pyx_7genexpr__pyx_v_host = NULL;
__pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1349, __pyx_L26_error)
__Pyx_GOTREF(__pyx_t_4);
/* "uvloop/loop.pyx":1351
* fs = [self._getaddrinfo(host, port, family,
* uv.SOCK_STREAM, 0, flags,
* 0) for host in hosts] # <<<<<<<<<<<<<<
*
* infos = await aio_gather(*fs, loop=self)
*/
if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_v_hosts)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_v_hosts)) {
__pyx_t_7 = __pyx_cur_scope->__pyx_v_hosts; __Pyx_INCREF(__pyx_t_7); __pyx_t_8 = 0;
__pyx_t_9 = NULL;
} else {
__pyx_t_8 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_cur_scope->__pyx_v_hosts); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1351, __pyx_L26_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_9 = Py_TYPE(__pyx_t_7)->tp_iternext; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1351, __pyx_L26_error)
}
for (;;) {
if (likely(!__pyx_t_9)) {
if (likely(PyList_CheckExact(__pyx_t_7))) {
if (__pyx_t_8 >= PyList_GET_SIZE(__pyx_t_7)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_5 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_8); __Pyx_INCREF(__pyx_t_5); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(1, 1351, __pyx_L26_error)
#else
__pyx_t_5 = PySequence_ITEM(__pyx_t_7, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1351, __pyx_L26_error)
__Pyx_GOTREF(__pyx_t_5);
#endif
} else {
if (__pyx_t_8 >= PyTuple_GET_SIZE(__pyx_t_7)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_8); __Pyx_INCREF(__pyx_t_5); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(1, 1351, __pyx_L26_error)
#else
__pyx_t_5 = PySequence_ITEM(__pyx_t_7, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1351, __pyx_L26_error)
__Pyx_GOTREF(__pyx_t_5);
#endif
}
} else {
__pyx_t_5 = __pyx_t_9(__pyx_t_7);
if (unlikely(!__pyx_t_5)) {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(1, 1351, __pyx_L26_error)
}
break;
}
__Pyx_GOTREF(__pyx_t_5);
}
__Pyx_XDECREF_SET(__pyx_7genexpr__pyx_v_host, __pyx_t_5);
__pyx_t_5 = 0;
/* "uvloop/loop.pyx":1349
* hosts = host
*
* fs = [self._getaddrinfo(host, port, family, # <<<<<<<<<<<<<<
* uv.SOCK_STREAM, 0, flags,
* 0) for host in hosts]
*/
__pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_getaddrinfo(__pyx_cur_scope->__pyx_v_self, __pyx_7genexpr__pyx_v_host, __pyx_cur_scope->__pyx_v_port, __pyx_cur_scope->__pyx_v_family, SOCK_STREAM, 0, __pyx_cur_scope->__pyx_v_flags, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1349, __pyx_L26_error)
__Pyx_GOTREF(__pyx_t_5);
if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_5))) __PYX_ERR(1, 1349, __pyx_L26_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":1351
* fs = [self._getaddrinfo(host, port, family,
* uv.SOCK_STREAM, 0, flags,
* 0) for host in hosts] # <<<<<<<<<<<<<<
*
* infos = await aio_gather(*fs, loop=self)
*/
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_7genexpr__pyx_v_host);
goto __pyx_L29_exit_scope;
__pyx_L26_error:;
__Pyx_XDECREF(__pyx_7genexpr__pyx_v_host);
goto __pyx_L1_error;
__pyx_L29_exit_scope:;
} /* exit inner scope */
__Pyx_GIVEREF(__pyx_t_4);
__pyx_cur_scope->__pyx_v_fs = ((PyObject*)__pyx_t_4);
__pyx_t_4 = 0;
/* "uvloop/loop.pyx":1353
* 0) for host in hosts]
*
* infos = await aio_gather(*fs, loop=self) # <<<<<<<<<<<<<<
*
* completed = False
*/
__pyx_t_4 = PySequence_Tuple(__pyx_cur_scope->__pyx_v_fs); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1353, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_7 = PyDict_New(); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1353, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
if (PyDict_SetItem(__pyx_t_7, __pyx_n_s_loop, ((PyObject *)__pyx_cur_scope->__pyx_v_self)) < 0) __PYX_ERR(1, 1353, __pyx_L1_error)
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_v_6uvloop_4loop_aio_gather, __pyx_t_4, __pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1353, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XGOTREF(__pyx_r);
if (likely(__pyx_r)) {
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
/* return from generator, yielding value */
__pyx_generator->resume_label = 2;
return __pyx_r;
__pyx_L30_resume_from_yield:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 1353, __pyx_L1_error)
__pyx_t_5 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_5);
} else {
__pyx_t_5 = NULL;
if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_5) < 0) __PYX_ERR(1, 1353, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
}
__Pyx_GIVEREF(__pyx_t_5);
__pyx_cur_scope->__pyx_v_infos = __pyx_t_5;
__pyx_t_5 = 0;
/* "uvloop/loop.pyx":1355
* infos = await aio_gather(*fs, loop=self)
*
* completed = False # <<<<<<<<<<<<<<
* try:
* for info in infos:
*/
__pyx_cur_scope->__pyx_v_completed = 0;
/* "uvloop/loop.pyx":1356
*
* completed = False
* try: # <<<<<<<<<<<<<<
* for info in infos:
* addrinfo = (info).data
*/
/*try:*/ {
/* "uvloop/loop.pyx":1357
* completed = False
* try:
* for info in infos: # <<<<<<<<<<<<<<
* addrinfo = (info).data
* while addrinfo != NULL:
*/
if (likely(PyList_CheckExact(__pyx_cur_scope->__pyx_v_infos)) || PyTuple_CheckExact(__pyx_cur_scope->__pyx_v_infos)) {
__pyx_t_5 = __pyx_cur_scope->__pyx_v_infos; __Pyx_INCREF(__pyx_t_5); __pyx_t_8 = 0;
__pyx_t_9 = NULL;
} else {
__pyx_t_8 = -1; __pyx_t_5 = PyObject_GetIter(__pyx_cur_scope->__pyx_v_infos); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1357, __pyx_L32_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_9 = Py_TYPE(__pyx_t_5)->tp_iternext; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1357, __pyx_L32_error)
}
for (;;) {
if (likely(!__pyx_t_9)) {
if (likely(PyList_CheckExact(__pyx_t_5))) {
if (__pyx_t_8 >= PyList_GET_SIZE(__pyx_t_5)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_7 = PyList_GET_ITEM(__pyx_t_5, __pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(1, 1357, __pyx_L32_error)
#else
__pyx_t_7 = PySequence_ITEM(__pyx_t_5, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1357, __pyx_L32_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
} else {
if (__pyx_t_8 >= PyTuple_GET_SIZE(__pyx_t_5)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_8); __Pyx_INCREF(__pyx_t_7); __pyx_t_8++; if (unlikely(0 < 0)) __PYX_ERR(1, 1357, __pyx_L32_error)
#else
__pyx_t_7 = PySequence_ITEM(__pyx_t_5, __pyx_t_8); __pyx_t_8++; if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1357, __pyx_L32_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
}
} else {
__pyx_t_7 = __pyx_t_9(__pyx_t_5);
if (unlikely(!__pyx_t_7)) {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(1, 1357, __pyx_L32_error)
}
break;
}
__Pyx_GOTREF(__pyx_t_7);
}
__Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_info);
__Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_info, __pyx_t_7);
__Pyx_GIVEREF(__pyx_t_7);
__pyx_t_7 = 0;
/* "uvloop/loop.pyx":1358
* try:
* for info in infos:
* addrinfo = (info).data # <<<<<<<<<<<<<<
* while addrinfo != NULL:
* if addrinfo.ai_family == uv.AF_UNSPEC:
*/
__pyx_t_10 = ((struct __pyx_obj_6uvloop_4loop_AddrInfo *)__pyx_cur_scope->__pyx_v_info)->data;
__pyx_cur_scope->__pyx_v_addrinfo = __pyx_t_10;
/* "uvloop/loop.pyx":1359
* for info in infos:
* addrinfo = (info).data
* while addrinfo != NULL: # <<<<<<<<<<<<<<
* if addrinfo.ai_family == uv.AF_UNSPEC:
* raise RuntimeError('AF_UNSPEC in DNS results')
*/
while (1) {
__pyx_t_3 = ((__pyx_cur_scope->__pyx_v_addrinfo != NULL) != 0);
if (!__pyx_t_3) break;
/* "uvloop/loop.pyx":1360
* addrinfo = (info).data
* while addrinfo != NULL:
* if addrinfo.ai_family == uv.AF_UNSPEC: # <<<<<<<<<<<<<<
* raise RuntimeError('AF_UNSPEC in DNS results')
*
*/
__pyx_t_3 = ((__pyx_cur_scope->__pyx_v_addrinfo->ai_family == AF_UNSPEC) != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1361
* while addrinfo != NULL:
* if addrinfo.ai_family == uv.AF_UNSPEC:
* raise RuntimeError('AF_UNSPEC in DNS results') # <<<<<<<<<<<<<<
*
* tcp = self._create_server(
*/
__pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__55, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1361, __pyx_L32_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_Raise(__pyx_t_7, 0, 0, 0);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__PYX_ERR(1, 1361, __pyx_L32_error)
/* "uvloop/loop.pyx":1360
* addrinfo = (info).data
* while addrinfo != NULL:
* if addrinfo.ai_family == uv.AF_UNSPEC: # <<<<<<<<<<<<<<
* raise RuntimeError('AF_UNSPEC in DNS results')
*
*/
}
/* "uvloop/loop.pyx":1365
* tcp = self._create_server(
* addrinfo.ai_addr, protocol_factory, server,
* ssl, reuse_port, backlog) # <<<<<<<<<<<<<<
*
* server._add_server(tcp)
*/
__pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_reuse_port); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1365, __pyx_L32_error)
/* "uvloop/loop.pyx":1363
* raise RuntimeError('AF_UNSPEC in DNS results')
*
* tcp = self._create_server( # <<<<<<<<<<<<<<
* addrinfo.ai_addr, protocol_factory, server,
* ssl, reuse_port, backlog)
*/
__pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_create_server(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_addrinfo->ai_addr, __pyx_cur_scope->__pyx_v_protocol_factory, __pyx_cur_scope->__pyx_v_server, __pyx_cur_scope->__pyx_v_ssl, __pyx_t_3, __pyx_cur_scope->__pyx_v_backlog); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1363, __pyx_L32_error)
__Pyx_GOTREF(__pyx_t_7);
if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_ptype_6uvloop_4loop_TCPServer))))) __PYX_ERR(1, 1363, __pyx_L32_error)
__Pyx_XGOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_tcp));
__Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_tcp, ((struct __pyx_obj_6uvloop_4loop_TCPServer *)__pyx_t_7));
__Pyx_GIVEREF(__pyx_t_7);
__pyx_t_7 = 0;
/* "uvloop/loop.pyx":1367
* ssl, reuse_port, backlog)
*
* server._add_server(tcp) # <<<<<<<<<<<<<<
*
* addrinfo = addrinfo.ai_next
*/
__pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_Server *)__pyx_cur_scope->__pyx_v_server->__pyx_vtab)->_add_server(__pyx_cur_scope->__pyx_v_server, ((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)__pyx_cur_scope->__pyx_v_tcp)); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1367, __pyx_L32_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "uvloop/loop.pyx":1369
* server._add_server(tcp)
*
* addrinfo = addrinfo.ai_next # <<<<<<<<<<<<<<
*
* completed = True
*/
__pyx_t_10 = __pyx_cur_scope->__pyx_v_addrinfo->ai_next;
__pyx_cur_scope->__pyx_v_addrinfo = __pyx_t_10;
}
/* "uvloop/loop.pyx":1357
* completed = False
* try:
* for info in infos: # <<<<<<<<<<<<<<
* addrinfo = (info).data
* while addrinfo != NULL:
*/
}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":1371
* addrinfo = addrinfo.ai_next
*
* completed = True # <<<<<<<<<<<<<<
* finally:
* if not completed:
*/
__pyx_cur_scope->__pyx_v_completed = 1;
}
/* "uvloop/loop.pyx":1373
* completed = True
* finally:
* if not completed: # <<<<<<<<<<<<<<
* server.close()
* else:
*/
/*finally:*/ {
/*normal exit:*/{
__pyx_t_3 = ((!(__pyx_cur_scope->__pyx_v_completed != 0)) != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1374
* finally:
* if not completed:
* server.close() # <<<<<<<<<<<<<<
* else:
* if sock is None:
*/
__pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_server), __pyx_n_s_close); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1374, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_7, function);
}
}
if (__pyx_t_4) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1374, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
__pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1374, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":1373
* completed = True
* finally:
* if not completed: # <<<<<<<<<<<<<<
* server.close()
* else:
*/
}
goto __pyx_L33;
}
/*exception exit:*/{
__Pyx_PyThreadState_declare
__pyx_L32_error:;
__pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19);
if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16) < 0)) __Pyx_ErrFetch(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16);
__Pyx_XGOTREF(__pyx_t_14);
__Pyx_XGOTREF(__pyx_t_15);
__Pyx_XGOTREF(__pyx_t_16);
__Pyx_XGOTREF(__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_18);
__Pyx_XGOTREF(__pyx_t_19);
__pyx_t_11 = __pyx_lineno; __pyx_t_12 = __pyx_clineno; __pyx_t_13 = __pyx_filename;
{
__pyx_t_3 = ((!(__pyx_cur_scope->__pyx_v_completed != 0)) != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1374
* finally:
* if not completed:
* server.close() # <<<<<<<<<<<<<<
* else:
* if sock is None:
*/
__pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_server), __pyx_n_s_close); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1374, __pyx_L41_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_7, function);
}
}
if (__pyx_t_4) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1374, __pyx_L41_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
__pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1374, __pyx_L41_error)
}
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":1373
* completed = True
* finally:
* if not completed: # <<<<<<<<<<<<<<
* server.close()
* else:
*/
}
}
__Pyx_PyThreadState_assign
if (PY_MAJOR_VERSION >= 3) {
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_XGIVEREF(__pyx_t_19);
__Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19);
}
__Pyx_XGIVEREF(__pyx_t_14);
__Pyx_XGIVEREF(__pyx_t_15);
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_ErrRestore(__pyx_t_14, __pyx_t_15, __pyx_t_16);
__pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0;
__pyx_lineno = __pyx_t_11; __pyx_clineno = __pyx_t_12; __pyx_filename = __pyx_t_13;
goto __pyx_L1_error;
__pyx_L41_error:;
__Pyx_PyThreadState_assign
if (PY_MAJOR_VERSION >= 3) {
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_XGIVEREF(__pyx_t_19);
__Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19);
}
__Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
__Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
__Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
__pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0;
goto __pyx_L1_error;
}
__pyx_L33:;
}
/* "uvloop/loop.pyx":1332
* raise TypeError('ssl argument must be an SSLContext or None')
*
* if host is not None or port is not None: # <<<<<<<<<<<<<<
* if sock is not None:
* raise ValueError(
*/
goto __pyx_L14;
}
/* "uvloop/loop.pyx":1376
* server.close()
* else:
* if sock is None: # <<<<<<<<<<<<<<
* raise ValueError('Neither host/port nor sock were specified')
* if not _is_sock_stream(sock.type):
*/
/*else*/ {
__pyx_t_3 = (__pyx_cur_scope->__pyx_v_sock == Py_None);
__pyx_t_1 = (__pyx_t_3 != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":1377
* else:
* if sock is None:
* raise ValueError('Neither host/port nor sock were specified') # <<<<<<<<<<<<<<
* if not _is_sock_stream(sock.type):
* raise ValueError(
*/
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__56, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1377, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_Raise(__pyx_t_5, 0, 0, 0);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__PYX_ERR(1, 1377, __pyx_L1_error)
/* "uvloop/loop.pyx":1376
* server.close()
* else:
* if sock is None: # <<<<<<<<<<<<<<
* raise ValueError('Neither host/port nor sock were specified')
* if not _is_sock_stream(sock.type):
*/
}
/* "uvloop/loop.pyx":1378
* if sock is None:
* raise ValueError('Neither host/port nor sock were specified')
* if not _is_sock_stream(sock.type): # <<<<<<<<<<<<<<
* raise ValueError(
* 'A Stream Socket was expected, got {!r}'.format(sock))
*/
__pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_type); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1378, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_7 = __pyx_f_6uvloop_4loop__is_sock_stream(__pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1378, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 1378, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_3 = ((!__pyx_t_1) != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1380
* if not _is_sock_stream(sock.type):
* raise ValueError(
* 'A Stream Socket was expected, got {!r}'.format(sock)) # <<<<<<<<<<<<<<
*
* tcp = TCPServer.new(self, protocol_factory, server, ssl,
*/
__pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_A_Stream_Socket_was_expected_got, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1380, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_5, function);
}
}
if (!__pyx_t_4) {
__pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_cur_scope->__pyx_v_sock); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1380, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_5)) {
PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_cur_scope->__pyx_v_sock};
__pyx_t_7 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1380, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_7);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_cur_scope->__pyx_v_sock};
__pyx_t_7 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1380, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_7);
} else
#endif
{
__pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1380, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_cur_scope->__pyx_v_sock);
__pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_6, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1380, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":1379
* raise ValueError('Neither host/port nor sock were specified')
* if not _is_sock_stream(sock.type):
* raise ValueError( # <<<<<<<<<<<<<<
* 'A Stream Socket was expected, got {!r}'.format(sock))
*
*/
__pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1379, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_7);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_7);
__pyx_t_7 = 0;
__pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1379, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_7, 0, 0, 0);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__PYX_ERR(1, 1379, __pyx_L1_error)
/* "uvloop/loop.pyx":1378
* if sock is None:
* raise ValueError('Neither host/port nor sock were specified')
* if not _is_sock_stream(sock.type): # <<<<<<<<<<<<<<
* raise ValueError(
* 'A Stream Socket was expected, got {!r}'.format(sock))
*/
}
/* "uvloop/loop.pyx":1382
* 'A Stream Socket was expected, got {!r}'.format(sock))
*
* tcp = TCPServer.new(self, protocol_factory, server, ssl, # <<<<<<<<<<<<<<
* uv.AF_UNSPEC)
*
*/
__pyx_t_7 = ((PyObject *)__pyx_f_6uvloop_4loop_9TCPServer_new(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_protocol_factory, __pyx_cur_scope->__pyx_v_server, __pyx_cur_scope->__pyx_v_ssl, AF_UNSPEC)); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1382, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_7);
__pyx_cur_scope->__pyx_v_tcp = ((struct __pyx_obj_6uvloop_4loop_TCPServer *)__pyx_t_7);
__pyx_t_7 = 0;
/* "uvloop/loop.pyx":1386
*
* # See a comment on os_dup in create_connection
* fileno = os_dup(sock.fileno()) # <<<<<<<<<<<<<<
* try:
* tcp._open(fileno)
*/
__pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_fileno); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1386, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_6, function);
}
}
if (__pyx_t_4) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1386, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
__pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1386, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_INCREF(__pyx_v_6uvloop_4loop_os_dup);
__pyx_t_6 = __pyx_v_6uvloop_4loop_os_dup; __pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_6, function);
}
}
if (!__pyx_t_4) {
__pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1386, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_7);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_6)) {
PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_5};
__pyx_t_7 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1386, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_5};
__pyx_t_7 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1386, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else
#endif
{
__pyx_t_20 = PyTuple_New(1+1); if (unlikely(!__pyx_t_20)) __PYX_ERR(1, 1386, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_20);
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_20, 0, __pyx_t_4); __pyx_t_4 = NULL;
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_20, 0+1, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_20, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1386, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
}
}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GIVEREF(__pyx_t_7);
__pyx_cur_scope->__pyx_v_fileno = __pyx_t_7;
__pyx_t_7 = 0;
/* "uvloop/loop.pyx":1387
* # See a comment on os_dup in create_connection
* fileno = os_dup(sock.fileno())
* try: # <<<<<<<<<<<<<<
* tcp._open(fileno)
* tcp._attach_fileobj(sock)
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_19, &__pyx_t_18, &__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_19);
__Pyx_XGOTREF(__pyx_t_18);
__Pyx_XGOTREF(__pyx_t_17);
/*try:*/ {
/* "uvloop/loop.pyx":1388
* fileno = os_dup(sock.fileno())
* try:
* tcp._open(fileno) # <<<<<<<<<<<<<<
* tcp._attach_fileobj(sock)
* tcp.listen(backlog)
*/
__pyx_t_12 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_fileno); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1388, __pyx_L45_error)
__pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPServer *)__pyx_cur_scope->__pyx_v_tcp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._open(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_tcp), __pyx_t_12); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1388, __pyx_L45_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "uvloop/loop.pyx":1389
* try:
* tcp._open(fileno)
* tcp._attach_fileobj(sock) # <<<<<<<<<<<<<<
* tcp.listen(backlog)
* except:
*/
__pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPServer *)__pyx_cur_scope->__pyx_v_tcp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._attach_fileobj(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_tcp), __pyx_cur_scope->__pyx_v_sock); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1389, __pyx_L45_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "uvloop/loop.pyx":1390
* tcp._open(fileno)
* tcp._attach_fileobj(sock)
* tcp.listen(backlog) # <<<<<<<<<<<<<<
* except:
* tcp._close()
*/
__pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPServer *)__pyx_cur_scope->__pyx_v_tcp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.listen(((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)__pyx_cur_scope->__pyx_v_tcp), __pyx_cur_scope->__pyx_v_backlog); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1390, __pyx_L45_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "uvloop/loop.pyx":1387
* # See a comment on os_dup in create_connection
* fileno = os_dup(sock.fileno())
* try: # <<<<<<<<<<<<<<
* tcp._open(fileno)
* tcp._attach_fileobj(sock)
*/
}
__Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0;
__Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
__Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
goto __pyx_L52_try_end;
__pyx_L45_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "uvloop/loop.pyx":1391
* tcp._attach_fileobj(sock)
* tcp.listen(backlog)
* except: # <<<<<<<<<<<<<<
* tcp._close()
* raise
*/
/*except:*/ {
__Pyx_AddTraceback("uvloop.loop.Loop.create_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_6, &__pyx_t_20) < 0) __PYX_ERR(1, 1391, __pyx_L47_except_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_t_20);
/* "uvloop/loop.pyx":1392
* tcp.listen(backlog)
* except:
* tcp._close() # <<<<<<<<<<<<<<
* raise
*
*/
__pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPServer *)__pyx_cur_scope->__pyx_v_tcp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_cur_scope->__pyx_v_tcp)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1392, __pyx_L47_except_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":1393
* except:
* tcp._close()
* raise # <<<<<<<<<<<<<<
*
* server._add_server(tcp)
*/
__Pyx_GIVEREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_6);
__Pyx_XGIVEREF(__pyx_t_20);
__Pyx_ErrRestoreWithState(__pyx_t_7, __pyx_t_6, __pyx_t_20);
__pyx_t_7 = 0; __pyx_t_6 = 0; __pyx_t_20 = 0;
__PYX_ERR(1, 1393, __pyx_L47_except_error)
}
__pyx_L47_except_error:;
/* "uvloop/loop.pyx":1387
* # See a comment on os_dup in create_connection
* fileno = os_dup(sock.fileno())
* try: # <<<<<<<<<<<<<<
* tcp._open(fileno)
* tcp._attach_fileobj(sock)
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_19);
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_ExceptionReset(__pyx_t_19, __pyx_t_18, __pyx_t_17);
goto __pyx_L1_error;
__pyx_L52_try_end:;
}
/* "uvloop/loop.pyx":1395
* raise
*
* server._add_server(tcp) # <<<<<<<<<<<<<<
*
* return server
*/
__pyx_t_20 = ((struct __pyx_vtabstruct_6uvloop_4loop_Server *)__pyx_cur_scope->__pyx_v_server->__pyx_vtab)->_add_server(__pyx_cur_scope->__pyx_v_server, ((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)__pyx_cur_scope->__pyx_v_tcp)); if (unlikely(!__pyx_t_20)) __PYX_ERR(1, 1395, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_20);
__Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0;
}
__pyx_L14:;
/* "uvloop/loop.pyx":1397
* server._add_server(tcp)
*
* return server # <<<<<<<<<<<<<<
*
* async def create_connection(self, protocol_factory, host=None, port=None, *,
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = NULL; __Pyx_ReturnWithStopIteration(((PyObject *)__pyx_cur_scope->__pyx_v_server));
goto __pyx_L0;
CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
/* "uvloop/loop.pyx":1271
* return await self._getnameinfo(ai.ai_addr, flags)
*
* async def create_server(self, protocol_factory, host=None, port=None, # <<<<<<<<<<<<<<
* *,
* int family=uv.AF_UNSPEC,
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_20);
__Pyx_AddTraceback("create_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_L0:;
__Pyx_XDECREF(__pyx_r); __pyx_r = 0;
__pyx_generator->resume_label = -1;
__Pyx_Coroutine_clear((PyObject*)__pyx_generator);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_56generator2(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */
/* "uvloop/loop.pyx":1399
* return server
*
* async def create_connection(self, protocol_factory, host=None, port=None, *, # <<<<<<<<<<<<<<
* ssl=None, family=0, proto=0, flags=0, sock=None,
* local_addr=None, server_hostname=None):
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_55create_connection(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_54create_connection[] = "Loop.create_connection(self, protocol_factory, host=None, port=None, *, ssl=None, family=0, proto=0, flags=0, sock=None, local_addr=None, server_hostname=None)\nConnect to a TCP server.\n\n Create a streaming transport connection to a given Internet host and\n port: socket family AF_INET or socket.AF_INET6 depending on host (or\n family if specified), socket type SOCK_STREAM. protocol_factory must be\n a callable returning a protocol instance.\n\n This method is a coroutine which will try to establish the connection\n in the background. When successful, the coroutine returns a\n (transport, protocol) pair.\n ";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_55create_connection(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_protocol_factory = 0;
PyObject *__pyx_v_host = 0;
PyObject *__pyx_v_port = 0;
PyObject *__pyx_v_ssl = 0;
PyObject *__pyx_v_family = 0;
PyObject *__pyx_v_proto = 0;
PyObject *__pyx_v_flags = 0;
PyObject *__pyx_v_sock = 0;
PyObject *__pyx_v_local_addr = 0;
PyObject *__pyx_v_server_hostname = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("create_connection (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_protocol_factory,&__pyx_n_s_host,&__pyx_n_s_port,&__pyx_n_s_ssl,&__pyx_n_s_family,&__pyx_n_s_proto,&__pyx_n_s_flags,&__pyx_n_s_sock,&__pyx_n_s_local_addr,&__pyx_n_s_server_hostname,0};
PyObject* values[10] = {0,0,0,0,0,0,0,0,0,0};
values[1] = ((PyObject *)Py_None);
values[2] = ((PyObject *)Py_None);
/* "uvloop/loop.pyx":1400
*
* async def create_connection(self, protocol_factory, host=None, port=None, *,
* ssl=None, family=0, proto=0, flags=0, sock=None, # <<<<<<<<<<<<<<
* local_addr=None, server_hostname=None):
* """Connect to a TCP server.
*/
values[3] = ((PyObject *)Py_None);
values[4] = ((PyObject *)__pyx_int_0);
values[5] = ((PyObject *)__pyx_int_0);
values[6] = ((PyObject *)__pyx_int_0);
values[7] = ((PyObject *)Py_None);
/* "uvloop/loop.pyx":1401
* async def create_connection(self, protocol_factory, host=None, port=None, *,
* ssl=None, family=0, proto=0, flags=0, sock=None,
* local_addr=None, server_hostname=None): # <<<<<<<<<<<<<<
* """Connect to a TCP server.
*
*/
values[8] = ((PyObject *)Py_None);
values[9] = ((PyObject *)Py_None);
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_protocol_factory)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
case 1:
if (kw_args > 0) {
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_host);
if (value) { values[1] = value; kw_args--; }
}
case 2:
if (kw_args > 0) {
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_port);
if (value) { values[2] = value; kw_args--; }
}
}
if (kw_args > 0 && likely(kw_args <= 7)) {
Py_ssize_t index;
for (index = 3; index < 10 && kw_args > 0; index++) {
PyObject* value = PyDict_GetItem(__pyx_kwds, *__pyx_pyargnames[index]);
if (value) { values[index] = value; kw_args--; }
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create_connection") < 0)) __PYX_ERR(1, 1399, __pyx_L3_error)
}
} else {
switch (PyTuple_GET_SIZE(__pyx_args)) {
case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
break;
default: goto __pyx_L5_argtuple_error;
}
}
__pyx_v_protocol_factory = values[0];
__pyx_v_host = values[1];
__pyx_v_port = values[2];
__pyx_v_ssl = values[3];
__pyx_v_family = values[4];
__pyx_v_proto = values[5];
__pyx_v_flags = values[6];
__pyx_v_sock = values[7];
__pyx_v_local_addr = values[8];
__pyx_v_server_hostname = values[9];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("create_connection", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1399, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.create_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_54create_connection(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_protocol_factory, __pyx_v_host, __pyx_v_port, __pyx_v_ssl, __pyx_v_family, __pyx_v_proto, __pyx_v_flags, __pyx_v_sock, __pyx_v_local_addr, __pyx_v_server_hostname);
/* "uvloop/loop.pyx":1399
* return server
*
* async def create_connection(self, protocol_factory, host=None, port=None, *, # <<<<<<<<<<<<<<
* ssl=None, family=0, proto=0, flags=0, sock=None,
* local_addr=None, server_hostname=None):
*/
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_17create_connection_2generator17(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */
/* "uvloop/loop.pyx":1567
* # If they all have the same str(), raise one.
* model = str(exceptions[0])
* if all(str(exc) == model for exc in exceptions): # <<<<<<<<<<<<<<
* raise exceptions[0]
* # Raise a combined exception so the user can see all
*/
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_17create_connection_genexpr(PyObject *__pyx_self) {
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_7_genexpr *__pyx_cur_scope;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("genexpr", 0);
__pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_7_genexpr *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_7_genexpr(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_7_genexpr, __pyx_empty_tuple, NULL);
if (unlikely(!__pyx_cur_scope)) {
__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_7_genexpr *)Py_None);
__Pyx_INCREF(Py_None);
__PYX_ERR(1, 1567, __pyx_L1_error)
} else {
__Pyx_GOTREF(__pyx_cur_scope);
}
__pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_create_connection *) __pyx_self;
__Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_outer_scope));
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope);
{
__pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_17create_connection_2generator17, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_create_connection_locals_genexpr, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(1, 1567, __pyx_L1_error)
__Pyx_DECREF(__pyx_cur_scope);
__Pyx_RefNannyFinishContext();
return (PyObject *) gen;
}
/* function exit code */
__pyx_L1_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.create_connection.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__Pyx_DECREF(((PyObject *)__pyx_cur_scope));
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_17create_connection_2generator17(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */
{
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_7_genexpr *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_7_genexpr *)__pyx_generator->closure);
PyObject *__pyx_r = NULL;
PyObject *__pyx_t_1 = NULL;
Py_ssize_t __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
int __pyx_t_5;
int __pyx_t_6;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("None", 0);
switch (__pyx_generator->resume_label) {
case 0: goto __pyx_L3_first_run;
default: /* CPython raises the right error here */
__Pyx_RefNannyFinishContext();
return NULL;
}
__pyx_L3_first_run:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 1567, __pyx_L1_error)
if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_exceptions)) { __Pyx_RaiseClosureNameError("exceptions"); __PYX_ERR(1, 1567, __pyx_L1_error) }
if (unlikely(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_exceptions == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
__PYX_ERR(1, 1567, __pyx_L1_error)
}
__pyx_t_1 = __pyx_cur_scope->__pyx_outer_scope->__pyx_v_exceptions; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
for (;;) {
if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 1567, __pyx_L1_error)
#else
__pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1567, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
__Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_exc);
__Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_exc, __pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
__pyx_t_3 = 0;
__pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1567, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_exc);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_exc);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_cur_scope->__pyx_v_exc);
__pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1567, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_model)) { __Pyx_RaiseClosureNameError("model"); __PYX_ERR(1, 1567, __pyx_L1_error) }
__pyx_t_5 = (__Pyx_PyUnicode_Equals(__pyx_t_4, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_model, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(1, 1567, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_6 = ((!__pyx_t_5) != 0);
if (__pyx_t_6) {
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(Py_False);
__pyx_r = Py_False;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
goto __pyx_L0;
}
}
/*else*/ {
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(Py_True);
__pyx_r = Py_True;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
goto __pyx_L0;
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__pyx_generator->resume_label = -1;
__Pyx_Coroutine_clear((PyObject*)__pyx_generator);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_17create_connection_5generator18(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */
/* "uvloop/loop.pyx":1572
* # the various error messages.
* raise OSError('Multiple exceptions: {}'.format(
* ', '.join(str(exc) for exc in exceptions))) # <<<<<<<<<<<<<<
* else:
* if sock is None:
*/
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_17create_connection_3genexpr(PyObject *__pyx_self) {
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_genexpr *__pyx_cur_scope;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("genexpr", 0);
__pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_genexpr *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_8_genexpr(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_8_genexpr, __pyx_empty_tuple, NULL);
if (unlikely(!__pyx_cur_scope)) {
__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_genexpr *)Py_None);
__Pyx_INCREF(Py_None);
__PYX_ERR(1, 1572, __pyx_L1_error)
} else {
__Pyx_GOTREF(__pyx_cur_scope);
}
__pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_create_connection *) __pyx_self;
__Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_outer_scope));
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope);
{
__pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_17create_connection_5generator18, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_create_connection_locals_genexpr, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(1, 1572, __pyx_L1_error)
__Pyx_DECREF(__pyx_cur_scope);
__Pyx_RefNannyFinishContext();
return (PyObject *) gen;
}
/* function exit code */
__pyx_L1_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.create_connection.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__Pyx_DECREF(((PyObject *)__pyx_cur_scope));
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_17create_connection_5generator18(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */
{
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_genexpr *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_8_genexpr *)__pyx_generator->closure);
PyObject *__pyx_r = NULL;
PyObject *__pyx_t_1 = NULL;
Py_ssize_t __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("None", 0);
switch (__pyx_generator->resume_label) {
case 0: goto __pyx_L3_first_run;
default: /* CPython raises the right error here */
__Pyx_RefNannyFinishContext();
return NULL;
}
__pyx_L3_first_run:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 1572, __pyx_L1_error)
__pyx_r = PyList_New(0); if (unlikely(!__pyx_r)) __PYX_ERR(1, 1572, __pyx_L1_error)
__Pyx_GOTREF(__pyx_r);
if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_exceptions)) { __Pyx_RaiseClosureNameError("exceptions"); __PYX_ERR(1, 1572, __pyx_L1_error) }
if (unlikely(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_exceptions == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
__PYX_ERR(1, 1572, __pyx_L1_error)
}
__pyx_t_1 = __pyx_cur_scope->__pyx_outer_scope->__pyx_v_exceptions; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0;
for (;;) {
if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_3 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(1, 1572, __pyx_L1_error)
#else
__pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1572, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
#endif
__Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_exc);
__Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_exc, __pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
__pyx_t_3 = 0;
__pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1572, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_exc);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_exc);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_cur_scope->__pyx_v_exc);
__pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1572, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (unlikely(__Pyx_ListComp_Append(__pyx_r, (PyObject*)__pyx_t_4))) __PYX_ERR(1, 1572, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_r); __pyx_r = 0;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__pyx_generator->resume_label = -1;
__Pyx_Coroutine_clear((PyObject*)__pyx_generator);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1399
* return server
*
* async def create_connection(self, protocol_factory, host=None, port=None, *, # <<<<<<<<<<<<<<
* ssl=None, family=0, proto=0, flags=0, sock=None,
* local_addr=None, server_hostname=None):
*/
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_54create_connection(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_host, PyObject *__pyx_v_port, PyObject *__pyx_v_ssl, PyObject *__pyx_v_family, PyObject *__pyx_v_proto, PyObject *__pyx_v_flags, PyObject *__pyx_v_sock, PyObject *__pyx_v_local_addr, PyObject *__pyx_v_server_hostname) {
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_create_connection *__pyx_cur_scope;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("create_connection", 0);
__pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_create_connection *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_6_create_connection(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_6_create_connection, __pyx_empty_tuple, NULL);
if (unlikely(!__pyx_cur_scope)) {
__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_create_connection *)Py_None);
__Pyx_INCREF(Py_None);
__PYX_ERR(1, 1399, __pyx_L1_error)
} else {
__Pyx_GOTREF(__pyx_cur_scope);
}
__pyx_cur_scope->__pyx_v_self = __pyx_v_self;
__Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__pyx_cur_scope->__pyx_v_protocol_factory = __pyx_v_protocol_factory;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol_factory);
__pyx_cur_scope->__pyx_v_host = __pyx_v_host;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_host);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_host);
__pyx_cur_scope->__pyx_v_port = __pyx_v_port;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_port);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_port);
__pyx_cur_scope->__pyx_v_ssl = __pyx_v_ssl;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl);
__pyx_cur_scope->__pyx_v_family = __pyx_v_family;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_family);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_family);
__pyx_cur_scope->__pyx_v_proto = __pyx_v_proto;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_proto);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_proto);
__pyx_cur_scope->__pyx_v_flags = __pyx_v_flags;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_flags);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_flags);
__pyx_cur_scope->__pyx_v_sock = __pyx_v_sock;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
__pyx_cur_scope->__pyx_v_local_addr = __pyx_v_local_addr;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_local_addr);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_local_addr);
__pyx_cur_scope->__pyx_v_server_hostname = __pyx_v_server_hostname;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_server_hostname);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_server_hostname);
{
__pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_56generator2, (PyObject *) __pyx_cur_scope, __pyx_n_s_create_connection, __pyx_n_s_Loop_create_connection, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(1, 1399, __pyx_L1_error)
__Pyx_DECREF(__pyx_cur_scope);
__Pyx_RefNannyFinishContext();
return (PyObject *) gen;
}
/* function exit code */
__pyx_L1_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.create_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__Pyx_DECREF(((PyObject *)__pyx_cur_scope));
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_56generator2(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */
{
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_create_connection *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_6_create_connection *)__pyx_generator->closure);
PyObject *__pyx_r = NULL;
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
int __pyx_t_8;
PyObject *__pyx_t_9 = NULL;
PyObject *__pyx_t_10 = NULL;
PyObject *__pyx_t_11 = NULL;
int __pyx_t_12;
int __pyx_t_13;
int __pyx_t_14;
int __pyx_t_15;
Py_ssize_t __pyx_t_16;
PyObject *__pyx_t_17 = NULL;
PyObject *__pyx_t_18 = NULL;
struct addrinfo *__pyx_t_19;
PyObject *__pyx_t_20 = NULL;
PyObject *__pyx_t_21 = NULL;
PyObject *__pyx_t_22 = NULL;
char const *__pyx_t_23;
PyObject *__pyx_t_24 = NULL;
PyObject *__pyx_t_25 = NULL;
PyObject *__pyx_t_26 = NULL;
PyObject *__pyx_t_27 = NULL;
PyObject *__pyx_t_28 = NULL;
PyObject *__pyx_t_29 = NULL;
char const *__pyx_t_30;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("None", 0);
switch (__pyx_generator->resume_label) {
case 0: goto __pyx_L3_first_run;
case 1: goto __pyx_L10_resume_from_yield;
case 2: goto __pyx_L46_resume_from_yield;
case 3: goto __pyx_L85_resume_from_yield;
case 4: goto __pyx_L112_resume_from_yield;
case 5: goto __pyx_L116_resume_from_yield;
default: /* CPython raises the right error here */
__Pyx_RefNannyFinishContext();
return NULL;
}
__pyx_L3_first_run:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 1399, __pyx_L1_error)
/* "uvloop/loop.pyx":1414
* """
* cdef:
* AddrInfo ai_local = None # <<<<<<<<<<<<<<
* AddrInfo ai_remote
* TCPTransport tr
*/
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__pyx_cur_scope->__pyx_v_ai_local = ((struct __pyx_obj_6uvloop_4loop_AddrInfo *)Py_None);
/* "uvloop/loop.pyx":1418
* TCPTransport tr
*
* system.addrinfo *rai = NULL # <<<<<<<<<<<<<<
* system.addrinfo *lai = NULL
*
*/
__pyx_cur_scope->__pyx_v_rai = NULL;
/* "uvloop/loop.pyx":1419
*
* system.addrinfo *rai = NULL
* system.addrinfo *lai = NULL # <<<<<<<<<<<<<<
*
* system.addrinfo *rai_iter = NULL
*/
__pyx_cur_scope->__pyx_v_lai = NULL;
/* "uvloop/loop.pyx":1421
* system.addrinfo *lai = NULL
*
* system.addrinfo *rai_iter = NULL # <<<<<<<<<<<<<<
* system.addrinfo *lai_iter = NULL
*
*/
__pyx_cur_scope->__pyx_v_rai_iter = NULL;
/* "uvloop/loop.pyx":1422
*
* system.addrinfo *rai_iter = NULL
* system.addrinfo *lai_iter = NULL # <<<<<<<<<<<<<<
*
* system.addrinfo rai_static
*/
__pyx_cur_scope->__pyx_v_lai_iter = NULL;
/* "uvloop/loop.pyx":1433
* object ssl_waiter
*
* if sock is not None and sock.family == uv.AF_UNIX: # <<<<<<<<<<<<<<
* if host is not None or port is not None:
* raise ValueError(
*/
__pyx_t_2 = (__pyx_cur_scope->__pyx_v_sock != Py_None);
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
} else {
__pyx_t_1 = __pyx_t_3;
goto __pyx_L5_bool_binop_done;
}
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_family); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1433, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = __Pyx_PyInt_From_int(AF_UNIX); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1433, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = PyObject_RichCompare(__pyx_t_4, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1433, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(1, 1433, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_1 = __pyx_t_3;
__pyx_L5_bool_binop_done:;
if (__pyx_t_1) {
/* "uvloop/loop.pyx":1434
*
* if sock is not None and sock.family == uv.AF_UNIX:
* if host is not None or port is not None: # <<<<<<<<<<<<<<
* raise ValueError(
* 'host/port and sock can not be specified at the same time')
*/
__pyx_t_3 = (__pyx_cur_scope->__pyx_v_host != Py_None);
__pyx_t_2 = (__pyx_t_3 != 0);
if (!__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L8_bool_binop_done;
}
__pyx_t_2 = (__pyx_cur_scope->__pyx_v_port != Py_None);
__pyx_t_3 = (__pyx_t_2 != 0);
__pyx_t_1 = __pyx_t_3;
__pyx_L8_bool_binop_done:;
if (__pyx_t_1) {
/* "uvloop/loop.pyx":1435
* if sock is not None and sock.family == uv.AF_UNIX:
* if host is not None or port is not None:
* raise ValueError( # <<<<<<<<<<<<<<
* 'host/port and sock can not be specified at the same time')
* return await self.create_unix_connection(
*/
__pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__57, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1435, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_Raise(__pyx_t_6, 0, 0, 0);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__PYX_ERR(1, 1435, __pyx_L1_error)
/* "uvloop/loop.pyx":1434
*
* if sock is not None and sock.family == uv.AF_UNIX:
* if host is not None or port is not None: # <<<<<<<<<<<<<<
* raise ValueError(
* 'host/port and sock can not be specified at the same time')
*/
}
/* "uvloop/loop.pyx":1437
* raise ValueError(
* 'host/port and sock can not be specified at the same time')
* return await self.create_unix_connection( # <<<<<<<<<<<<<<
* protocol_factory, None,
* sock=sock, ssl=ssl, server_hostname=server_hostname)
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_create_unix_connection); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1437, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
/* "uvloop/loop.pyx":1438
* 'host/port and sock can not be specified at the same time')
* return await self.create_unix_connection(
* protocol_factory, None, # <<<<<<<<<<<<<<
* sock=sock, ssl=ssl, server_hostname=server_hostname)
*
*/
__pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1437, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol_factory);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_cur_scope->__pyx_v_protocol_factory);
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
PyTuple_SET_ITEM(__pyx_t_5, 1, Py_None);
/* "uvloop/loop.pyx":1439
* return await self.create_unix_connection(
* protocol_factory, None,
* sock=sock, ssl=ssl, server_hostname=server_hostname) # <<<<<<<<<<<<<<
*
* app_protocol = protocol = protocol_factory()
*/
__pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1439, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_sock, __pyx_cur_scope->__pyx_v_sock) < 0) __PYX_ERR(1, 1439, __pyx_L1_error)
if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_ssl, __pyx_cur_scope->__pyx_v_ssl) < 0) __PYX_ERR(1, 1439, __pyx_L1_error)
if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_server_hostname, __pyx_cur_scope->__pyx_v_server_hostname) < 0) __PYX_ERR(1, 1439, __pyx_L1_error)
/* "uvloop/loop.pyx":1437
* raise ValueError(
* 'host/port and sock can not be specified at the same time')
* return await self.create_unix_connection( # <<<<<<<<<<<<<<
* protocol_factory, None,
* sock=sock, ssl=ssl, server_hostname=server_hostname)
*/
__pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1437, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_7);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XGOTREF(__pyx_r);
if (likely(__pyx_r)) {
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
/* return from generator, yielding value */
__pyx_generator->resume_label = 1;
return __pyx_r;
__pyx_L10_resume_from_yield:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 1437, __pyx_L1_error)
__pyx_t_7 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_7);
} else {
__pyx_t_7 = NULL;
if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_7) < 0) __PYX_ERR(1, 1437, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
}
__pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_7);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_7 = 0;
goto __pyx_L0;
/* "uvloop/loop.pyx":1433
* object ssl_waiter
*
* if sock is not None and sock.family == uv.AF_UNIX: # <<<<<<<<<<<<<<
* if host is not None or port is not None:
* raise ValueError(
*/
}
/* "uvloop/loop.pyx":1441
* sock=sock, ssl=ssl, server_hostname=server_hostname)
*
* app_protocol = protocol = protocol_factory() # <<<<<<<<<<<<<<
* ssl_waiter = None
* if ssl:
*/
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
__pyx_t_4 = __pyx_cur_scope->__pyx_v_protocol_factory; __pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (__pyx_t_5) {
__pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1441, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
__pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1441, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_INCREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_7);
__pyx_cur_scope->__pyx_v_app_protocol = __pyx_t_7;
__Pyx_INCREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_7);
__pyx_cur_scope->__pyx_v_protocol = __pyx_t_7;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "uvloop/loop.pyx":1442
*
* app_protocol = protocol = protocol_factory()
* ssl_waiter = None # <<<<<<<<<<<<<<
* if ssl:
* if server_hostname is None:
*/
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__pyx_cur_scope->__pyx_v_ssl_waiter = Py_None;
/* "uvloop/loop.pyx":1443
* app_protocol = protocol = protocol_factory()
* ssl_waiter = None
* if ssl: # <<<<<<<<<<<<<<
* if server_hostname is None:
* if not host:
*/
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_ssl); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 1443, __pyx_L1_error)
if (__pyx_t_1) {
/* "uvloop/loop.pyx":1444
* ssl_waiter = None
* if ssl:
* if server_hostname is None: # <<<<<<<<<<<<<<
* if not host:
* raise ValueError('You must set server_hostname '
*/
__pyx_t_1 = (__pyx_cur_scope->__pyx_v_server_hostname == Py_None);
__pyx_t_3 = (__pyx_t_1 != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1445
* if ssl:
* if server_hostname is None:
* if not host: # <<<<<<<<<<<<<<
* raise ValueError('You must set server_hostname '
* 'when using ssl without a host')
*/
__pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_host); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(1, 1445, __pyx_L1_error)
__pyx_t_1 = ((!__pyx_t_3) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":1446
* if server_hostname is None:
* if not host:
* raise ValueError('You must set server_hostname ' # <<<<<<<<<<<<<<
* 'when using ssl without a host')
* server_hostname = host
*/
__pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__58, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1446, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_Raise(__pyx_t_7, 0, 0, 0);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__PYX_ERR(1, 1446, __pyx_L1_error)
/* "uvloop/loop.pyx":1445
* if ssl:
* if server_hostname is None:
* if not host: # <<<<<<<<<<<<<<
* raise ValueError('You must set server_hostname '
* 'when using ssl without a host')
*/
}
/* "uvloop/loop.pyx":1448
* raise ValueError('You must set server_hostname '
* 'when using ssl without a host')
* server_hostname = host # <<<<<<<<<<<<<<
*
* ssl_waiter = self._new_future()
*/
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_host);
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_server_hostname);
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_server_hostname, __pyx_cur_scope->__pyx_v_host);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_host);
/* "uvloop/loop.pyx":1444
* ssl_waiter = None
* if ssl:
* if server_hostname is None: # <<<<<<<<<<<<<<
* if not host:
* raise ValueError('You must set server_hostname '
*/
}
/* "uvloop/loop.pyx":1450
* server_hostname = host
*
* ssl_waiter = self._new_future() # <<<<<<<<<<<<<<
* sslcontext = None if isinstance(ssl, bool) else ssl
* protocol = aio_SSLProtocol(
*/
__pyx_t_7 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1450, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_ssl_waiter);
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_ssl_waiter, __pyx_t_7);
__Pyx_GIVEREF(__pyx_t_7);
__pyx_t_7 = 0;
/* "uvloop/loop.pyx":1451
*
* ssl_waiter = self._new_future()
* sslcontext = None if isinstance(ssl, bool) else ssl # <<<<<<<<<<<<<<
* protocol = aio_SSLProtocol(
* self, app_protocol, sslcontext, ssl_waiter,
*/
__pyx_t_4 = ((PyObject*)&PyBool_Type);
__Pyx_INCREF(__pyx_t_4);
__pyx_t_1 = PyObject_IsInstance(__pyx_cur_scope->__pyx_v_ssl, __pyx_t_4); if (unlikely(__pyx_t_1 == -1)) __PYX_ERR(1, 1451, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if ((__pyx_t_1 != 0)) {
__Pyx_INCREF(Py_None);
__pyx_t_7 = Py_None;
} else {
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl);
__pyx_t_7 = __pyx_cur_scope->__pyx_v_ssl;
}
__Pyx_GIVEREF(__pyx_t_7);
__pyx_cur_scope->__pyx_v_sslcontext = __pyx_t_7;
__pyx_t_7 = 0;
/* "uvloop/loop.pyx":1454
* protocol = aio_SSLProtocol(
* self, app_protocol, sslcontext, ssl_waiter,
* False, server_hostname) # <<<<<<<<<<<<<<
* else:
* if server_hostname is not None:
*/
__Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_SSLProtocol);
__pyx_t_4 = __pyx_v_6uvloop_4loop_aio_SSLProtocol; __pyx_t_5 = NULL;
__pyx_t_8 = 0;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
__pyx_t_8 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[7] = {__pyx_t_5, ((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_cur_scope->__pyx_v_app_protocol, __pyx_cur_scope->__pyx_v_sslcontext, __pyx_cur_scope->__pyx_v_ssl_waiter, Py_False, __pyx_cur_scope->__pyx_v_server_hostname};
__pyx_t_7 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 6+__pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1452, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_7);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[7] = {__pyx_t_5, ((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_cur_scope->__pyx_v_app_protocol, __pyx_cur_scope->__pyx_v_sslcontext, __pyx_cur_scope->__pyx_v_ssl_waiter, Py_False, __pyx_cur_scope->__pyx_v_server_hostname};
__pyx_t_7 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_8, 6+__pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1452, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_7);
} else
#endif
{
__pyx_t_6 = PyTuple_New(6+__pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1452, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
if (__pyx_t_5) {
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
}
__Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_8, ((PyObject *)__pyx_cur_scope->__pyx_v_self));
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_app_protocol);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_app_protocol);
PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_8, __pyx_cur_scope->__pyx_v_app_protocol);
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_sslcontext);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sslcontext);
PyTuple_SET_ITEM(__pyx_t_6, 2+__pyx_t_8, __pyx_cur_scope->__pyx_v_sslcontext);
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl_waiter);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl_waiter);
PyTuple_SET_ITEM(__pyx_t_6, 3+__pyx_t_8, __pyx_cur_scope->__pyx_v_ssl_waiter);
__Pyx_INCREF(Py_False);
__Pyx_GIVEREF(Py_False);
PyTuple_SET_ITEM(__pyx_t_6, 4+__pyx_t_8, Py_False);
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_server_hostname);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_server_hostname);
PyTuple_SET_ITEM(__pyx_t_6, 5+__pyx_t_8, __pyx_cur_scope->__pyx_v_server_hostname);
__pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1452, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_protocol);
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_protocol, __pyx_t_7);
__Pyx_GIVEREF(__pyx_t_7);
__pyx_t_7 = 0;
/* "uvloop/loop.pyx":1443
* app_protocol = protocol = protocol_factory()
* ssl_waiter = None
* if ssl: # <<<<<<<<<<<<<<
* if server_hostname is None:
* if not host:
*/
goto __pyx_L11;
}
/* "uvloop/loop.pyx":1456
* False, server_hostname)
* else:
* if server_hostname is not None: # <<<<<<<<<<<<<<
* raise ValueError('server_hostname is only meaningful with ssl')
*
*/
/*else*/ {
__pyx_t_1 = (__pyx_cur_scope->__pyx_v_server_hostname != Py_None);
__pyx_t_3 = (__pyx_t_1 != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1457
* else:
* if server_hostname is not None:
* raise ValueError('server_hostname is only meaningful with ssl') # <<<<<<<<<<<<<<
*
* if host is not None or port is not None:
*/
__pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__59, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1457, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_Raise(__pyx_t_7, 0, 0, 0);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__PYX_ERR(1, 1457, __pyx_L1_error)
/* "uvloop/loop.pyx":1456
* False, server_hostname)
* else:
* if server_hostname is not None: # <<<<<<<<<<<<<<
* raise ValueError('server_hostname is only meaningful with ssl')
*
*/
}
}
__pyx_L11:;
/* "uvloop/loop.pyx":1459
* raise ValueError('server_hostname is only meaningful with ssl')
*
* if host is not None or port is not None: # <<<<<<<<<<<<<<
* if sock is not None:
* raise ValueError(
*/
__pyx_t_1 = (__pyx_cur_scope->__pyx_v_host != Py_None);
__pyx_t_2 = (__pyx_t_1 != 0);
if (!__pyx_t_2) {
} else {
__pyx_t_3 = __pyx_t_2;
goto __pyx_L16_bool_binop_done;
}
__pyx_t_2 = (__pyx_cur_scope->__pyx_v_port != Py_None);
__pyx_t_1 = (__pyx_t_2 != 0);
__pyx_t_3 = __pyx_t_1;
__pyx_L16_bool_binop_done:;
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1460
*
* if host is not None or port is not None:
* if sock is not None: # <<<<<<<<<<<<<<
* raise ValueError(
* 'host/port and sock can not be specified at the same time')
*/
__pyx_t_3 = (__pyx_cur_scope->__pyx_v_sock != Py_None);
__pyx_t_1 = (__pyx_t_3 != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":1461
* if host is not None or port is not None:
* if sock is not None:
* raise ValueError( # <<<<<<<<<<<<<<
* 'host/port and sock can not be specified at the same time')
*
*/
__pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__60, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1461, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_Raise(__pyx_t_7, 0, 0, 0);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__PYX_ERR(1, 1461, __pyx_L1_error)
/* "uvloop/loop.pyx":1460
*
* if host is not None or port is not None:
* if sock is not None: # <<<<<<<<<<<<<<
* raise ValueError(
* 'host/port and sock can not be specified at the same time')
*/
}
/* "uvloop/loop.pyx":1464
* 'host/port and sock can not be specified at the same time')
*
* fs = [] # <<<<<<<<<<<<<<
* f1 = f2 = None
*
*/
__pyx_t_7 = PyList_New(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1464, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_7);
__pyx_cur_scope->__pyx_v_fs = ((PyObject*)__pyx_t_7);
__pyx_t_7 = 0;
/* "uvloop/loop.pyx":1465
*
* fs = []
* f1 = f2 = None # <<<<<<<<<<<<<<
*
* try:
*/
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__pyx_cur_scope->__pyx_v_f1 = Py_None;
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__pyx_cur_scope->__pyx_v_f2 = Py_None;
/* "uvloop/loop.pyx":1467
* f1 = f2 = None
*
* try: # <<<<<<<<<<<<<<
* __static_getaddrinfo(
* host, port, family, uv.SOCK_STREAM,
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11);
__Pyx_XGOTREF(__pyx_t_9);
__Pyx_XGOTREF(__pyx_t_10);
__Pyx_XGOTREF(__pyx_t_11);
/*try:*/ {
/* "uvloop/loop.pyx":1469
* try:
* __static_getaddrinfo(
* host, port, family, uv.SOCK_STREAM, # <<<<<<<<<<<<<<
* proto, &rai_addr_static)
* except LookupError:
*/
__pyx_t_8 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_family); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1469, __pyx_L19_error)
/* "uvloop/loop.pyx":1470
* __static_getaddrinfo(
* host, port, family, uv.SOCK_STREAM,
* proto, &rai_addr_static) # <<<<<<<<<<<<<<
* except LookupError:
* f1 = self._getaddrinfo(
*/
__pyx_t_12 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_proto); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1470, __pyx_L19_error)
/* "uvloop/loop.pyx":1468
*
* try:
* __static_getaddrinfo( # <<<<<<<<<<<<<<
* host, port, family, uv.SOCK_STREAM,
* proto, &rai_addr_static)
*/
__pyx_t_7 = __pyx_f_6uvloop_4loop___static_getaddrinfo(__pyx_cur_scope->__pyx_v_host, __pyx_cur_scope->__pyx_v_port, __pyx_t_8, SOCK_STREAM, __pyx_t_12, ((struct sockaddr *)(&__pyx_cur_scope->__pyx_v_rai_addr_static))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1468, __pyx_L19_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "uvloop/loop.pyx":1467
* f1 = f2 = None
*
* try: # <<<<<<<<<<<<<<
* __static_getaddrinfo(
* host, port, family, uv.SOCK_STREAM,
*/
}
/* "uvloop/loop.pyx":1479
* fs.append(f1)
* else:
* rai_static.ai_addr = &rai_addr_static # <<<<<<<<<<<<<<
* rai_static.ai_next = NULL
* rai = &rai_static
*/
/*else:*/ {
__pyx_cur_scope->__pyx_v_rai_static.ai_addr = ((struct sockaddr *)(&__pyx_cur_scope->__pyx_v_rai_addr_static));
/* "uvloop/loop.pyx":1480
* else:
* rai_static.ai_addr = &rai_addr_static
* rai_static.ai_next = NULL # <<<<<<<<<<<<<<
* rai = &rai_static
*
*/
__pyx_cur_scope->__pyx_v_rai_static.ai_next = NULL;
/* "uvloop/loop.pyx":1481
* rai_static.ai_addr = &rai_addr_static
* rai_static.ai_next = NULL
* rai = &rai_static # <<<<<<<<<<<<<<
*
* if local_addr is not None:
*/
__pyx_cur_scope->__pyx_v_rai = (&__pyx_cur_scope->__pyx_v_rai_static);
}
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
goto __pyx_L26_try_end;
__pyx_L19_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "uvloop/loop.pyx":1471
* host, port, family, uv.SOCK_STREAM,
* proto, &rai_addr_static)
* except LookupError: # <<<<<<<<<<<<<<
* f1 = self._getaddrinfo(
* host, port, family,
*/
__pyx_t_12 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_LookupError);
if (__pyx_t_12) {
__Pyx_AddTraceback("uvloop.loop.Loop.create_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_4, &__pyx_t_6) < 0) __PYX_ERR(1, 1471, __pyx_L21_except_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GOTREF(__pyx_t_6);
/* "uvloop/loop.pyx":1473
* except LookupError:
* f1 = self._getaddrinfo(
* host, port, family, # <<<<<<<<<<<<<<
* uv.SOCK_STREAM, proto, flags,
* 0) # 0 == don't unpack
*/
__pyx_t_12 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_family); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1473, __pyx_L21_except_error)
/* "uvloop/loop.pyx":1474
* f1 = self._getaddrinfo(
* host, port, family,
* uv.SOCK_STREAM, proto, flags, # <<<<<<<<<<<<<<
* 0) # 0 == don't unpack
*
*/
__pyx_t_8 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_proto); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1474, __pyx_L21_except_error)
__pyx_t_13 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_flags); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1474, __pyx_L21_except_error)
/* "uvloop/loop.pyx":1472
* proto, &rai_addr_static)
* except LookupError:
* f1 = self._getaddrinfo( # <<<<<<<<<<<<<<
* host, port, family,
* uv.SOCK_STREAM, proto, flags,
*/
__pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_getaddrinfo(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_host, __pyx_cur_scope->__pyx_v_port, __pyx_t_12, SOCK_STREAM, __pyx_t_8, __pyx_t_13, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1472, __pyx_L21_except_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_f1);
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_f1, __pyx_t_5);
__Pyx_GIVEREF(__pyx_t_5);
__pyx_t_5 = 0;
/* "uvloop/loop.pyx":1477
* 0) # 0 == don't unpack
*
* fs.append(f1) # <<<<<<<<<<<<<<
* else:
* rai_static.ai_addr = &rai_addr_static
*/
__pyx_t_14 = __Pyx_PyList_Append(__pyx_cur_scope->__pyx_v_fs, __pyx_cur_scope->__pyx_v_f1); if (unlikely(__pyx_t_14 == -1)) __PYX_ERR(1, 1477, __pyx_L21_except_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
goto __pyx_L20_exception_handled;
}
goto __pyx_L21_except_error;
__pyx_L21_except_error:;
/* "uvloop/loop.pyx":1467
* f1 = f2 = None
*
* try: # <<<<<<<<<<<<<<
* __static_getaddrinfo(
* host, port, family, uv.SOCK_STREAM,
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_XGIVEREF(__pyx_t_10);
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11);
goto __pyx_L1_error;
__pyx_L20_exception_handled:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_XGIVEREF(__pyx_t_10);
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11);
__pyx_L26_try_end:;
}
/* "uvloop/loop.pyx":1483
* rai = &rai_static
*
* if local_addr is not None: # <<<<<<<<<<<<<<
* if not isinstance(local_addr, (tuple, list)) or \
* len(local_addr) != 2:
*/
__pyx_t_1 = (__pyx_cur_scope->__pyx_v_local_addr != Py_None);
__pyx_t_3 = (__pyx_t_1 != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1484
*
* if local_addr is not None:
* if not isinstance(local_addr, (tuple, list)) or \ # <<<<<<<<<<<<<<
* len(local_addr) != 2:
* raise ValueError(
*/
__pyx_t_2 = PyTuple_Check(__pyx_cur_scope->__pyx_v_local_addr);
__pyx_t_15 = (__pyx_t_2 != 0);
if (!__pyx_t_15) {
} else {
__pyx_t_1 = __pyx_t_15;
goto __pyx_L33_bool_binop_done;
}
__pyx_t_15 = PyList_Check(__pyx_cur_scope->__pyx_v_local_addr);
__pyx_t_2 = (__pyx_t_15 != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L33_bool_binop_done:;
__pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0);
if (!__pyx_t_2) {
} else {
__pyx_t_3 = __pyx_t_2;
goto __pyx_L31_bool_binop_done;
}
/* "uvloop/loop.pyx":1485
* if local_addr is not None:
* if not isinstance(local_addr, (tuple, list)) or \
* len(local_addr) != 2: # <<<<<<<<<<<<<<
* raise ValueError(
* 'local_addr must be a tuple of host and port')
*/
__pyx_t_16 = PyObject_Length(__pyx_cur_scope->__pyx_v_local_addr); if (unlikely(__pyx_t_16 == -1)) __PYX_ERR(1, 1485, __pyx_L1_error)
__pyx_t_2 = ((__pyx_t_16 != 2) != 0);
__pyx_t_3 = __pyx_t_2;
__pyx_L31_bool_binop_done:;
/* "uvloop/loop.pyx":1484
*
* if local_addr is not None:
* if not isinstance(local_addr, (tuple, list)) or \ # <<<<<<<<<<<<<<
* len(local_addr) != 2:
* raise ValueError(
*/
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1486
* if not isinstance(local_addr, (tuple, list)) or \
* len(local_addr) != 2:
* raise ValueError( # <<<<<<<<<<<<<<
* 'local_addr must be a tuple of host and port')
*
*/
__pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1486, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_Raise(__pyx_t_6, 0, 0, 0);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__PYX_ERR(1, 1486, __pyx_L1_error)
/* "uvloop/loop.pyx":1484
*
* if local_addr is not None:
* if not isinstance(local_addr, (tuple, list)) or \ # <<<<<<<<<<<<<<
* len(local_addr) != 2:
* raise ValueError(
*/
}
/* "uvloop/loop.pyx":1489
* 'local_addr must be a tuple of host and port')
*
* try: # <<<<<<<<<<<<<<
* __static_getaddrinfo(
* local_addr[0], local_addr[1],
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_10, &__pyx_t_9);
__Pyx_XGOTREF(__pyx_t_11);
__Pyx_XGOTREF(__pyx_t_10);
__Pyx_XGOTREF(__pyx_t_9);
/*try:*/ {
/* "uvloop/loop.pyx":1491
* try:
* __static_getaddrinfo(
* local_addr[0], local_addr[1], # <<<<<<<<<<<<<<
* family, uv.SOCK_STREAM,
* proto, &lai_addr_static)
*/
__pyx_t_6 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_local_addr, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1491, __pyx_L35_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_4 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_local_addr, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1491, __pyx_L35_error)
__Pyx_GOTREF(__pyx_t_4);
/* "uvloop/loop.pyx":1492
* __static_getaddrinfo(
* local_addr[0], local_addr[1],
* family, uv.SOCK_STREAM, # <<<<<<<<<<<<<<
* proto, &lai_addr_static)
* except LookupError:
*/
__pyx_t_13 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_family); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1492, __pyx_L35_error)
/* "uvloop/loop.pyx":1493
* local_addr[0], local_addr[1],
* family, uv.SOCK_STREAM,
* proto, &lai_addr_static) # <<<<<<<<<<<<<<
* except LookupError:
* f2 = self._getaddrinfo(
*/
__pyx_t_8 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_proto); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1493, __pyx_L35_error)
/* "uvloop/loop.pyx":1490
*
* try:
* __static_getaddrinfo( # <<<<<<<<<<<<<<
* local_addr[0], local_addr[1],
* family, uv.SOCK_STREAM,
*/
__pyx_t_7 = __pyx_f_6uvloop_4loop___static_getaddrinfo(__pyx_t_6, __pyx_t_4, __pyx_t_13, SOCK_STREAM, __pyx_t_8, ((struct sockaddr *)(&__pyx_cur_scope->__pyx_v_lai_addr_static))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1490, __pyx_L35_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "uvloop/loop.pyx":1489
* 'local_addr must be a tuple of host and port')
*
* try: # <<<<<<<<<<<<<<
* __static_getaddrinfo(
* local_addr[0], local_addr[1],
*/
}
/* "uvloop/loop.pyx":1502
* fs.append(f2)
* else:
* lai_static.ai_addr = &lai_addr_static # <<<<<<<<<<<<<<
* lai_static.ai_next = NULL
* lai = &lai_static
*/
/*else:*/ {
__pyx_cur_scope->__pyx_v_lai_static.ai_addr = ((struct sockaddr *)(&__pyx_cur_scope->__pyx_v_lai_addr_static));
/* "uvloop/loop.pyx":1503
* else:
* lai_static.ai_addr = &lai_addr_static
* lai_static.ai_next = NULL # <<<<<<<<<<<<<<
* lai = &lai_static
*
*/
__pyx_cur_scope->__pyx_v_lai_static.ai_next = NULL;
/* "uvloop/loop.pyx":1504
* lai_static.ai_addr = &lai_addr_static
* lai_static.ai_next = NULL
* lai = &lai_static # <<<<<<<<<<<<<<
*
* if len(fs):
*/
__pyx_cur_scope->__pyx_v_lai = (&__pyx_cur_scope->__pyx_v_lai_static);
}
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
goto __pyx_L42_try_end;
__pyx_L35_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "uvloop/loop.pyx":1494
* family, uv.SOCK_STREAM,
* proto, &lai_addr_static)
* except LookupError: # <<<<<<<<<<<<<<
* f2 = self._getaddrinfo(
* local_addr[0], local_addr[1], family,
*/
__pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_LookupError);
if (__pyx_t_8) {
__Pyx_AddTraceback("uvloop.loop.Loop.create_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_4, &__pyx_t_6) < 0) __PYX_ERR(1, 1494, __pyx_L37_except_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GOTREF(__pyx_t_6);
/* "uvloop/loop.pyx":1496
* except LookupError:
* f2 = self._getaddrinfo(
* local_addr[0], local_addr[1], family, # <<<<<<<<<<<<<<
* uv.SOCK_STREAM, proto, flags,
* 0) # 0 == don't unpack
*/
__pyx_t_5 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_local_addr, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1496, __pyx_L37_except_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_17 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_local_addr, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_17)) __PYX_ERR(1, 1496, __pyx_L37_except_error)
__Pyx_GOTREF(__pyx_t_17);
__pyx_t_8 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_family); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1496, __pyx_L37_except_error)
/* "uvloop/loop.pyx":1497
* f2 = self._getaddrinfo(
* local_addr[0], local_addr[1], family,
* uv.SOCK_STREAM, proto, flags, # <<<<<<<<<<<<<<
* 0) # 0 == don't unpack
*
*/
__pyx_t_13 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_proto); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1497, __pyx_L37_except_error)
__pyx_t_12 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_flags); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1497, __pyx_L37_except_error)
/* "uvloop/loop.pyx":1495
* proto, &lai_addr_static)
* except LookupError:
* f2 = self._getaddrinfo( # <<<<<<<<<<<<<<
* local_addr[0], local_addr[1], family,
* uv.SOCK_STREAM, proto, flags,
*/
__pyx_t_18 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_getaddrinfo(__pyx_cur_scope->__pyx_v_self, __pyx_t_5, __pyx_t_17, __pyx_t_8, SOCK_STREAM, __pyx_t_13, __pyx_t_12, 0); if (unlikely(!__pyx_t_18)) __PYX_ERR(1, 1495, __pyx_L37_except_error)
__Pyx_GOTREF(__pyx_t_18);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_f2);
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_f2, __pyx_t_18);
__Pyx_GIVEREF(__pyx_t_18);
__pyx_t_18 = 0;
/* "uvloop/loop.pyx":1500
* 0) # 0 == don't unpack
*
* fs.append(f2) # <<<<<<<<<<<<<<
* else:
* lai_static.ai_addr = &lai_addr_static
*/
__pyx_t_14 = __Pyx_PyList_Append(__pyx_cur_scope->__pyx_v_fs, __pyx_cur_scope->__pyx_v_f2); if (unlikely(__pyx_t_14 == -1)) __PYX_ERR(1, 1500, __pyx_L37_except_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
goto __pyx_L36_exception_handled;
}
goto __pyx_L37_except_error;
__pyx_L37_except_error:;
/* "uvloop/loop.pyx":1489
* 'local_addr must be a tuple of host and port')
*
* try: # <<<<<<<<<<<<<<
* __static_getaddrinfo(
* local_addr[0], local_addr[1],
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_XGIVEREF(__pyx_t_10);
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_ExceptionReset(__pyx_t_11, __pyx_t_10, __pyx_t_9);
goto __pyx_L1_error;
__pyx_L36_exception_handled:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_XGIVEREF(__pyx_t_10);
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_ExceptionReset(__pyx_t_11, __pyx_t_10, __pyx_t_9);
__pyx_L42_try_end:;
}
/* "uvloop/loop.pyx":1483
* rai = &rai_static
*
* if local_addr is not None: # <<<<<<<<<<<<<<
* if not isinstance(local_addr, (tuple, list)) or \
* len(local_addr) != 2:
*/
}
/* "uvloop/loop.pyx":1506
* lai = &lai_static
*
* if len(fs): # <<<<<<<<<<<<<<
* await aio_wait(fs, loop=self)
*
*/
__pyx_t_16 = PyList_GET_SIZE(__pyx_cur_scope->__pyx_v_fs); if (unlikely(__pyx_t_16 == -1)) __PYX_ERR(1, 1506, __pyx_L1_error)
__pyx_t_3 = (__pyx_t_16 != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1507
*
* if len(fs):
* await aio_wait(fs, loop=self) # <<<<<<<<<<<<<<
*
* if rai is NULL:
*/
__pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1507, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_fs);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_fs);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_cur_scope->__pyx_v_fs);
__pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1507, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_loop, ((PyObject *)__pyx_cur_scope->__pyx_v_self)) < 0) __PYX_ERR(1, 1507, __pyx_L1_error)
__pyx_t_7 = __Pyx_PyObject_Call(__pyx_v_6uvloop_4loop_aio_wait, __pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1507, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_7);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XGOTREF(__pyx_r);
if (likely(__pyx_r)) {
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
/* return from generator, yielding value */
__pyx_generator->resume_label = 2;
return __pyx_r;
__pyx_L46_resume_from_yield:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 1507, __pyx_L1_error)
} else {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(1, 1507, __pyx_L1_error)
}
}
/* "uvloop/loop.pyx":1506
* lai = &lai_static
*
* if len(fs): # <<<<<<<<<<<<<<
* await aio_wait(fs, loop=self)
*
*/
}
/* "uvloop/loop.pyx":1509
* await aio_wait(fs, loop=self)
*
* if rai is NULL: # <<<<<<<<<<<<<<
* ai_remote = f1.result()
* if ai_remote.data is NULL:
*/
__pyx_t_3 = ((__pyx_cur_scope->__pyx_v_rai == NULL) != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1510
*
* if rai is NULL:
* ai_remote = f1.result() # <<<<<<<<<<<<<<
* if ai_remote.data is NULL:
* raise OSError('getaddrinfo() returned empty list')
*/
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_f1, __pyx_n_s_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1510, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (__pyx_t_6) {
__pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1510, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
__pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1510, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_ptype_6uvloop_4loop_AddrInfo))))) __PYX_ERR(1, 1510, __pyx_L1_error)
__Pyx_GIVEREF(__pyx_t_7);
__pyx_cur_scope->__pyx_v_ai_remote = ((struct __pyx_obj_6uvloop_4loop_AddrInfo *)__pyx_t_7);
__pyx_t_7 = 0;
/* "uvloop/loop.pyx":1511
* if rai is NULL:
* ai_remote = f1.result()
* if ai_remote.data is NULL: # <<<<<<<<<<<<<<
* raise OSError('getaddrinfo() returned empty list')
* rai = ai_remote.data
*/
__pyx_t_3 = ((__pyx_cur_scope->__pyx_v_ai_remote->data == NULL) != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1512
* ai_remote = f1.result()
* if ai_remote.data is NULL:
* raise OSError('getaddrinfo() returned empty list') # <<<<<<<<<<<<<<
* rai = ai_remote.data
*
*/
__pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_tuple__62, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1512, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_Raise(__pyx_t_7, 0, 0, 0);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__PYX_ERR(1, 1512, __pyx_L1_error)
/* "uvloop/loop.pyx":1511
* if rai is NULL:
* ai_remote = f1.result()
* if ai_remote.data is NULL: # <<<<<<<<<<<<<<
* raise OSError('getaddrinfo() returned empty list')
* rai = ai_remote.data
*/
}
/* "uvloop/loop.pyx":1513
* if ai_remote.data is NULL:
* raise OSError('getaddrinfo() returned empty list')
* rai = ai_remote.data # <<<<<<<<<<<<<<
*
* if lai is NULL and f2 is not None:
*/
__pyx_t_19 = __pyx_cur_scope->__pyx_v_ai_remote->data;
__pyx_cur_scope->__pyx_v_rai = __pyx_t_19;
/* "uvloop/loop.pyx":1509
* await aio_wait(fs, loop=self)
*
* if rai is NULL: # <<<<<<<<<<<<<<
* ai_remote = f1.result()
* if ai_remote.data is NULL:
*/
}
/* "uvloop/loop.pyx":1515
* rai = ai_remote.data
*
* if lai is NULL and f2 is not None: # <<<<<<<<<<<<<<
* ai_local = f2.result()
* if ai_local.data is NULL:
*/
__pyx_t_2 = ((__pyx_cur_scope->__pyx_v_lai == NULL) != 0);
if (__pyx_t_2) {
} else {
__pyx_t_3 = __pyx_t_2;
goto __pyx_L50_bool_binop_done;
}
__pyx_t_2 = (__pyx_cur_scope->__pyx_v_f2 != Py_None);
__pyx_t_1 = (__pyx_t_2 != 0);
__pyx_t_3 = __pyx_t_1;
__pyx_L50_bool_binop_done:;
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1516
*
* if lai is NULL and f2 is not None:
* ai_local = f2.result() # <<<<<<<<<<<<<<
* if ai_local.data is NULL:
* raise OSError(
*/
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_f2, __pyx_n_s_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1516, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (__pyx_t_6) {
__pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1516, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
__pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1516, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (!(likely(((__pyx_t_7) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_7, __pyx_ptype_6uvloop_4loop_AddrInfo))))) __PYX_ERR(1, 1516, __pyx_L1_error)
__Pyx_GOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_ai_local));
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_ai_local, ((struct __pyx_obj_6uvloop_4loop_AddrInfo *)__pyx_t_7));
__Pyx_GIVEREF(__pyx_t_7);
__pyx_t_7 = 0;
/* "uvloop/loop.pyx":1517
* if lai is NULL and f2 is not None:
* ai_local = f2.result()
* if ai_local.data is NULL: # <<<<<<<<<<<<<<
* raise OSError(
* 'getaddrinfo() returned empty list for local_addr')
*/
__pyx_t_3 = ((__pyx_cur_scope->__pyx_v_ai_local->data == NULL) != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1518
* ai_local = f2.result()
* if ai_local.data is NULL:
* raise OSError( # <<<<<<<<<<<<<<
* 'getaddrinfo() returned empty list for local_addr')
* lai = ai_local.data
*/
__pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_tuple__63, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1518, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_Raise(__pyx_t_7, 0, 0, 0);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__PYX_ERR(1, 1518, __pyx_L1_error)
/* "uvloop/loop.pyx":1517
* if lai is NULL and f2 is not None:
* ai_local = f2.result()
* if ai_local.data is NULL: # <<<<<<<<<<<<<<
* raise OSError(
* 'getaddrinfo() returned empty list for local_addr')
*/
}
/* "uvloop/loop.pyx":1520
* raise OSError(
* 'getaddrinfo() returned empty list for local_addr')
* lai = ai_local.data # <<<<<<<<<<<<<<
*
* exceptions = []
*/
__pyx_t_19 = __pyx_cur_scope->__pyx_v_ai_local->data;
__pyx_cur_scope->__pyx_v_lai = __pyx_t_19;
/* "uvloop/loop.pyx":1515
* rai = ai_remote.data
*
* if lai is NULL and f2 is not None: # <<<<<<<<<<<<<<
* ai_local = f2.result()
* if ai_local.data is NULL:
*/
}
/* "uvloop/loop.pyx":1522
* lai = ai_local.data
*
* exceptions = [] # <<<<<<<<<<<<<<
* rai_iter = rai
* while rai_iter is not NULL:
*/
__pyx_t_7 = PyList_New(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1522, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_7);
__pyx_cur_scope->__pyx_v_exceptions = ((PyObject*)__pyx_t_7);
__pyx_t_7 = 0;
/* "uvloop/loop.pyx":1523
*
* exceptions = []
* rai_iter = rai # <<<<<<<<<<<<<<
* while rai_iter is not NULL:
* tr = None
*/
__pyx_cur_scope->__pyx_v_rai_iter = __pyx_cur_scope->__pyx_v_rai;
/* "uvloop/loop.pyx":1524
* exceptions = []
* rai_iter = rai
* while rai_iter is not NULL: # <<<<<<<<<<<<<<
* tr = None
* try:
*/
while (1) {
__pyx_t_3 = ((__pyx_cur_scope->__pyx_v_rai_iter != NULL) != 0);
if (!__pyx_t_3) break;
/* "uvloop/loop.pyx":1525
* rai_iter = rai
* while rai_iter is not NULL:
* tr = None # <<<<<<<<<<<<<<
* try:
* waiter = self._new_future()
*/
__Pyx_INCREF(Py_None);
__Pyx_XGOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_tr));
__Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_tr, ((struct __pyx_obj_6uvloop_4loop_TCPTransport *)Py_None));
__Pyx_GIVEREF(Py_None);
/* "uvloop/loop.pyx":1526
* while rai_iter is not NULL:
* tr = None
* try: # <<<<<<<<<<<<<<
* waiter = self._new_future()
* tr = TCPTransport.new(self, protocol, None, waiter)
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11);
__Pyx_XGOTREF(__pyx_t_9);
__Pyx_XGOTREF(__pyx_t_10);
__Pyx_XGOTREF(__pyx_t_11);
/*try:*/ {
/* "uvloop/loop.pyx":1527
* tr = None
* try:
* waiter = self._new_future() # <<<<<<<<<<<<<<
* tr = TCPTransport.new(self, protocol, None, waiter)
*
*/
__pyx_t_7 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1527, __pyx_L55_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_waiter);
__Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_waiter, __pyx_t_7);
__Pyx_GIVEREF(__pyx_t_7);
__pyx_t_7 = 0;
/* "uvloop/loop.pyx":1528
* try:
* waiter = self._new_future()
* tr = TCPTransport.new(self, protocol, None, waiter) # <<<<<<<<<<<<<<
*
* if lai is not NULL:
*/
__pyx_t_7 = ((PyObject *)__pyx_f_6uvloop_4loop_12TCPTransport_new(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_protocol, ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None), __pyx_cur_scope->__pyx_v_waiter)); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1528, __pyx_L55_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_tr));
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_tr, ((struct __pyx_obj_6uvloop_4loop_TCPTransport *)__pyx_t_7));
__Pyx_GIVEREF(__pyx_t_7);
__pyx_t_7 = 0;
/* "uvloop/loop.pyx":1530
* tr = TCPTransport.new(self, protocol, None, waiter)
*
* if lai is not NULL: # <<<<<<<<<<<<<<
* lai_iter = lai
* while lai_iter is not NULL:
*/
__pyx_t_3 = ((__pyx_cur_scope->__pyx_v_lai != NULL) != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1531
*
* if lai is not NULL:
* lai_iter = lai # <<<<<<<<<<<<<<
* while lai_iter is not NULL:
* try:
*/
__pyx_cur_scope->__pyx_v_lai_iter = __pyx_cur_scope->__pyx_v_lai;
/* "uvloop/loop.pyx":1532
* if lai is not NULL:
* lai_iter = lai
* while lai_iter is not NULL: # <<<<<<<<<<<<<<
* try:
* tr.bind(lai_iter.ai_addr)
*/
while (1) {
__pyx_t_3 = ((__pyx_cur_scope->__pyx_v_lai_iter != NULL) != 0);
if (!__pyx_t_3) break;
/* "uvloop/loop.pyx":1533
* lai_iter = lai
* while lai_iter is not NULL:
* try: # <<<<<<<<<<<<<<
* tr.bind(lai_iter.ai_addr)
* break
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22);
__Pyx_XGOTREF(__pyx_t_20);
__Pyx_XGOTREF(__pyx_t_21);
__Pyx_XGOTREF(__pyx_t_22);
/*try:*/ {
/* "uvloop/loop.pyx":1534
* while lai_iter is not NULL:
* try:
* tr.bind(lai_iter.ai_addr) # <<<<<<<<<<<<<<
* break
* except OSError as exc:
*/
__pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->bind(__pyx_cur_scope->__pyx_v_tr, __pyx_cur_scope->__pyx_v_lai_iter->ai_addr, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1534, __pyx_L66_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "uvloop/loop.pyx":1535
* try:
* tr.bind(lai_iter.ai_addr)
* break # <<<<<<<<<<<<<<
* except OSError as exc:
* exceptions.append(exc)
*/
goto __pyx_L71_try_break;
/* "uvloop/loop.pyx":1533
* lai_iter = lai
* while lai_iter is not NULL:
* try: # <<<<<<<<<<<<<<
* tr.bind(lai_iter.ai_addr)
* break
*/
}
__pyx_L66_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
__Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "uvloop/loop.pyx":1536
* tr.bind(lai_iter.ai_addr)
* break
* except OSError as exc: # <<<<<<<<<<<<<<
* exceptions.append(exc)
* lai_iter = lai_iter.ai_next
*/
__pyx_t_12 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_OSError);
if (__pyx_t_12) {
__Pyx_AddTraceback("uvloop.loop.Loop.create_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_4, &__pyx_t_6) < 0) __PYX_ERR(1, 1536, __pyx_L68_except_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GOTREF(__pyx_t_6);
__Pyx_INCREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_4);
__pyx_cur_scope->__pyx_v_exc = __pyx_t_4;
/*try:*/ {
/* "uvloop/loop.pyx":1537
* break
* except OSError as exc:
* exceptions.append(exc) # <<<<<<<<<<<<<<
* lai_iter = lai_iter.ai_next
* else:
*/
__pyx_t_14 = __Pyx_PyList_Append(__pyx_cur_scope->__pyx_v_exceptions, __pyx_cur_scope->__pyx_v_exc); if (unlikely(__pyx_t_14 == -1)) __PYX_ERR(1, 1537, __pyx_L79_error)
}
/* "uvloop/loop.pyx":1536
* tr.bind(lai_iter.ai_addr)
* break
* except OSError as exc: # <<<<<<<<<<<<<<
* exceptions.append(exc)
* lai_iter = lai_iter.ai_next
*/
/*finally:*/ {
/*normal exit:*/{
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_exc);
__Pyx_DECREF(__pyx_cur_scope->__pyx_v_exc);
__pyx_cur_scope->__pyx_v_exc = NULL;
goto __pyx_L80;
}
/*exception exit:*/{
__Pyx_PyThreadState_declare
__pyx_L79_error:;
__pyx_t_24 = 0; __pyx_t_25 = 0; __pyx_t_26 = 0; __pyx_t_27 = 0; __pyx_t_28 = 0; __pyx_t_29 = 0;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
__Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_27, &__pyx_t_28, &__pyx_t_29);
if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_24, &__pyx_t_25, &__pyx_t_26) < 0)) __Pyx_ErrFetch(&__pyx_t_24, &__pyx_t_25, &__pyx_t_26);
__Pyx_XGOTREF(__pyx_t_24);
__Pyx_XGOTREF(__pyx_t_25);
__Pyx_XGOTREF(__pyx_t_26);
__Pyx_XGOTREF(__pyx_t_27);
__Pyx_XGOTREF(__pyx_t_28);
__Pyx_XGOTREF(__pyx_t_29);
__pyx_t_12 = __pyx_lineno; __pyx_t_13 = __pyx_clineno; __pyx_t_23 = __pyx_filename;
{
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_exc);
__Pyx_DECREF(__pyx_cur_scope->__pyx_v_exc);
__pyx_cur_scope->__pyx_v_exc = NULL;
}
__Pyx_PyThreadState_assign
if (PY_MAJOR_VERSION >= 3) {
__Pyx_XGIVEREF(__pyx_t_27);
__Pyx_XGIVEREF(__pyx_t_28);
__Pyx_XGIVEREF(__pyx_t_29);
__Pyx_ExceptionReset(__pyx_t_27, __pyx_t_28, __pyx_t_29);
}
__Pyx_XGIVEREF(__pyx_t_24);
__Pyx_XGIVEREF(__pyx_t_25);
__Pyx_XGIVEREF(__pyx_t_26);
__Pyx_ErrRestore(__pyx_t_24, __pyx_t_25, __pyx_t_26);
__pyx_t_24 = 0; __pyx_t_25 = 0; __pyx_t_26 = 0; __pyx_t_27 = 0; __pyx_t_28 = 0; __pyx_t_29 = 0;
__pyx_lineno = __pyx_t_12; __pyx_clineno = __pyx_t_13; __pyx_filename = __pyx_t_23;
goto __pyx_L68_except_error;
}
__pyx_L80:;
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
goto __pyx_L67_exception_handled;
}
goto __pyx_L68_except_error;
__pyx_L68_except_error:;
/* "uvloop/loop.pyx":1533
* lai_iter = lai
* while lai_iter is not NULL:
* try: # <<<<<<<<<<<<<<
* tr.bind(lai_iter.ai_addr)
* break
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_20);
__Pyx_XGIVEREF(__pyx_t_21);
__Pyx_XGIVEREF(__pyx_t_22);
__Pyx_ExceptionReset(__pyx_t_20, __pyx_t_21, __pyx_t_22);
goto __pyx_L55_error;
__pyx_L71_try_break:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_20);
__Pyx_XGIVEREF(__pyx_t_21);
__Pyx_XGIVEREF(__pyx_t_22);
__Pyx_ExceptionReset(__pyx_t_20, __pyx_t_21, __pyx_t_22);
goto __pyx_L65_break;
__pyx_L67_exception_handled:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_20);
__Pyx_XGIVEREF(__pyx_t_21);
__Pyx_XGIVEREF(__pyx_t_22);
__Pyx_ExceptionReset(__pyx_t_20, __pyx_t_21, __pyx_t_22);
}
/* "uvloop/loop.pyx":1538
* except OSError as exc:
* exceptions.append(exc)
* lai_iter = lai_iter.ai_next # <<<<<<<<<<<<<<
* else:
* tr._close()
*/
__pyx_t_19 = __pyx_cur_scope->__pyx_v_lai_iter->ai_next;
__pyx_cur_scope->__pyx_v_lai_iter = __pyx_t_19;
}
/* "uvloop/loop.pyx":1540
* lai_iter = lai_iter.ai_next
* else:
* tr._close() # <<<<<<<<<<<<<<
* tr = None
*
*/
/*else*/ {
__pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_cur_scope->__pyx_v_tr)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1540, __pyx_L55_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "uvloop/loop.pyx":1541
* else:
* tr._close()
* tr = None # <<<<<<<<<<<<<<
*
* rai_iter = rai_iter.ai_next
*/
__Pyx_INCREF(Py_None);
__Pyx_GOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_tr));
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_tr, ((struct __pyx_obj_6uvloop_4loop_TCPTransport *)Py_None));
__Pyx_GIVEREF(Py_None);
/* "uvloop/loop.pyx":1543
* tr = None
*
* rai_iter = rai_iter.ai_next # <<<<<<<<<<<<<<
* continue
*
*/
__pyx_t_19 = __pyx_cur_scope->__pyx_v_rai_iter->ai_next;
__pyx_cur_scope->__pyx_v_rai_iter = __pyx_t_19;
/* "uvloop/loop.pyx":1544
*
* rai_iter = rai_iter.ai_next
* continue # <<<<<<<<<<<<<<
*
* tr.connect(rai_iter.ai_addr)
*/
goto __pyx_L61_try_continue;
}
__pyx_L65_break:;
/* "uvloop/loop.pyx":1530
* tr = TCPTransport.new(self, protocol, None, waiter)
*
* if lai is not NULL: # <<<<<<<<<<<<<<
* lai_iter = lai
* while lai_iter is not NULL:
*/
}
/* "uvloop/loop.pyx":1546
* continue
*
* tr.connect(rai_iter.ai_addr) # <<<<<<<<<<<<<<
* await waiter
*
*/
__pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->connect(__pyx_cur_scope->__pyx_v_tr, __pyx_cur_scope->__pyx_v_rai_iter->ai_addr); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1546, __pyx_L55_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "uvloop/loop.pyx":1547
*
* tr.connect(rai_iter.ai_addr)
* await waiter # <<<<<<<<<<<<<<
*
* except OSError as exc:
*/
__pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_waiter);
__Pyx_XGOTREF(__pyx_r);
if (likely(__pyx_r)) {
__Pyx_XGIVEREF(__pyx_t_9);
__pyx_cur_scope->__pyx_t_0 = __pyx_t_9;
__Pyx_XGIVEREF(__pyx_t_10);
__pyx_cur_scope->__pyx_t_1 = __pyx_t_10;
__Pyx_XGIVEREF(__pyx_t_11);
__pyx_cur_scope->__pyx_t_2 = __pyx_t_11;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
/* return from generator, yielding value */
__pyx_generator->resume_label = 3;
return __pyx_r;
__pyx_L85_resume_from_yield:;
__pyx_t_9 = __pyx_cur_scope->__pyx_t_0;
__pyx_cur_scope->__pyx_t_0 = 0;
__Pyx_XGOTREF(__pyx_t_9);
__pyx_t_10 = __pyx_cur_scope->__pyx_t_1;
__pyx_cur_scope->__pyx_t_1 = 0;
__Pyx_XGOTREF(__pyx_t_10);
__pyx_t_11 = __pyx_cur_scope->__pyx_t_2;
__pyx_cur_scope->__pyx_t_2 = 0;
__Pyx_XGOTREF(__pyx_t_11);
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 1547, __pyx_L55_error)
} else {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(1, 1547, __pyx_L55_error)
}
}
/* "uvloop/loop.pyx":1526
* while rai_iter is not NULL:
* tr = None
* try: # <<<<<<<<<<<<<<
* waiter = self._new_future()
* tr = TCPTransport.new(self, protocol, None, waiter)
*/
}
/* "uvloop/loop.pyx":1560
* raise
* else:
* break # <<<<<<<<<<<<<<
*
* rai_iter = rai_iter.ai_next
*/
/*else:*/ {
goto __pyx_L60_try_break;
}
__pyx_L55_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
__Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "uvloop/loop.pyx":1549
* await waiter
*
* except OSError as exc: # <<<<<<<<<<<<<<
* if tr is not None:
* tr._close()
*/
__pyx_t_13 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_OSError);
if (__pyx_t_13) {
__Pyx_AddTraceback("uvloop.loop.Loop.create_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_4, &__pyx_t_7) < 0) __PYX_ERR(1, 1549, __pyx_L57_except_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GOTREF(__pyx_t_7);
__Pyx_INCREF(__pyx_t_4);
__Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_exc);
__Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_exc, __pyx_t_4);
__Pyx_GIVEREF(__pyx_t_4);
/*try:*/ {
/* "uvloop/loop.pyx":1550
*
* except OSError as exc:
* if tr is not None: # <<<<<<<<<<<<<<
* tr._close()
* tr = None
*/
__pyx_t_3 = (((PyObject *)__pyx_cur_scope->__pyx_v_tr) != Py_None);
__pyx_t_1 = (__pyx_t_3 != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":1551
* except OSError as exc:
* if tr is not None:
* tr._close() # <<<<<<<<<<<<<<
* tr = None
* exceptions.append(exc)
*/
__pyx_t_18 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_cur_scope->__pyx_v_tr)); if (unlikely(!__pyx_t_18)) __PYX_ERR(1, 1551, __pyx_L91_error)
__Pyx_GOTREF(__pyx_t_18);
__Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
/* "uvloop/loop.pyx":1552
* if tr is not None:
* tr._close()
* tr = None # <<<<<<<<<<<<<<
* exceptions.append(exc)
* except:
*/
__Pyx_INCREF(Py_None);
__Pyx_GOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_tr));
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_tr, ((struct __pyx_obj_6uvloop_4loop_TCPTransport *)Py_None));
__Pyx_GIVEREF(Py_None);
/* "uvloop/loop.pyx":1550
*
* except OSError as exc:
* if tr is not None: # <<<<<<<<<<<<<<
* tr._close()
* tr = None
*/
}
/* "uvloop/loop.pyx":1553
* tr._close()
* tr = None
* exceptions.append(exc) # <<<<<<<<<<<<<<
* except:
* if tr is not None:
*/
__pyx_t_14 = __Pyx_PyList_Append(__pyx_cur_scope->__pyx_v_exceptions, __pyx_cur_scope->__pyx_v_exc); if (unlikely(__pyx_t_14 == -1)) __PYX_ERR(1, 1553, __pyx_L91_error)
}
/* "uvloop/loop.pyx":1549
* await waiter
*
* except OSError as exc: # <<<<<<<<<<<<<<
* if tr is not None:
* tr._close()
*/
/*finally:*/ {
/*normal exit:*/{
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_exc);
__Pyx_DECREF(__pyx_cur_scope->__pyx_v_exc);
__pyx_cur_scope->__pyx_v_exc = NULL;
goto __pyx_L92;
}
/*exception exit:*/{
__Pyx_PyThreadState_declare
__pyx_L91_error:;
__pyx_t_22 = 0; __pyx_t_21 = 0; __pyx_t_20 = 0; __pyx_t_29 = 0; __pyx_t_28 = 0; __pyx_t_27 = 0;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
__Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_29, &__pyx_t_28, &__pyx_t_27);
if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_22, &__pyx_t_21, &__pyx_t_20) < 0)) __Pyx_ErrFetch(&__pyx_t_22, &__pyx_t_21, &__pyx_t_20);
__Pyx_XGOTREF(__pyx_t_22);
__Pyx_XGOTREF(__pyx_t_21);
__Pyx_XGOTREF(__pyx_t_20);
__Pyx_XGOTREF(__pyx_t_29);
__Pyx_XGOTREF(__pyx_t_28);
__Pyx_XGOTREF(__pyx_t_27);
__pyx_t_13 = __pyx_lineno; __pyx_t_12 = __pyx_clineno; __pyx_t_30 = __pyx_filename;
{
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_exc);
__Pyx_DECREF(__pyx_cur_scope->__pyx_v_exc);
__pyx_cur_scope->__pyx_v_exc = NULL;
}
__Pyx_PyThreadState_assign
if (PY_MAJOR_VERSION >= 3) {
__Pyx_XGIVEREF(__pyx_t_29);
__Pyx_XGIVEREF(__pyx_t_28);
__Pyx_XGIVEREF(__pyx_t_27);
__Pyx_ExceptionReset(__pyx_t_29, __pyx_t_28, __pyx_t_27);
}
__Pyx_XGIVEREF(__pyx_t_22);
__Pyx_XGIVEREF(__pyx_t_21);
__Pyx_XGIVEREF(__pyx_t_20);
__Pyx_ErrRestore(__pyx_t_22, __pyx_t_21, __pyx_t_20);
__pyx_t_22 = 0; __pyx_t_21 = 0; __pyx_t_20 = 0; __pyx_t_29 = 0; __pyx_t_28 = 0; __pyx_t_27 = 0;
__pyx_lineno = __pyx_t_13; __pyx_clineno = __pyx_t_12; __pyx_filename = __pyx_t_30;
goto __pyx_L57_except_error;
}
__pyx_L92:;
}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
goto __pyx_L56_exception_handled;
}
/* "uvloop/loop.pyx":1554
* tr = None
* exceptions.append(exc)
* except: # <<<<<<<<<<<<<<
* if tr is not None:
* tr._close()
*/
/*except:*/ {
__Pyx_AddTraceback("uvloop.loop.Loop.create_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_4, &__pyx_t_6) < 0) __PYX_ERR(1, 1554, __pyx_L57_except_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GOTREF(__pyx_t_6);
/* "uvloop/loop.pyx":1555
* exceptions.append(exc)
* except:
* if tr is not None: # <<<<<<<<<<<<<<
* tr._close()
* tr = None
*/
__pyx_t_1 = (((PyObject *)__pyx_cur_scope->__pyx_v_tr) != Py_None);
__pyx_t_3 = (__pyx_t_1 != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1556
* except:
* if tr is not None:
* tr._close() # <<<<<<<<<<<<<<
* tr = None
* raise
*/
__pyx_t_18 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_cur_scope->__pyx_v_tr)); if (unlikely(!__pyx_t_18)) __PYX_ERR(1, 1556, __pyx_L57_except_error)
__Pyx_GOTREF(__pyx_t_18);
__Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
/* "uvloop/loop.pyx":1557
* if tr is not None:
* tr._close()
* tr = None # <<<<<<<<<<<<<<
* raise
* else:
*/
__Pyx_INCREF(Py_None);
__Pyx_GOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_tr));
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_tr, ((struct __pyx_obj_6uvloop_4loop_TCPTransport *)Py_None));
__Pyx_GIVEREF(Py_None);
/* "uvloop/loop.pyx":1555
* exceptions.append(exc)
* except:
* if tr is not None: # <<<<<<<<<<<<<<
* tr._close()
* tr = None
*/
}
/* "uvloop/loop.pyx":1558
* tr._close()
* tr = None
* raise # <<<<<<<<<<<<<<
* else:
* break
*/
__Pyx_GIVEREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_4);
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_ErrRestoreWithState(__pyx_t_7, __pyx_t_4, __pyx_t_6);
__pyx_t_7 = 0; __pyx_t_4 = 0; __pyx_t_6 = 0;
__PYX_ERR(1, 1558, __pyx_L57_except_error)
}
__pyx_L57_except_error:;
/* "uvloop/loop.pyx":1526
* while rai_iter is not NULL:
* tr = None
* try: # <<<<<<<<<<<<<<
* waiter = self._new_future()
* tr = TCPTransport.new(self, protocol, None, waiter)
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_XGIVEREF(__pyx_t_10);
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11);
goto __pyx_L1_error;
__pyx_L60_try_break:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_XGIVEREF(__pyx_t_10);
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11);
goto __pyx_L54_break;
__pyx_L61_try_continue:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_XGIVEREF(__pyx_t_10);
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11);
goto __pyx_L53_continue;
__pyx_L56_exception_handled:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_XGIVEREF(__pyx_t_10);
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11);
}
/* "uvloop/loop.pyx":1562
* break
*
* rai_iter = rai_iter.ai_next # <<<<<<<<<<<<<<
*
* else:
*/
__pyx_t_19 = __pyx_cur_scope->__pyx_v_rai_iter->ai_next;
__pyx_cur_scope->__pyx_v_rai_iter = __pyx_t_19;
__pyx_L53_continue:;
}
/* "uvloop/loop.pyx":1566
* else:
* # If they all have the same str(), raise one.
* model = str(exceptions[0]) # <<<<<<<<<<<<<<
* if all(str(exc) == model for exc in exceptions):
* raise exceptions[0]
*/
/*else*/ {
__pyx_t_6 = __Pyx_GetItemInt_List(__pyx_cur_scope->__pyx_v_exceptions, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1566, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1566, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6);
__pyx_t_6 = 0;
__pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_t_4, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1566, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GIVEREF(__pyx_t_6);
__pyx_cur_scope->__pyx_v_model = __pyx_t_6;
__pyx_t_6 = 0;
/* "uvloop/loop.pyx":1567
* # If they all have the same str(), raise one.
* model = str(exceptions[0])
* if all(str(exc) == model for exc in exceptions): # <<<<<<<<<<<<<<
* raise exceptions[0]
* # Raise a combined exception so the user can see all
*/
__pyx_t_6 = __pyx_pf_6uvloop_4loop_4Loop_17create_connection_genexpr(((PyObject*)__pyx_cur_scope)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1567, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_4 = __Pyx_Generator_Next(__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1567, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(1, 1567, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1568
* model = str(exceptions[0])
* if all(str(exc) == model for exc in exceptions):
* raise exceptions[0] # <<<<<<<<<<<<<<
* # Raise a combined exception so the user can see all
* # the various error messages.
*/
__pyx_t_4 = __Pyx_GetItemInt_List(__pyx_cur_scope->__pyx_v_exceptions, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1568, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__PYX_ERR(1, 1568, __pyx_L1_error)
/* "uvloop/loop.pyx":1567
* # If they all have the same str(), raise one.
* model = str(exceptions[0])
* if all(str(exc) == model for exc in exceptions): # <<<<<<<<<<<<<<
* raise exceptions[0]
* # Raise a combined exception so the user can see all
*/
}
/* "uvloop/loop.pyx":1571
* # Raise a combined exception so the user can see all
* # the various error messages.
* raise OSError('Multiple exceptions: {}'.format( # <<<<<<<<<<<<<<
* ', '.join(str(exc) for exc in exceptions)))
* else:
*/
__pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Multiple_exceptions, __pyx_n_s_format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1571, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
/* "uvloop/loop.pyx":1572
* # the various error messages.
* raise OSError('Multiple exceptions: {}'.format(
* ', '.join(str(exc) for exc in exceptions))) # <<<<<<<<<<<<<<
* else:
* if sock is None:
*/
__pyx_t_7 = __pyx_pf_6uvloop_4loop_4Loop_17create_connection_3genexpr(((PyObject*)__pyx_cur_scope)); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1572, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_18 = __Pyx_Generator_Next(__pyx_t_7); if (unlikely(!__pyx_t_18)) __PYX_ERR(1, 1572, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_18);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_7 = PyUnicode_Join(__pyx_kp_u__64, __pyx_t_18); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1572, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
__pyx_t_18 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
__pyx_t_18 = PyMethod_GET_SELF(__pyx_t_6);
if (likely(__pyx_t_18)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
__Pyx_INCREF(__pyx_t_18);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_6, function);
}
}
if (!__pyx_t_18) {
__pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1571, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GOTREF(__pyx_t_4);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_6)) {
PyObject *__pyx_temp[2] = {__pyx_t_18, __pyx_t_7};
__pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1571, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
PyObject *__pyx_temp[2] = {__pyx_t_18, __pyx_t_7};
__pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1571, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else
#endif
{
__pyx_t_17 = PyTuple_New(1+1); if (unlikely(!__pyx_t_17)) __PYX_ERR(1, 1571, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_17);
__Pyx_GIVEREF(__pyx_t_18); PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_18); __pyx_t_18 = NULL;
__Pyx_GIVEREF(__pyx_t_7);
PyTuple_SET_ITEM(__pyx_t_17, 0+1, __pyx_t_7);
__pyx_t_7 = 0;
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_17, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1571, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
}
}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "uvloop/loop.pyx":1571
* # Raise a combined exception so the user can see all
* # the various error messages.
* raise OSError('Multiple exceptions: {}'.format( # <<<<<<<<<<<<<<
* ', '.join(str(exc) for exc in exceptions)))
* else:
*/
__pyx_t_6 = PyTuple_New(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1571, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4);
__pyx_t_4 = 0;
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1571, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__PYX_ERR(1, 1571, __pyx_L1_error)
}
__pyx_L54_break:;
/* "uvloop/loop.pyx":1459
* raise ValueError('server_hostname is only meaningful with ssl')
*
* if host is not None or port is not None: # <<<<<<<<<<<<<<
* if sock is not None:
* raise ValueError(
*/
goto __pyx_L15;
}
/* "uvloop/loop.pyx":1574
* ', '.join(str(exc) for exc in exceptions)))
* else:
* if sock is None: # <<<<<<<<<<<<<<
* raise ValueError(
* 'host and port was not specified and no sock specified')
*/
/*else*/ {
__pyx_t_3 = (__pyx_cur_scope->__pyx_v_sock == Py_None);
__pyx_t_1 = (__pyx_t_3 != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":1575
* else:
* if sock is None:
* raise ValueError( # <<<<<<<<<<<<<<
* 'host and port was not specified and no sock specified')
* if not _is_sock_stream(sock.type):
*/
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__65, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1575, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__PYX_ERR(1, 1575, __pyx_L1_error)
/* "uvloop/loop.pyx":1574
* ', '.join(str(exc) for exc in exceptions)))
* else:
* if sock is None: # <<<<<<<<<<<<<<
* raise ValueError(
* 'host and port was not specified and no sock specified')
*/
}
/* "uvloop/loop.pyx":1577
* raise ValueError(
* 'host and port was not specified and no sock specified')
* if not _is_sock_stream(sock.type): # <<<<<<<<<<<<<<
* raise ValueError(
* 'A Stream Socket was expected, got {!r}'.format(sock))
*/
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_type); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1577, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_6 = __pyx_f_6uvloop_4loop__is_sock_stream(__pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1577, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 1577, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_3 = ((!__pyx_t_1) != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1579
* if not _is_sock_stream(sock.type):
* raise ValueError(
* 'A Stream Socket was expected, got {!r}'.format(sock)) # <<<<<<<<<<<<<<
*
* waiter = self._new_future()
*/
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_A_Stream_Socket_was_expected_got, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1579, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_17 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_17 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_17)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_17);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (!__pyx_t_17) {
__pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_cur_scope->__pyx_v_sock); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1579, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[2] = {__pyx_t_17, __pyx_cur_scope->__pyx_v_sock};
__pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1579, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
__Pyx_GOTREF(__pyx_t_6);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[2] = {__pyx_t_17, __pyx_cur_scope->__pyx_v_sock};
__pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1579, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
__Pyx_GOTREF(__pyx_t_6);
} else
#endif
{
__pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1579, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_17); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_17); __pyx_t_17 = NULL;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_cur_scope->__pyx_v_sock);
__pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1579, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":1578
* 'host and port was not specified and no sock specified')
* if not _is_sock_stream(sock.type):
* raise ValueError( # <<<<<<<<<<<<<<
* 'A Stream Socket was expected, got {!r}'.format(sock))
*
*/
__pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1578, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6);
__pyx_t_6 = 0;
__pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1578, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_6, 0, 0, 0);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__PYX_ERR(1, 1578, __pyx_L1_error)
/* "uvloop/loop.pyx":1577
* raise ValueError(
* 'host and port was not specified and no sock specified')
* if not _is_sock_stream(sock.type): # <<<<<<<<<<<<<<
* raise ValueError(
* 'A Stream Socket was expected, got {!r}'.format(sock))
*/
}
/* "uvloop/loop.pyx":1581
* 'A Stream Socket was expected, got {!r}'.format(sock))
*
* waiter = self._new_future() # <<<<<<<<<<<<<<
* tr = TCPTransport.new(self, protocol, None, waiter)
* try:
*/
__pyx_t_6 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1581, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_6);
__pyx_cur_scope->__pyx_v_waiter = __pyx_t_6;
__pyx_t_6 = 0;
/* "uvloop/loop.pyx":1582
*
* waiter = self._new_future()
* tr = TCPTransport.new(self, protocol, None, waiter) # <<<<<<<<<<<<<<
* try:
* # Why we use os.dup here and other places
*/
__pyx_t_6 = ((PyObject *)__pyx_f_6uvloop_4loop_12TCPTransport_new(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_protocol, ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None), __pyx_cur_scope->__pyx_v_waiter)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1582, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_6);
__pyx_cur_scope->__pyx_v_tr = ((struct __pyx_obj_6uvloop_4loop_TCPTransport *)__pyx_t_6);
__pyx_t_6 = 0;
/* "uvloop/loop.pyx":1583
* waiter = self._new_future()
* tr = TCPTransport.new(self, protocol, None, waiter)
* try: # <<<<<<<<<<<<<<
* # Why we use os.dup here and other places
* # ---------------------------------------
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_10, &__pyx_t_9);
__Pyx_XGOTREF(__pyx_t_11);
__Pyx_XGOTREF(__pyx_t_10);
__Pyx_XGOTREF(__pyx_t_9);
/*try:*/ {
/* "uvloop/loop.pyx":1610
* # any control of the FD once it is passed to uvloop.
* # See also: https://github.com/python/asyncio/pull/449
* fileno = os_dup(sock.fileno()) # <<<<<<<<<<<<<<
*
* # libuv will make socket non-blocking
*/
__pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_fileno); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1610, __pyx_L104_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_17 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
__pyx_t_17 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_17)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_17);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_7, function);
}
}
if (__pyx_t_17) {
__pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_17); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1610, __pyx_L104_error)
__Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
} else {
__pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1610, __pyx_L104_error)
}
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_INCREF(__pyx_v_6uvloop_4loop_os_dup);
__pyx_t_7 = __pyx_v_6uvloop_4loop_os_dup; __pyx_t_17 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
__pyx_t_17 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_17)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_17);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_7, function);
}
}
if (!__pyx_t_17) {
__pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1610, __pyx_L104_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_6);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_7)) {
PyObject *__pyx_temp[2] = {__pyx_t_17, __pyx_t_4};
__pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1610, __pyx_L104_error)
__Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
PyObject *__pyx_temp[2] = {__pyx_t_17, __pyx_t_4};
__pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1610, __pyx_L104_error)
__Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
{
__pyx_t_18 = PyTuple_New(1+1); if (unlikely(!__pyx_t_18)) __PYX_ERR(1, 1610, __pyx_L104_error)
__Pyx_GOTREF(__pyx_t_18);
__Pyx_GIVEREF(__pyx_t_17); PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_17); __pyx_t_17 = NULL;
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_18, 0+1, __pyx_t_4);
__pyx_t_4 = 0;
__pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_18, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1610, __pyx_L104_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
}
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GIVEREF(__pyx_t_6);
__pyx_cur_scope->__pyx_v_fileno = __pyx_t_6;
__pyx_t_6 = 0;
/* "uvloop/loop.pyx":1613
*
* # libuv will make socket non-blocking
* tr._open(fileno) # <<<<<<<<<<<<<<
* tr._attach_fileobj(sock)
* tr._init_protocol()
*/
__pyx_t_12 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_fileno); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1613, __pyx_L104_error)
__pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._open(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_tr), __pyx_t_12); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1613, __pyx_L104_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "uvloop/loop.pyx":1614
* # libuv will make socket non-blocking
* tr._open(fileno)
* tr._attach_fileobj(sock) # <<<<<<<<<<<<<<
* tr._init_protocol()
* await waiter
*/
__pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._attach_fileobj(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_tr), __pyx_cur_scope->__pyx_v_sock); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1614, __pyx_L104_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "uvloop/loop.pyx":1615
* tr._open(fileno)
* tr._attach_fileobj(sock)
* tr._init_protocol() # <<<<<<<<<<<<<<
* await waiter
* except:
*/
__pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._init_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_cur_scope->__pyx_v_tr)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1615, __pyx_L104_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "uvloop/loop.pyx":1616
* tr._attach_fileobj(sock)
* tr._init_protocol()
* await waiter # <<<<<<<<<<<<<<
* except:
* tr._close()
*/
__pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_waiter);
__Pyx_XGOTREF(__pyx_r);
if (likely(__pyx_r)) {
__Pyx_XGIVEREF(__pyx_t_9);
__pyx_cur_scope->__pyx_t_0 = __pyx_t_9;
__Pyx_XGIVEREF(__pyx_t_10);
__pyx_cur_scope->__pyx_t_1 = __pyx_t_10;
__Pyx_XGIVEREF(__pyx_t_11);
__pyx_cur_scope->__pyx_t_2 = __pyx_t_11;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
/* return from generator, yielding value */
__pyx_generator->resume_label = 4;
return __pyx_r;
__pyx_L112_resume_from_yield:;
__pyx_t_9 = __pyx_cur_scope->__pyx_t_0;
__pyx_cur_scope->__pyx_t_0 = 0;
__Pyx_XGOTREF(__pyx_t_9);
__pyx_t_10 = __pyx_cur_scope->__pyx_t_1;
__pyx_cur_scope->__pyx_t_1 = 0;
__Pyx_XGOTREF(__pyx_t_10);
__pyx_t_11 = __pyx_cur_scope->__pyx_t_2;
__pyx_cur_scope->__pyx_t_2 = 0;
__Pyx_XGOTREF(__pyx_t_11);
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 1616, __pyx_L104_error)
} else {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(1, 1616, __pyx_L104_error)
}
}
/* "uvloop/loop.pyx":1583
* waiter = self._new_future()
* tr = TCPTransport.new(self, protocol, None, waiter)
* try: # <<<<<<<<<<<<<<
* # Why we use os.dup here and other places
* # ---------------------------------------
*/
}
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
goto __pyx_L111_try_end;
__pyx_L104_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "uvloop/loop.pyx":1617
* tr._init_protocol()
* await waiter
* except: # <<<<<<<<<<<<<<
* tr._close()
* raise
*/
/*except:*/ {
__Pyx_AddTraceback("uvloop.loop.Loop.create_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_7, &__pyx_t_18) < 0) __PYX_ERR(1, 1617, __pyx_L106_except_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GOTREF(__pyx_t_18);
/* "uvloop/loop.pyx":1618
* await waiter
* except:
* tr._close() # <<<<<<<<<<<<<<
* raise
*
*/
__pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_TCPTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_cur_scope->__pyx_v_tr)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1618, __pyx_L106_except_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":1619
* except:
* tr._close()
* raise # <<<<<<<<<<<<<<
*
* if ssl:
*/
__Pyx_GIVEREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_7);
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_ErrRestoreWithState(__pyx_t_6, __pyx_t_7, __pyx_t_18);
__pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_18 = 0;
__PYX_ERR(1, 1619, __pyx_L106_except_error)
}
__pyx_L106_except_error:;
/* "uvloop/loop.pyx":1583
* waiter = self._new_future()
* tr = TCPTransport.new(self, protocol, None, waiter)
* try: # <<<<<<<<<<<<<<
* # Why we use os.dup here and other places
* # ---------------------------------------
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_XGIVEREF(__pyx_t_10);
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_ExceptionReset(__pyx_t_11, __pyx_t_10, __pyx_t_9);
goto __pyx_L1_error;
__pyx_L111_try_end:;
}
}
__pyx_L15:;
/* "uvloop/loop.pyx":1621
* raise
*
* if ssl: # <<<<<<<<<<<<<<
* await ssl_waiter
* return protocol._app_transport, app_protocol
*/
__pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_ssl); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(1, 1621, __pyx_L1_error)
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1622
*
* if ssl:
* await ssl_waiter # <<<<<<<<<<<<<<
* return protocol._app_transport, app_protocol
* else:
*/
__pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_ssl_waiter);
__Pyx_XGOTREF(__pyx_r);
if (likely(__pyx_r)) {
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
/* return from generator, yielding value */
__pyx_generator->resume_label = 5;
return __pyx_r;
__pyx_L116_resume_from_yield:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 1622, __pyx_L1_error)
} else {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(1, 1622, __pyx_L1_error)
}
}
/* "uvloop/loop.pyx":1623
* if ssl:
* await ssl_waiter
* return protocol._app_transport, app_protocol # <<<<<<<<<<<<<<
* else:
* return tr, protocol
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_protocol, __pyx_n_s_app_transport); if (unlikely(!__pyx_t_18)) __PYX_ERR(1, 1623, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_18);
__pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1623, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_18);
PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_18);
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_app_protocol);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_app_protocol);
PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_cur_scope->__pyx_v_app_protocol);
__pyx_t_18 = 0;
__pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_7);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_7 = 0;
goto __pyx_L0;
/* "uvloop/loop.pyx":1621
* raise
*
* if ssl: # <<<<<<<<<<<<<<
* await ssl_waiter
* return protocol._app_transport, app_protocol
*/
}
/* "uvloop/loop.pyx":1625
* return protocol._app_transport, app_protocol
* else:
* return tr, protocol # <<<<<<<<<<<<<<
*
* async def create_unix_server(self, protocol_factory, str path=None,
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
__pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1625, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_tr));
__Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_tr));
PyTuple_SET_ITEM(__pyx_t_7, 0, ((PyObject *)__pyx_cur_scope->__pyx_v_tr));
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol);
PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_cur_scope->__pyx_v_protocol);
__pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_7);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_7 = 0;
goto __pyx_L0;
}
CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
/* "uvloop/loop.pyx":1399
* return server
*
* async def create_connection(self, protocol_factory, host=None, port=None, *, # <<<<<<<<<<<<<<
* ssl=None, family=0, proto=0, flags=0, sock=None,
* local_addr=None, server_hostname=None):
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_17);
__Pyx_XDECREF(__pyx_t_18);
__Pyx_AddTraceback("create_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_L0:;
__Pyx_XDECREF(__pyx_r); __pyx_r = 0;
__pyx_generator->resume_label = -1;
__Pyx_Coroutine_clear((PyObject*)__pyx_generator);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_59generator3(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */
/* "uvloop/loop.pyx":1627
* return tr, protocol
*
* async def create_unix_server(self, protocol_factory, str path=None, # <<<<<<<<<<<<<<
* *, backlog=100, sock=None, ssl=None):
* """A coroutine which creates a UNIX Domain Socket server.
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_58create_unix_server(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_57create_unix_server[] = "Loop.create_unix_server(self, protocol_factory, unicode path=None, *, backlog=100, sock=None, ssl=None)\nA coroutine which creates a UNIX Domain Socket server.\n\n The return value is a Server object, which can be used to stop\n the service.\n\n path is a str, representing a file systsem path to bind the\n server socket to.\n\n sock can optionally be specified in order to use a preexisting\n socket object.\n\n backlog is the maximum number of queued connections passed to\n listen() (defaults to 100).\n\n ssl can be set to an SSLContext to enable SSL over the\n accepted connections.\n ";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_58create_unix_server(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_protocol_factory = 0;
PyObject *__pyx_v_path = 0;
PyObject *__pyx_v_backlog = 0;
PyObject *__pyx_v_sock = 0;
PyObject *__pyx_v_ssl = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("create_unix_server (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_protocol_factory,&__pyx_n_s_path,&__pyx_n_s_backlog,&__pyx_n_s_sock,&__pyx_n_s_ssl,0};
PyObject* values[5] = {0,0,0,0,0};
values[1] = ((PyObject*)Py_None);
values[2] = ((PyObject *)__pyx_int_100);
/* "uvloop/loop.pyx":1628
*
* async def create_unix_server(self, protocol_factory, str path=None,
* *, backlog=100, sock=None, ssl=None): # <<<<<<<<<<<<<<
* """A coroutine which creates a UNIX Domain Socket server.
*
*/
values[3] = ((PyObject *)Py_None);
values[4] = ((PyObject *)Py_None);
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_protocol_factory)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
case 1:
if (kw_args > 0) {
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_path);
if (value) { values[1] = value; kw_args--; }
}
}
if (kw_args > 0 && likely(kw_args <= 3)) {
Py_ssize_t index;
for (index = 2; index < 5 && kw_args > 0; index++) {
PyObject* value = PyDict_GetItem(__pyx_kwds, *__pyx_pyargnames[index]);
if (value) { values[index] = value; kw_args--; }
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create_unix_server") < 0)) __PYX_ERR(1, 1627, __pyx_L3_error)
}
} else {
switch (PyTuple_GET_SIZE(__pyx_args)) {
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
break;
default: goto __pyx_L5_argtuple_error;
}
}
__pyx_v_protocol_factory = values[0];
__pyx_v_path = ((PyObject*)values[1]);
__pyx_v_backlog = values[2];
__pyx_v_sock = values[3];
__pyx_v_ssl = values[4];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("create_unix_server", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1627, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.create_unix_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_path), (&PyUnicode_Type), 1, "path", 1))) __PYX_ERR(1, 1627, __pyx_L1_error)
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_57create_unix_server(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_protocol_factory, __pyx_v_path, __pyx_v_backlog, __pyx_v_sock, __pyx_v_ssl);
/* "uvloop/loop.pyx":1627
* return tr, protocol
*
* async def create_unix_server(self, protocol_factory, str path=None, # <<<<<<<<<<<<<<
* *, backlog=100, sock=None, ssl=None):
* """A coroutine which creates a UNIX Domain Socket server.
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__pyx_r = NULL;
__pyx_L0:;
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_57create_unix_server(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_path, PyObject *__pyx_v_backlog, PyObject *__pyx_v_sock, PyObject *__pyx_v_ssl) {
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_9_create_unix_server *__pyx_cur_scope;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("create_unix_server", 0);
__pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_9_create_unix_server *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_9_create_unix_server(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_9_create_unix_server, __pyx_empty_tuple, NULL);
if (unlikely(!__pyx_cur_scope)) {
__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_9_create_unix_server *)Py_None);
__Pyx_INCREF(Py_None);
__PYX_ERR(1, 1627, __pyx_L1_error)
} else {
__Pyx_GOTREF(__pyx_cur_scope);
}
__pyx_cur_scope->__pyx_v_self = __pyx_v_self;
__Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__pyx_cur_scope->__pyx_v_protocol_factory = __pyx_v_protocol_factory;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol_factory);
__pyx_cur_scope->__pyx_v_path = __pyx_v_path;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_path);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_path);
__pyx_cur_scope->__pyx_v_backlog = __pyx_v_backlog;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_backlog);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_backlog);
__pyx_cur_scope->__pyx_v_sock = __pyx_v_sock;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
__pyx_cur_scope->__pyx_v_ssl = __pyx_v_ssl;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl);
{
__pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_59generator3, (PyObject *) __pyx_cur_scope, __pyx_n_s_create_unix_server, __pyx_n_s_Loop_create_unix_server, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(1, 1627, __pyx_L1_error)
__Pyx_DECREF(__pyx_cur_scope);
__Pyx_RefNannyFinishContext();
return (PyObject *) gen;
}
/* function exit code */
__pyx_L1_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.create_unix_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__Pyx_DECREF(((PyObject *)__pyx_cur_scope));
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_59generator3(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */
{
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_9_create_unix_server *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_9_create_unix_server *)__pyx_generator->closure);
PyObject *__pyx_r = NULL;
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
int __pyx_t_3;
int __pyx_t_4;
int __pyx_t_5;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
PyObject *__pyx_t_10 = NULL;
PyObject *__pyx_t_11 = NULL;
int __pyx_t_12;
PyObject *__pyx_t_13 = NULL;
PyObject *__pyx_t_14 = NULL;
int __pyx_t_15;
char const *__pyx_t_16;
PyObject *__pyx_t_17 = NULL;
PyObject *__pyx_t_18 = NULL;
PyObject *__pyx_t_19 = NULL;
PyObject *__pyx_t_20 = NULL;
PyObject *__pyx_t_21 = NULL;
PyObject *__pyx_t_22 = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("None", 0);
switch (__pyx_generator->resume_label) {
case 0: goto __pyx_L3_first_run;
default: /* CPython raises the right error here */
__Pyx_RefNannyFinishContext();
return NULL;
}
__pyx_L3_first_run:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 1627, __pyx_L1_error)
/* "uvloop/loop.pyx":1648
* cdef:
* UnixServer pipe
* Server server = Server(self) # <<<<<<<<<<<<<<
*
* if ssl is not None and not isinstance(ssl, ssl_SSLContext):
*/
__pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1648, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_cur_scope->__pyx_v_self));
__pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_6uvloop_4loop_Server), __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1648, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_GIVEREF(__pyx_t_2);
__pyx_cur_scope->__pyx_v_server = ((struct __pyx_obj_6uvloop_4loop_Server *)__pyx_t_2);
__pyx_t_2 = 0;
/* "uvloop/loop.pyx":1650
* Server server = Server(self)
*
* if ssl is not None and not isinstance(ssl, ssl_SSLContext): # <<<<<<<<<<<<<<
* raise TypeError('ssl argument must be an SSLContext or None')
*
*/
__pyx_t_4 = (__pyx_cur_scope->__pyx_v_ssl != Py_None);
__pyx_t_5 = (__pyx_t_4 != 0);
if (__pyx_t_5) {
} else {
__pyx_t_3 = __pyx_t_5;
goto __pyx_L5_bool_binop_done;
}
__pyx_t_2 = __pyx_v_6uvloop_4loop_ssl_SSLContext;
__Pyx_INCREF(__pyx_t_2);
__pyx_t_5 = PyObject_IsInstance(__pyx_cur_scope->__pyx_v_ssl, __pyx_t_2); if (unlikely(__pyx_t_5 == -1)) __PYX_ERR(1, 1650, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_4 = ((!(__pyx_t_5 != 0)) != 0);
__pyx_t_3 = __pyx_t_4;
__pyx_L5_bool_binop_done:;
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1651
*
* if ssl is not None and not isinstance(ssl, ssl_SSLContext):
* raise TypeError('ssl argument must be an SSLContext or None') # <<<<<<<<<<<<<<
*
* if path is not None:
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__66, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1651, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__PYX_ERR(1, 1651, __pyx_L1_error)
/* "uvloop/loop.pyx":1650
* Server server = Server(self)
*
* if ssl is not None and not isinstance(ssl, ssl_SSLContext): # <<<<<<<<<<<<<<
* raise TypeError('ssl argument must be an SSLContext or None')
*
*/
}
/* "uvloop/loop.pyx":1653
* raise TypeError('ssl argument must be an SSLContext or None')
*
* if path is not None: # <<<<<<<<<<<<<<
* if sock is not None:
* raise ValueError(
*/
__pyx_t_3 = (__pyx_cur_scope->__pyx_v_path != ((PyObject*)Py_None));
__pyx_t_4 = (__pyx_t_3 != 0);
if (__pyx_t_4) {
/* "uvloop/loop.pyx":1654
*
* if path is not None:
* if sock is not None: # <<<<<<<<<<<<<<
* raise ValueError(
* 'path and sock can not be specified at the same time')
*/
__pyx_t_4 = (__pyx_cur_scope->__pyx_v_sock != Py_None);
__pyx_t_3 = (__pyx_t_4 != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1655
* if path is not None:
* if sock is not None:
* raise ValueError( # <<<<<<<<<<<<<<
* 'path and sock can not be specified at the same time')
*
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__67, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1655, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__PYX_ERR(1, 1655, __pyx_L1_error)
/* "uvloop/loop.pyx":1654
*
* if path is not None:
* if sock is not None: # <<<<<<<<<<<<<<
* raise ValueError(
* 'path and sock can not be specified at the same time')
*/
}
/* "uvloop/loop.pyx":1662
* # they were bound to. This is different from asyncio, which
* # doesn't cleanup the socket path.
* sock = socket_socket(uv.AF_UNIX) # <<<<<<<<<<<<<<
*
* try:
*/
__pyx_t_1 = __Pyx_PyInt_From_int(AF_UNIX); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1662, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_v_6uvloop_4loop_socket_socket);
__pyx_t_6 = __pyx_v_6uvloop_4loop_socket_socket; __pyx_t_7 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) {
__pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
if (likely(__pyx_t_7)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
__Pyx_INCREF(__pyx_t_7);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_6, function);
}
}
if (!__pyx_t_7) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1662, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_6)) {
PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_1};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1662, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_1};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1662, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else
#endif
{
__pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1662, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL;
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_1);
__pyx_t_1 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1662, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
}
}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_sock);
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_sock, __pyx_t_2);
__Pyx_GIVEREF(__pyx_t_2);
__pyx_t_2 = 0;
/* "uvloop/loop.pyx":1664
* sock = socket_socket(uv.AF_UNIX)
*
* try: # <<<<<<<<<<<<<<
* sock.bind(path)
* except OSError as exc:
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11);
__Pyx_XGOTREF(__pyx_t_9);
__Pyx_XGOTREF(__pyx_t_10);
__Pyx_XGOTREF(__pyx_t_11);
/*try:*/ {
/* "uvloop/loop.pyx":1665
*
* try:
* sock.bind(path) # <<<<<<<<<<<<<<
* except OSError as exc:
* sock.close()
*/
__pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_bind); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1665, __pyx_L9_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_8 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
__pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6);
if (likely(__pyx_t_8)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
__Pyx_INCREF(__pyx_t_8);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_6, function);
}
}
if (!__pyx_t_8) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_cur_scope->__pyx_v_path); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1665, __pyx_L9_error)
__Pyx_GOTREF(__pyx_t_2);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_6)) {
PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_cur_scope->__pyx_v_path};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1665, __pyx_L9_error)
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) {
PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_cur_scope->__pyx_v_path};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1665, __pyx_L9_error)
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else
#endif
{
__pyx_t_1 = PyTuple_New(1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1665, __pyx_L9_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_8); __pyx_t_8 = NULL;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_path);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_path);
PyTuple_SET_ITEM(__pyx_t_1, 0+1, __pyx_cur_scope->__pyx_v_path);
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1665, __pyx_L9_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
}
}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":1664
* sock = socket_socket(uv.AF_UNIX)
*
* try: # <<<<<<<<<<<<<<
* sock.bind(path)
* except OSError as exc:
*/
}
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
goto __pyx_L16_try_end;
__pyx_L9_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":1666
* try:
* sock.bind(path)
* except OSError as exc: # <<<<<<<<<<<<<<
* sock.close()
* if exc.errno == errno.EADDRINUSE:
*/
__pyx_t_12 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_OSError);
if (__pyx_t_12) {
__Pyx_AddTraceback("uvloop.loop.Loop.create_unix_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_6, &__pyx_t_1) < 0) __PYX_ERR(1, 1666, __pyx_L11_except_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_t_1);
__Pyx_INCREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_6);
__pyx_cur_scope->__pyx_v_exc = __pyx_t_6;
/*try:*/ {
/* "uvloop/loop.pyx":1667
* sock.bind(path)
* except OSError as exc:
* sock.close() # <<<<<<<<<<<<<<
* if exc.errno == errno.EADDRINUSE:
* # Let's improve the error message by adding
*/
__pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_close); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1667, __pyx_L22_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_13 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
__pyx_t_13 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_13)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_13);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_7, function);
}
}
if (__pyx_t_13) {
__pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_13); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1667, __pyx_L22_error)
__Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
} else {
__pyx_t_8 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1667, __pyx_L22_error)
}
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
/* "uvloop/loop.pyx":1668
* except OSError as exc:
* sock.close()
* if exc.errno == errno.EADDRINUSE: # <<<<<<<<<<<<<<
* # Let's improve the error message by adding
* # with what exact address it occurs.
*/
__pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_exc, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1668, __pyx_L22_error)
__Pyx_GOTREF(__pyx_t_8);
__pyx_t_7 = __Pyx_PyInt_From_int(EADDRINUSE); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1668, __pyx_L22_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_13 = PyObject_RichCompare(__pyx_t_8, __pyx_t_7, Py_EQ); __Pyx_XGOTREF(__pyx_t_13); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 1668, __pyx_L22_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_13); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(1, 1668, __pyx_L22_error)
__Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1671
* # Let's improve the error message by adding
* # with what exact address it occurs.
* msg = 'Address {!r} is already in use'.format(path) # <<<<<<<<<<<<<<
* raise OSError(errno.EADDRINUSE, msg) from None
* else:
*/
__pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Address_r_is_already_in_use, __pyx_n_s_format); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1671, __pyx_L22_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_8 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
__pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_8)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_8);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_7, function);
}
}
if (!__pyx_t_8) {
__pyx_t_13 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_cur_scope->__pyx_v_path); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 1671, __pyx_L22_error)
__Pyx_GOTREF(__pyx_t_13);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_7)) {
PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_cur_scope->__pyx_v_path};
__pyx_t_13 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 1671, __pyx_L22_error)
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_GOTREF(__pyx_t_13);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_cur_scope->__pyx_v_path};
__pyx_t_13 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 1671, __pyx_L22_error)
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_GOTREF(__pyx_t_13);
} else
#endif
{
__pyx_t_14 = PyTuple_New(1+1); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 1671, __pyx_L22_error)
__Pyx_GOTREF(__pyx_t_14);
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_8); __pyx_t_8 = NULL;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_path);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_path);
PyTuple_SET_ITEM(__pyx_t_14, 0+1, __pyx_cur_scope->__pyx_v_path);
__pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_14, NULL); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 1671, __pyx_L22_error)
__Pyx_GOTREF(__pyx_t_13);
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
}
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GIVEREF(__pyx_t_13);
__pyx_cur_scope->__pyx_v_msg = __pyx_t_13;
__pyx_t_13 = 0;
/* "uvloop/loop.pyx":1672
* # with what exact address it occurs.
* msg = 'Address {!r} is already in use'.format(path)
* raise OSError(errno.EADDRINUSE, msg) from None # <<<<<<<<<<<<<<
* else:
* raise
*/
__pyx_t_13 = __Pyx_PyInt_From_int(EADDRINUSE); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 1672, __pyx_L22_error)
__Pyx_GOTREF(__pyx_t_13);
__pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1672, __pyx_L22_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_13);
PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_13);
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_msg);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_msg);
PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_cur_scope->__pyx_v_msg);
__pyx_t_13 = 0;
__pyx_t_13 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 1672, __pyx_L22_error)
__Pyx_GOTREF(__pyx_t_13);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_Raise(__pyx_t_13, 0, 0, Py_None);
__Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
__PYX_ERR(1, 1672, __pyx_L22_error)
/* "uvloop/loop.pyx":1668
* except OSError as exc:
* sock.close()
* if exc.errno == errno.EADDRINUSE: # <<<<<<<<<<<<<<
* # Let's improve the error message by adding
* # with what exact address it occurs.
*/
}
/* "uvloop/loop.pyx":1674
* raise OSError(errno.EADDRINUSE, msg) from None
* else:
* raise # <<<<<<<<<<<<<<
* except:
* sock.close()
*/
/*else*/ {
__Pyx_GIVEREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_6);
__Pyx_XGIVEREF(__pyx_t_1);
__Pyx_ErrRestoreWithState(__pyx_t_2, __pyx_t_6, __pyx_t_1);
__pyx_t_2 = 0; __pyx_t_6 = 0; __pyx_t_1 = 0;
__PYX_ERR(1, 1674, __pyx_L22_error)
}
}
/* "uvloop/loop.pyx":1666
* try:
* sock.bind(path)
* except OSError as exc: # <<<<<<<<<<<<<<
* sock.close()
* if exc.errno == errno.EADDRINUSE:
*/
/*finally:*/ {
/*exception exit:*/{
__Pyx_PyThreadState_declare
__pyx_L22_error:;
__pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22);
if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19) < 0)) __Pyx_ErrFetch(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19);
__Pyx_XGOTREF(__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_18);
__Pyx_XGOTREF(__pyx_t_19);
__Pyx_XGOTREF(__pyx_t_20);
__Pyx_XGOTREF(__pyx_t_21);
__Pyx_XGOTREF(__pyx_t_22);
__pyx_t_12 = __pyx_lineno; __pyx_t_15 = __pyx_clineno; __pyx_t_16 = __pyx_filename;
{
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_exc);
__Pyx_DECREF(__pyx_cur_scope->__pyx_v_exc);
__pyx_cur_scope->__pyx_v_exc = NULL;
}
__Pyx_PyThreadState_assign
if (PY_MAJOR_VERSION >= 3) {
__Pyx_XGIVEREF(__pyx_t_20);
__Pyx_XGIVEREF(__pyx_t_21);
__Pyx_XGIVEREF(__pyx_t_22);
__Pyx_ExceptionReset(__pyx_t_20, __pyx_t_21, __pyx_t_22);
}
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_XGIVEREF(__pyx_t_19);
__Pyx_ErrRestore(__pyx_t_17, __pyx_t_18, __pyx_t_19);
__pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0;
__pyx_lineno = __pyx_t_12; __pyx_clineno = __pyx_t_15; __pyx_filename = __pyx_t_16;
goto __pyx_L11_except_error;
}
}
}
/* "uvloop/loop.pyx":1675
* else:
* raise
* except: # <<<<<<<<<<<<<<
* sock.close()
* raise
*/
/*except:*/ {
__Pyx_AddTraceback("uvloop.loop.Loop.create_unix_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_6, &__pyx_t_2) < 0) __PYX_ERR(1, 1675, __pyx_L11_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_t_2);
/* "uvloop/loop.pyx":1676
* raise
* except:
* sock.close() # <<<<<<<<<<<<<<
* raise
*
*/
__pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_close); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1676, __pyx_L11_except_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_14 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
__pyx_t_14 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_14)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_14);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_7, function);
}
}
if (__pyx_t_14) {
__pyx_t_13 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_14); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 1676, __pyx_L11_except_error)
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
} else {
__pyx_t_13 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 1676, __pyx_L11_except_error)
}
__Pyx_GOTREF(__pyx_t_13);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
/* "uvloop/loop.pyx":1677
* except:
* sock.close()
* raise # <<<<<<<<<<<<<<
*
* else:
*/
__Pyx_GIVEREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_6);
__Pyx_XGIVEREF(__pyx_t_2);
__Pyx_ErrRestoreWithState(__pyx_t_1, __pyx_t_6, __pyx_t_2);
__pyx_t_1 = 0; __pyx_t_6 = 0; __pyx_t_2 = 0;
__PYX_ERR(1, 1677, __pyx_L11_except_error)
}
__pyx_L11_except_error:;
/* "uvloop/loop.pyx":1664
* sock = socket_socket(uv.AF_UNIX)
*
* try: # <<<<<<<<<<<<<<
* sock.bind(path)
* except OSError as exc:
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_XGIVEREF(__pyx_t_10);
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11);
goto __pyx_L1_error;
__pyx_L16_try_end:;
}
/* "uvloop/loop.pyx":1653
* raise TypeError('ssl argument must be an SSLContext or None')
*
* if path is not None: # <<<<<<<<<<<<<<
* if sock is not None:
* raise ValueError(
*/
goto __pyx_L7;
}
/* "uvloop/loop.pyx":1680
*
* else:
* if sock is None: # <<<<<<<<<<<<<<
* raise ValueError(
* 'path was not specified, and no sock specified')
*/
/*else*/ {
__pyx_t_3 = (__pyx_cur_scope->__pyx_v_sock == Py_None);
__pyx_t_4 = (__pyx_t_3 != 0);
if (__pyx_t_4) {
/* "uvloop/loop.pyx":1681
* else:
* if sock is None:
* raise ValueError( # <<<<<<<<<<<<<<
* 'path was not specified, and no sock specified')
*
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__68, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1681, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__PYX_ERR(1, 1681, __pyx_L1_error)
/* "uvloop/loop.pyx":1680
*
* else:
* if sock is None: # <<<<<<<<<<<<<<
* raise ValueError(
* 'path was not specified, and no sock specified')
*/
}
/* "uvloop/loop.pyx":1684
* 'path was not specified, and no sock specified')
*
* if sock.family != uv.AF_UNIX or not _is_sock_stream(sock.type): # <<<<<<<<<<<<<<
* raise ValueError(
* 'A UNIX Domain Stream Socket was expected, got {!r}'
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_family); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1684, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_6 = __Pyx_PyInt_From_int(AF_UNIX); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1684, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_1 = PyObject_RichCompare(__pyx_t_2, __pyx_t_6, Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1684, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(1, 1684, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (!__pyx_t_3) {
} else {
__pyx_t_4 = __pyx_t_3;
goto __pyx_L33_bool_binop_done;
}
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1684, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_6 = __pyx_f_6uvloop_4loop__is_sock_stream(__pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1684, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(1, 1684, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__pyx_t_5 = ((!__pyx_t_3) != 0);
__pyx_t_4 = __pyx_t_5;
__pyx_L33_bool_binop_done:;
if (__pyx_t_4) {
/* "uvloop/loop.pyx":1687
* raise ValueError(
* 'A UNIX Domain Stream Socket was expected, got {!r}'
* .format(sock)) # <<<<<<<<<<<<<<
*
* pipe = UnixServer.new(self, protocol_factory, server, ssl)
*/
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_A_UNIX_Domain_Stream_Socket_was, __pyx_n_s_format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1687, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
__pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1);
if (likely(__pyx_t_2)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
__Pyx_INCREF(__pyx_t_2);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_1, function);
}
}
if (!__pyx_t_2) {
__pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_cur_scope->__pyx_v_sock); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1687, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_1)) {
PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_cur_scope->__pyx_v_sock};
__pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1687, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_GOTREF(__pyx_t_6);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_cur_scope->__pyx_v_sock};
__pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1687, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_GOTREF(__pyx_t_6);
} else
#endif
{
__pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 1687, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_13);
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_2); __pyx_t_2 = NULL;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_cur_scope->__pyx_v_sock);
__pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_13, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1687, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
}
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1685
*
* if sock.family != uv.AF_UNIX or not _is_sock_stream(sock.type):
* raise ValueError( # <<<<<<<<<<<<<<
* 'A UNIX Domain Stream Socket was expected, got {!r}'
* .format(sock))
*/
__pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1685, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_6);
__pyx_t_6 = 0;
__pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1685, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_Raise(__pyx_t_6, 0, 0, 0);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__PYX_ERR(1, 1685, __pyx_L1_error)
/* "uvloop/loop.pyx":1684
* 'path was not specified, and no sock specified')
*
* if sock.family != uv.AF_UNIX or not _is_sock_stream(sock.type): # <<<<<<<<<<<<<<
* raise ValueError(
* 'A UNIX Domain Stream Socket was expected, got {!r}'
*/
}
}
__pyx_L7:;
/* "uvloop/loop.pyx":1689
* .format(sock))
*
* pipe = UnixServer.new(self, protocol_factory, server, ssl) # <<<<<<<<<<<<<<
*
* try:
*/
__pyx_t_6 = ((PyObject *)__pyx_f_6uvloop_4loop_10UnixServer_new(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_protocol_factory, __pyx_cur_scope->__pyx_v_server, __pyx_cur_scope->__pyx_v_ssl)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1689, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_6);
__pyx_cur_scope->__pyx_v_pipe = ((struct __pyx_obj_6uvloop_4loop_UnixServer *)__pyx_t_6);
__pyx_t_6 = 0;
/* "uvloop/loop.pyx":1691
* pipe = UnixServer.new(self, protocol_factory, server, ssl)
*
* try: # <<<<<<<<<<<<<<
* # See a comment on os_dup in create_connection
* fileno = os_dup(sock.fileno())
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_10, &__pyx_t_9);
__Pyx_XGOTREF(__pyx_t_11);
__Pyx_XGOTREF(__pyx_t_10);
__Pyx_XGOTREF(__pyx_t_9);
/*try:*/ {
/* "uvloop/loop.pyx":1693
* try:
* # See a comment on os_dup in create_connection
* fileno = os_dup(sock.fileno()) # <<<<<<<<<<<<<<
*
* pipe._open(fileno)
*/
__pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_fileno); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 1693, __pyx_L35_error)
__Pyx_GOTREF(__pyx_t_13);
__pyx_t_2 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_13))) {
__pyx_t_2 = PyMethod_GET_SELF(__pyx_t_13);
if (likely(__pyx_t_2)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13);
__Pyx_INCREF(__pyx_t_2);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_13, function);
}
}
if (__pyx_t_2) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1693, __pyx_L35_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_13); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1693, __pyx_L35_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
__Pyx_INCREF(__pyx_v_6uvloop_4loop_os_dup);
__pyx_t_13 = __pyx_v_6uvloop_4loop_os_dup; __pyx_t_2 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_13))) {
__pyx_t_2 = PyMethod_GET_SELF(__pyx_t_13);
if (likely(__pyx_t_2)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_13);
__Pyx_INCREF(__pyx_t_2);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_13, function);
}
}
if (!__pyx_t_2) {
__pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_13, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1693, __pyx_L35_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_GOTREF(__pyx_t_6);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_13)) {
PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_1};
__pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_13, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1693, __pyx_L35_error)
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_13)) {
PyObject *__pyx_temp[2] = {__pyx_t_2, __pyx_t_1};
__pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_13, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1693, __pyx_L35_error)
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else
#endif
{
__pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1693, __pyx_L35_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_2); __pyx_t_2 = NULL;
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_1);
__pyx_t_1 = 0;
__pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_13, __pyx_t_7, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1693, __pyx_L35_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
}
__Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
__Pyx_GIVEREF(__pyx_t_6);
__pyx_cur_scope->__pyx_v_fileno = __pyx_t_6;
__pyx_t_6 = 0;
/* "uvloop/loop.pyx":1695
* fileno = os_dup(sock.fileno())
*
* pipe._open(fileno) # <<<<<<<<<<<<<<
* except:
* pipe._close()
*/
__pyx_t_15 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_fileno); if (unlikely((__pyx_t_15 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1695, __pyx_L35_error)
__pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixServer *)__pyx_cur_scope->__pyx_v_pipe->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._open(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_pipe), __pyx_t_15); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1695, __pyx_L35_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "uvloop/loop.pyx":1691
* pipe = UnixServer.new(self, protocol_factory, server, ssl)
*
* try: # <<<<<<<<<<<<<<
* # See a comment on os_dup in create_connection
* fileno = os_dup(sock.fileno())
*/
}
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
goto __pyx_L42_try_end;
__pyx_L35_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "uvloop/loop.pyx":1696
*
* pipe._open(fileno)
* except: # <<<<<<<<<<<<<<
* pipe._close()
* sock.close()
*/
/*except:*/ {
__Pyx_AddTraceback("uvloop.loop.Loop.create_unix_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_13, &__pyx_t_7) < 0) __PYX_ERR(1, 1696, __pyx_L37_except_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_t_13);
__Pyx_GOTREF(__pyx_t_7);
/* "uvloop/loop.pyx":1697
* pipe._open(fileno)
* except:
* pipe._close() # <<<<<<<<<<<<<<
* sock.close()
* raise
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixServer *)__pyx_cur_scope->__pyx_v_pipe->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_cur_scope->__pyx_v_pipe)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1697, __pyx_L37_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1698
* except:
* pipe._close()
* sock.close() # <<<<<<<<<<<<<<
* raise
*
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_close); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1698, __pyx_L37_except_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_14 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_14 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_14)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_14);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (__pyx_t_14) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_14); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1698, __pyx_L37_except_error)
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1698, __pyx_L37_except_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1699
* pipe._close()
* sock.close()
* raise # <<<<<<<<<<<<<<
*
* pipe._attach_fileobj(sock)
*/
__Pyx_GIVEREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_13);
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_ErrRestoreWithState(__pyx_t_6, __pyx_t_13, __pyx_t_7);
__pyx_t_6 = 0; __pyx_t_13 = 0; __pyx_t_7 = 0;
__PYX_ERR(1, 1699, __pyx_L37_except_error)
}
__pyx_L37_except_error:;
/* "uvloop/loop.pyx":1691
* pipe = UnixServer.new(self, protocol_factory, server, ssl)
*
* try: # <<<<<<<<<<<<<<
* # See a comment on os_dup in create_connection
* fileno = os_dup(sock.fileno())
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_XGIVEREF(__pyx_t_10);
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_ExceptionReset(__pyx_t_11, __pyx_t_10, __pyx_t_9);
goto __pyx_L1_error;
__pyx_L42_try_end:;
}
/* "uvloop/loop.pyx":1701
* raise
*
* pipe._attach_fileobj(sock) # <<<<<<<<<<<<<<
*
* try:
*/
__pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixServer *)__pyx_cur_scope->__pyx_v_pipe->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._attach_fileobj(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_pipe), __pyx_cur_scope->__pyx_v_sock); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1701, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "uvloop/loop.pyx":1703
* pipe._attach_fileobj(sock)
*
* try: # <<<<<<<<<<<<<<
* pipe.listen(backlog)
* except:
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11);
__Pyx_XGOTREF(__pyx_t_9);
__Pyx_XGOTREF(__pyx_t_10);
__Pyx_XGOTREF(__pyx_t_11);
/*try:*/ {
/* "uvloop/loop.pyx":1704
*
* try:
* pipe.listen(backlog) # <<<<<<<<<<<<<<
* except:
* pipe._close()
*/
__pyx_t_7 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixServer *)__pyx_cur_scope->__pyx_v_pipe->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.listen(((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)__pyx_cur_scope->__pyx_v_pipe), __pyx_cur_scope->__pyx_v_backlog); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1704, __pyx_L45_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "uvloop/loop.pyx":1703
* pipe._attach_fileobj(sock)
*
* try: # <<<<<<<<<<<<<<
* pipe.listen(backlog)
* except:
*/
}
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
goto __pyx_L52_try_end;
__pyx_L45_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
/* "uvloop/loop.pyx":1705
* try:
* pipe.listen(backlog)
* except: # <<<<<<<<<<<<<<
* pipe._close()
* raise
*/
/*except:*/ {
__Pyx_AddTraceback("uvloop.loop.Loop.create_unix_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_13, &__pyx_t_6) < 0) __PYX_ERR(1, 1705, __pyx_L47_except_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GOTREF(__pyx_t_13);
__Pyx_GOTREF(__pyx_t_6);
/* "uvloop/loop.pyx":1706
* pipe.listen(backlog)
* except:
* pipe._close() # <<<<<<<<<<<<<<
* raise
*
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixServer *)__pyx_cur_scope->__pyx_v_pipe->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_cur_scope->__pyx_v_pipe)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1706, __pyx_L47_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1707
* except:
* pipe._close()
* raise # <<<<<<<<<<<<<<
*
* server._add_server(pipe)
*/
__Pyx_GIVEREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_13);
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_ErrRestoreWithState(__pyx_t_7, __pyx_t_13, __pyx_t_6);
__pyx_t_7 = 0; __pyx_t_13 = 0; __pyx_t_6 = 0;
__PYX_ERR(1, 1707, __pyx_L47_except_error)
}
__pyx_L47_except_error:;
/* "uvloop/loop.pyx":1703
* pipe._attach_fileobj(sock)
*
* try: # <<<<<<<<<<<<<<
* pipe.listen(backlog)
* except:
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_XGIVEREF(__pyx_t_10);
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11);
goto __pyx_L1_error;
__pyx_L52_try_end:;
}
/* "uvloop/loop.pyx":1709
* raise
*
* server._add_server(pipe) # <<<<<<<<<<<<<<
* return server
*
*/
__pyx_t_6 = ((struct __pyx_vtabstruct_6uvloop_4loop_Server *)__pyx_cur_scope->__pyx_v_server->__pyx_vtab)->_add_server(__pyx_cur_scope->__pyx_v_server, ((struct __pyx_obj_6uvloop_4loop_UVStreamServer *)__pyx_cur_scope->__pyx_v_pipe)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1709, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "uvloop/loop.pyx":1710
*
* server._add_server(pipe)
* return server # <<<<<<<<<<<<<<
*
* async def create_unix_connection(self, protocol_factory, path, *,
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = NULL; __Pyx_ReturnWithStopIteration(((PyObject *)__pyx_cur_scope->__pyx_v_server));
goto __pyx_L0;
CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
/* "uvloop/loop.pyx":1627
* return tr, protocol
*
* async def create_unix_server(self, protocol_factory, str path=None, # <<<<<<<<<<<<<<
* *, backlog=100, sock=None, ssl=None):
* """A coroutine which creates a UNIX Domain Socket server.
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_XDECREF(__pyx_t_13);
__Pyx_XDECREF(__pyx_t_14);
__Pyx_AddTraceback("create_unix_server", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_L0:;
__Pyx_XDECREF(__pyx_r); __pyx_r = 0;
__pyx_generator->resume_label = -1;
__Pyx_Coroutine_clear((PyObject*)__pyx_generator);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_62generator4(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */
/* "uvloop/loop.pyx":1712
* return server
*
* async def create_unix_connection(self, protocol_factory, path, *, # <<<<<<<<<<<<<<
* ssl=None, sock=None,
* server_hostname=None):
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_61create_unix_connection(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_60create_unix_connection[] = "Loop.create_unix_connection(self, protocol_factory, path, *, ssl=None, sock=None, server_hostname=None)";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_61create_unix_connection(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_protocol_factory = 0;
PyObject *__pyx_v_path = 0;
PyObject *__pyx_v_ssl = 0;
PyObject *__pyx_v_sock = 0;
PyObject *__pyx_v_server_hostname = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("create_unix_connection (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_protocol_factory,&__pyx_n_s_path,&__pyx_n_s_ssl,&__pyx_n_s_sock,&__pyx_n_s_server_hostname,0};
PyObject* values[5] = {0,0,0,0,0};
/* "uvloop/loop.pyx":1713
*
* async def create_unix_connection(self, protocol_factory, path, *,
* ssl=None, sock=None, # <<<<<<<<<<<<<<
* server_hostname=None):
*
*/
values[2] = ((PyObject *)Py_None);
values[3] = ((PyObject *)Py_None);
/* "uvloop/loop.pyx":1714
* async def create_unix_connection(self, protocol_factory, path, *,
* ssl=None, sock=None,
* server_hostname=None): # <<<<<<<<<<<<<<
*
* cdef:
*/
values[4] = ((PyObject *)Py_None);
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_protocol_factory)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_path)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("create_unix_connection", 1, 2, 2, 1); __PYX_ERR(1, 1712, __pyx_L3_error)
}
}
if (kw_args > 0 && likely(kw_args <= 3)) {
Py_ssize_t index;
for (index = 2; index < 5 && kw_args > 0; index++) {
PyObject* value = PyDict_GetItem(__pyx_kwds, *__pyx_pyargnames[index]);
if (value) { values[index] = value; kw_args--; }
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create_unix_connection") < 0)) __PYX_ERR(1, 1712, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
}
__pyx_v_protocol_factory = values[0];
__pyx_v_path = values[1];
__pyx_v_ssl = values[2];
__pyx_v_sock = values[3];
__pyx_v_server_hostname = values[4];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("create_unix_connection", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1712, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.create_unix_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_60create_unix_connection(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_protocol_factory, __pyx_v_path, __pyx_v_ssl, __pyx_v_sock, __pyx_v_server_hostname);
/* "uvloop/loop.pyx":1712
* return server
*
* async def create_unix_connection(self, protocol_factory, path, *, # <<<<<<<<<<<<<<
* ssl=None, sock=None,
* server_hostname=None):
*/
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_60create_unix_connection(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_path, PyObject *__pyx_v_ssl, PyObject *__pyx_v_sock, PyObject *__pyx_v_server_hostname) {
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_10_create_unix_connection *__pyx_cur_scope;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("create_unix_connection", 0);
__pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_10_create_unix_connection *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_10_create_unix_connection(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_10_create_unix_connection, __pyx_empty_tuple, NULL);
if (unlikely(!__pyx_cur_scope)) {
__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_10_create_unix_connection *)Py_None);
__Pyx_INCREF(Py_None);
__PYX_ERR(1, 1712, __pyx_L1_error)
} else {
__Pyx_GOTREF(__pyx_cur_scope);
}
__pyx_cur_scope->__pyx_v_self = __pyx_v_self;
__Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__pyx_cur_scope->__pyx_v_protocol_factory = __pyx_v_protocol_factory;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol_factory);
__pyx_cur_scope->__pyx_v_path = __pyx_v_path;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_path);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_path);
__pyx_cur_scope->__pyx_v_ssl = __pyx_v_ssl;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl);
__pyx_cur_scope->__pyx_v_sock = __pyx_v_sock;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
__pyx_cur_scope->__pyx_v_server_hostname = __pyx_v_server_hostname;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_server_hostname);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_server_hostname);
{
__pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_62generator4, (PyObject *) __pyx_cur_scope, __pyx_n_s_create_unix_connection, __pyx_n_s_Loop_create_unix_connection, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(1, 1712, __pyx_L1_error)
__Pyx_DECREF(__pyx_cur_scope);
__Pyx_RefNannyFinishContext();
return (PyObject *) gen;
}
/* function exit code */
__pyx_L1_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.create_unix_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__Pyx_DECREF(((PyObject *)__pyx_cur_scope));
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_62generator4(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */
{
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_10_create_unix_connection *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_10_create_unix_connection *)__pyx_generator->closure);
PyObject *__pyx_r = NULL;
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
int __pyx_t_4;
int __pyx_t_5;
int __pyx_t_6;
PyObject *__pyx_t_7 = NULL;
char *__pyx_t_8;
PyObject *__pyx_t_9 = NULL;
PyObject *__pyx_t_10 = NULL;
PyObject *__pyx_t_11 = NULL;
int __pyx_t_12;
PyObject *__pyx_t_13 = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("None", 0);
switch (__pyx_generator->resume_label) {
case 0: goto __pyx_L3_first_run;
case 1: goto __pyx_L18_resume_from_yield;
case 2: goto __pyx_L33_resume_from_yield;
case 3: goto __pyx_L37_resume_from_yield;
default: /* CPython raises the right error here */
__Pyx_RefNannyFinishContext();
return NULL;
}
__pyx_L3_first_run:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 1712, __pyx_L1_error)
/* "uvloop/loop.pyx":1722
* object ssl_waiter
*
* app_protocol = protocol = protocol_factory() # <<<<<<<<<<<<<<
* ssl_waiter = None
* if ssl:
*/
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
__pyx_t_2 = __pyx_cur_scope->__pyx_v_protocol_factory; __pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (__pyx_t_3) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1722, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1722, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
__pyx_cur_scope->__pyx_v_app_protocol = __pyx_t_1;
__Pyx_INCREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
__pyx_cur_scope->__pyx_v_protocol = __pyx_t_1;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1723
*
* app_protocol = protocol = protocol_factory()
* ssl_waiter = None # <<<<<<<<<<<<<<
* if ssl:
* if server_hostname is None:
*/
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__pyx_cur_scope->__pyx_v_ssl_waiter = Py_None;
/* "uvloop/loop.pyx":1724
* app_protocol = protocol = protocol_factory()
* ssl_waiter = None
* if ssl: # <<<<<<<<<<<<<<
* if server_hostname is None:
* raise ValueError('You must set server_hostname '
*/
__pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_ssl); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 1724, __pyx_L1_error)
if (__pyx_t_4) {
/* "uvloop/loop.pyx":1725
* ssl_waiter = None
* if ssl:
* if server_hostname is None: # <<<<<<<<<<<<<<
* raise ValueError('You must set server_hostname '
* 'when using ssl without a host')
*/
__pyx_t_4 = (__pyx_cur_scope->__pyx_v_server_hostname == Py_None);
__pyx_t_5 = (__pyx_t_4 != 0);
if (__pyx_t_5) {
/* "uvloop/loop.pyx":1726
* if ssl:
* if server_hostname is None:
* raise ValueError('You must set server_hostname ' # <<<<<<<<<<<<<<
* 'when using ssl without a host')
*
*/
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__69, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1726, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__PYX_ERR(1, 1726, __pyx_L1_error)
/* "uvloop/loop.pyx":1725
* ssl_waiter = None
* if ssl:
* if server_hostname is None: # <<<<<<<<<<<<<<
* raise ValueError('You must set server_hostname '
* 'when using ssl without a host')
*/
}
/* "uvloop/loop.pyx":1729
* 'when using ssl without a host')
*
* ssl_waiter = self._new_future() # <<<<<<<<<<<<<<
* sslcontext = None if isinstance(ssl, bool) else ssl
* protocol = aio_SSLProtocol(
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1729, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_ssl_waiter);
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_ssl_waiter, __pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":1730
*
* ssl_waiter = self._new_future()
* sslcontext = None if isinstance(ssl, bool) else ssl # <<<<<<<<<<<<<<
* protocol = aio_SSLProtocol(
* self, app_protocol, sslcontext, ssl_waiter,
*/
__pyx_t_2 = ((PyObject*)&PyBool_Type);
__Pyx_INCREF(__pyx_t_2);
__pyx_t_5 = PyObject_IsInstance(__pyx_cur_scope->__pyx_v_ssl, __pyx_t_2); if (unlikely(__pyx_t_5 == -1)) __PYX_ERR(1, 1730, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
if ((__pyx_t_5 != 0)) {
__Pyx_INCREF(Py_None);
__pyx_t_1 = Py_None;
} else {
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl);
__pyx_t_1 = __pyx_cur_scope->__pyx_v_ssl;
}
__Pyx_GIVEREF(__pyx_t_1);
__pyx_cur_scope->__pyx_v_sslcontext = __pyx_t_1;
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":1733
* protocol = aio_SSLProtocol(
* self, app_protocol, sslcontext, ssl_waiter,
* False, server_hostname) # <<<<<<<<<<<<<<
* else:
* if server_hostname is not None:
*/
__Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_SSLProtocol);
__pyx_t_2 = __pyx_v_6uvloop_4loop_aio_SSLProtocol; __pyx_t_3 = NULL;
__pyx_t_6 = 0;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
__pyx_t_6 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[7] = {__pyx_t_3, ((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_cur_scope->__pyx_v_app_protocol, __pyx_cur_scope->__pyx_v_sslcontext, __pyx_cur_scope->__pyx_v_ssl_waiter, Py_False, __pyx_cur_scope->__pyx_v_server_hostname};
__pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 6+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1731, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[7] = {__pyx_t_3, ((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_cur_scope->__pyx_v_app_protocol, __pyx_cur_scope->__pyx_v_sslcontext, __pyx_cur_scope->__pyx_v_ssl_waiter, Py_False, __pyx_cur_scope->__pyx_v_server_hostname};
__pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 6+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1731, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else
#endif
{
__pyx_t_7 = PyTuple_New(6+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1731, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
if (__pyx_t_3) {
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3); __pyx_t_3 = NULL;
}
__Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, ((PyObject *)__pyx_cur_scope->__pyx_v_self));
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_app_protocol);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_app_protocol);
PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_cur_scope->__pyx_v_app_protocol);
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_sslcontext);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sslcontext);
PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_6, __pyx_cur_scope->__pyx_v_sslcontext);
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl_waiter);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl_waiter);
PyTuple_SET_ITEM(__pyx_t_7, 3+__pyx_t_6, __pyx_cur_scope->__pyx_v_ssl_waiter);
__Pyx_INCREF(Py_False);
__Pyx_GIVEREF(Py_False);
PyTuple_SET_ITEM(__pyx_t_7, 4+__pyx_t_6, Py_False);
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_server_hostname);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_server_hostname);
PyTuple_SET_ITEM(__pyx_t_7, 5+__pyx_t_6, __pyx_cur_scope->__pyx_v_server_hostname);
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1731, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_protocol);
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_protocol, __pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":1724
* app_protocol = protocol = protocol_factory()
* ssl_waiter = None
* if ssl: # <<<<<<<<<<<<<<
* if server_hostname is None:
* raise ValueError('You must set server_hostname '
*/
goto __pyx_L4;
}
/* "uvloop/loop.pyx":1735
* False, server_hostname)
* else:
* if server_hostname is not None: # <<<<<<<<<<<<<<
* raise ValueError('server_hostname is only meaningful with ssl')
*
*/
/*else*/ {
__pyx_t_5 = (__pyx_cur_scope->__pyx_v_server_hostname != Py_None);
__pyx_t_4 = (__pyx_t_5 != 0);
if (__pyx_t_4) {
/* "uvloop/loop.pyx":1736
* else:
* if server_hostname is not None:
* raise ValueError('server_hostname is only meaningful with ssl') # <<<<<<<<<<<<<<
*
* if path is not None:
*/
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__70, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1736, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__PYX_ERR(1, 1736, __pyx_L1_error)
/* "uvloop/loop.pyx":1735
* False, server_hostname)
* else:
* if server_hostname is not None: # <<<<<<<<<<<<<<
* raise ValueError('server_hostname is only meaningful with ssl')
*
*/
}
}
__pyx_L4:;
/* "uvloop/loop.pyx":1738
* raise ValueError('server_hostname is only meaningful with ssl')
*
* if path is not None: # <<<<<<<<<<<<<<
* if isinstance(path, str):
* path = PyUnicode_EncodeFSDefault(path)
*/
__pyx_t_4 = (__pyx_cur_scope->__pyx_v_path != Py_None);
__pyx_t_5 = (__pyx_t_4 != 0);
if (__pyx_t_5) {
/* "uvloop/loop.pyx":1739
*
* if path is not None:
* if isinstance(path, str): # <<<<<<<<<<<<<<
* path = PyUnicode_EncodeFSDefault(path)
*
*/
__pyx_t_5 = PyUnicode_Check(__pyx_cur_scope->__pyx_v_path);
__pyx_t_4 = (__pyx_t_5 != 0);
if (__pyx_t_4) {
/* "uvloop/loop.pyx":1740
* if path is not None:
* if isinstance(path, str):
* path = PyUnicode_EncodeFSDefault(path) # <<<<<<<<<<<<<<
*
* if sock is not None:
*/
__pyx_t_1 = PyUnicode_EncodeFSDefault(__pyx_cur_scope->__pyx_v_path); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1740, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_path);
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_path, __pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":1739
*
* if path is not None:
* if isinstance(path, str): # <<<<<<<<<<<<<<
* path = PyUnicode_EncodeFSDefault(path)
*
*/
}
/* "uvloop/loop.pyx":1742
* path = PyUnicode_EncodeFSDefault(path)
*
* if sock is not None: # <<<<<<<<<<<<<<
* raise ValueError(
* 'path and sock can not be specified at the same time')
*/
__pyx_t_4 = (__pyx_cur_scope->__pyx_v_sock != Py_None);
__pyx_t_5 = (__pyx_t_4 != 0);
if (__pyx_t_5) {
/* "uvloop/loop.pyx":1743
*
* if sock is not None:
* raise ValueError( # <<<<<<<<<<<<<<
* 'path and sock can not be specified at the same time')
*
*/
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__71, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1743, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__PYX_ERR(1, 1743, __pyx_L1_error)
/* "uvloop/loop.pyx":1742
* path = PyUnicode_EncodeFSDefault(path)
*
* if sock is not None: # <<<<<<<<<<<<<<
* raise ValueError(
* 'path and sock can not be specified at the same time')
*/
}
/* "uvloop/loop.pyx":1746
* 'path and sock can not be specified at the same time')
*
* waiter = self._new_future() # <<<<<<<<<<<<<<
* tr = UnixTransport.new(self, protocol, None, waiter)
* tr.connect(path)
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1746, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
__pyx_cur_scope->__pyx_v_waiter = __pyx_t_1;
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":1747
*
* waiter = self._new_future()
* tr = UnixTransport.new(self, protocol, None, waiter) # <<<<<<<<<<<<<<
* tr.connect(path)
* try:
*/
__pyx_t_1 = ((PyObject *)__pyx_f_6uvloop_4loop_13UnixTransport_new(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_protocol, ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None), __pyx_cur_scope->__pyx_v_waiter)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1747, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
__pyx_cur_scope->__pyx_v_tr = ((struct __pyx_obj_6uvloop_4loop_UnixTransport *)__pyx_t_1);
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":1748
* waiter = self._new_future()
* tr = UnixTransport.new(self, protocol, None, waiter)
* tr.connect(path) # <<<<<<<<<<<<<<
* try:
* await waiter
*/
__pyx_t_8 = __Pyx_PyObject_AsString(__pyx_cur_scope->__pyx_v_path); if (unlikely((!__pyx_t_8) && PyErr_Occurred())) __PYX_ERR(1, 1748, __pyx_L1_error)
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->connect(__pyx_cur_scope->__pyx_v_tr, __pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1748, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1749
* tr = UnixTransport.new(self, protocol, None, waiter)
* tr.connect(path)
* try: # <<<<<<<<<<<<<<
* await waiter
* except:
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11);
__Pyx_XGOTREF(__pyx_t_9);
__Pyx_XGOTREF(__pyx_t_10);
__Pyx_XGOTREF(__pyx_t_11);
/*try:*/ {
/* "uvloop/loop.pyx":1750
* tr.connect(path)
* try:
* await waiter # <<<<<<<<<<<<<<
* except:
* tr._close()
*/
__pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_waiter);
__Pyx_XGOTREF(__pyx_r);
if (likely(__pyx_r)) {
__Pyx_XGIVEREF(__pyx_t_9);
__pyx_cur_scope->__pyx_t_0 = __pyx_t_9;
__Pyx_XGIVEREF(__pyx_t_10);
__pyx_cur_scope->__pyx_t_1 = __pyx_t_10;
__Pyx_XGIVEREF(__pyx_t_11);
__pyx_cur_scope->__pyx_t_2 = __pyx_t_11;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
/* return from generator, yielding value */
__pyx_generator->resume_label = 1;
return __pyx_r;
__pyx_L18_resume_from_yield:;
__pyx_t_9 = __pyx_cur_scope->__pyx_t_0;
__pyx_cur_scope->__pyx_t_0 = 0;
__Pyx_XGOTREF(__pyx_t_9);
__pyx_t_10 = __pyx_cur_scope->__pyx_t_1;
__pyx_cur_scope->__pyx_t_1 = 0;
__Pyx_XGOTREF(__pyx_t_10);
__pyx_t_11 = __pyx_cur_scope->__pyx_t_2;
__pyx_cur_scope->__pyx_t_2 = 0;
__Pyx_XGOTREF(__pyx_t_11);
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 1750, __pyx_L10_error)
} else {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(1, 1750, __pyx_L10_error)
}
}
/* "uvloop/loop.pyx":1749
* tr = UnixTransport.new(self, protocol, None, waiter)
* tr.connect(path)
* try: # <<<<<<<<<<<<<<
* await waiter
* except:
*/
}
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
goto __pyx_L17_try_end;
__pyx_L10_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1751
* try:
* await waiter
* except: # <<<<<<<<<<<<<<
* tr._close()
* raise
*/
/*except:*/ {
__Pyx_AddTraceback("uvloop.loop.Loop.create_unix_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_2, &__pyx_t_7) < 0) __PYX_ERR(1, 1751, __pyx_L12_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GOTREF(__pyx_t_7);
/* "uvloop/loop.pyx":1752
* await waiter
* except:
* tr._close() # <<<<<<<<<<<<<<
* raise
*
*/
__pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_cur_scope->__pyx_v_tr)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1752, __pyx_L12_except_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":1753
* except:
* tr._close()
* raise # <<<<<<<<<<<<<<
*
* else:
*/
__Pyx_GIVEREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_ErrRestoreWithState(__pyx_t_1, __pyx_t_2, __pyx_t_7);
__pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_7 = 0;
__PYX_ERR(1, 1753, __pyx_L12_except_error)
}
__pyx_L12_except_error:;
/* "uvloop/loop.pyx":1749
* tr = UnixTransport.new(self, protocol, None, waiter)
* tr.connect(path)
* try: # <<<<<<<<<<<<<<
* await waiter
* except:
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_XGIVEREF(__pyx_t_10);
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11);
goto __pyx_L1_error;
__pyx_L17_try_end:;
}
/* "uvloop/loop.pyx":1738
* raise ValueError('server_hostname is only meaningful with ssl')
*
* if path is not None: # <<<<<<<<<<<<<<
* if isinstance(path, str):
* path = PyUnicode_EncodeFSDefault(path)
*/
goto __pyx_L7;
}
/* "uvloop/loop.pyx":1756
*
* else:
* if sock is None: # <<<<<<<<<<<<<<
* raise ValueError('no path and sock were specified')
*
*/
/*else*/ {
__pyx_t_5 = (__pyx_cur_scope->__pyx_v_sock == Py_None);
__pyx_t_4 = (__pyx_t_5 != 0);
if (__pyx_t_4) {
/* "uvloop/loop.pyx":1757
* else:
* if sock is None:
* raise ValueError('no path and sock were specified') # <<<<<<<<<<<<<<
*
* if sock.family != uv.AF_UNIX or not _is_sock_stream(sock.type):
*/
__pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__72, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1757, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_Raise(__pyx_t_7, 0, 0, 0);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__PYX_ERR(1, 1757, __pyx_L1_error)
/* "uvloop/loop.pyx":1756
*
* else:
* if sock is None: # <<<<<<<<<<<<<<
* raise ValueError('no path and sock were specified')
*
*/
}
/* "uvloop/loop.pyx":1759
* raise ValueError('no path and sock were specified')
*
* if sock.family != uv.AF_UNIX or not _is_sock_stream(sock.type): # <<<<<<<<<<<<<<
* raise ValueError(
* 'A UNIX Domain Stream Socket was expected, got {!r}'
*/
__pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_family); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1759, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_2 = __Pyx_PyInt_From_int(AF_UNIX); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1759, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_1 = PyObject_RichCompare(__pyx_t_7, __pyx_t_2, Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1759, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(1, 1759, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
if (!__pyx_t_5) {
} else {
__pyx_t_4 = __pyx_t_5;
goto __pyx_L23_bool_binop_done;
}
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1759, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = __pyx_f_6uvloop_4loop__is_sock_stream(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1759, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(1, 1759, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_12 = ((!__pyx_t_5) != 0);
__pyx_t_4 = __pyx_t_12;
__pyx_L23_bool_binop_done:;
if (__pyx_t_4) {
/* "uvloop/loop.pyx":1762
* raise ValueError(
* 'A UNIX Domain Stream Socket was expected, got {!r}'
* .format(sock)) # <<<<<<<<<<<<<<
*
* waiter = self._new_future()
*/
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_A_UNIX_Domain_Stream_Socket_was, __pyx_n_s_format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1762, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_7 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
__pyx_t_7 = PyMethod_GET_SELF(__pyx_t_1);
if (likely(__pyx_t_7)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
__Pyx_INCREF(__pyx_t_7);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_1, function);
}
}
if (!__pyx_t_7) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_cur_scope->__pyx_v_sock); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1762, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_1)) {
PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_cur_scope->__pyx_v_sock};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1762, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_cur_scope->__pyx_v_sock};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1762, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else
#endif
{
__pyx_t_3 = PyTuple_New(1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1762, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_7); __pyx_t_7 = NULL;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
PyTuple_SET_ITEM(__pyx_t_3, 0+1, __pyx_cur_scope->__pyx_v_sock);
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1762, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1760
*
* if sock.family != uv.AF_UNIX or not _is_sock_stream(sock.type):
* raise ValueError( # <<<<<<<<<<<<<<
* 'A UNIX Domain Stream Socket was expected, got {!r}'
* .format(sock))
*/
__pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1760, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2);
__pyx_t_2 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1760, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__PYX_ERR(1, 1760, __pyx_L1_error)
/* "uvloop/loop.pyx":1759
* raise ValueError('no path and sock were specified')
*
* if sock.family != uv.AF_UNIX or not _is_sock_stream(sock.type): # <<<<<<<<<<<<<<
* raise ValueError(
* 'A UNIX Domain Stream Socket was expected, got {!r}'
*/
}
/* "uvloop/loop.pyx":1764
* .format(sock))
*
* waiter = self._new_future() # <<<<<<<<<<<<<<
* tr = UnixTransport.new(self, protocol, None, waiter)
* try:
*/
__pyx_t_2 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1764, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_2);
__pyx_cur_scope->__pyx_v_waiter = __pyx_t_2;
__pyx_t_2 = 0;
/* "uvloop/loop.pyx":1765
*
* waiter = self._new_future()
* tr = UnixTransport.new(self, protocol, None, waiter) # <<<<<<<<<<<<<<
* try:
* # See a comment on os_dup in create_connection
*/
__pyx_t_2 = ((PyObject *)__pyx_f_6uvloop_4loop_13UnixTransport_new(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_protocol, ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None), __pyx_cur_scope->__pyx_v_waiter)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1765, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_2);
__pyx_cur_scope->__pyx_v_tr = ((struct __pyx_obj_6uvloop_4loop_UnixTransport *)__pyx_t_2);
__pyx_t_2 = 0;
/* "uvloop/loop.pyx":1766
* waiter = self._new_future()
* tr = UnixTransport.new(self, protocol, None, waiter)
* try: # <<<<<<<<<<<<<<
* # See a comment on os_dup in create_connection
* fileno = os_dup(sock.fileno())
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_11, &__pyx_t_10, &__pyx_t_9);
__Pyx_XGOTREF(__pyx_t_11);
__Pyx_XGOTREF(__pyx_t_10);
__Pyx_XGOTREF(__pyx_t_9);
/*try:*/ {
/* "uvloop/loop.pyx":1768
* try:
* # See a comment on os_dup in create_connection
* fileno = os_dup(sock.fileno()) # <<<<<<<<<<<<<<
*
* # libuv will make socket non-blocking
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_fileno); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1768, __pyx_L25_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_7 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_7)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_7);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (__pyx_t_7) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1768, __pyx_L25_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1768, __pyx_L25_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_INCREF(__pyx_v_6uvloop_4loop_os_dup);
__pyx_t_3 = __pyx_v_6uvloop_4loop_os_dup; __pyx_t_7 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_7)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_7);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (!__pyx_t_7) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1768, __pyx_L25_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_1};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1768, __pyx_L25_error)
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_7, __pyx_t_1};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1768, __pyx_L25_error)
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
} else
#endif
{
__pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 1768, __pyx_L25_error)
__Pyx_GOTREF(__pyx_t_13);
__Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_7); __pyx_t_7 = NULL;
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_t_1);
__pyx_t_1 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_13, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1768, __pyx_L25_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
}
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GIVEREF(__pyx_t_2);
__pyx_cur_scope->__pyx_v_fileno = __pyx_t_2;
__pyx_t_2 = 0;
/* "uvloop/loop.pyx":1771
*
* # libuv will make socket non-blocking
* tr._open(fileno) # <<<<<<<<<<<<<<
* tr._attach_fileobj(sock)
* tr._init_protocol()
*/
__pyx_t_6 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_fileno); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1771, __pyx_L25_error)
__pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._open(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_tr), __pyx_t_6); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1771, __pyx_L25_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":1772
* # libuv will make socket non-blocking
* tr._open(fileno)
* tr._attach_fileobj(sock) # <<<<<<<<<<<<<<
* tr._init_protocol()
* await waiter
*/
__pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._attach_fileobj(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_tr), __pyx_cur_scope->__pyx_v_sock); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1772, __pyx_L25_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":1773
* tr._open(fileno)
* tr._attach_fileobj(sock)
* tr._init_protocol() # <<<<<<<<<<<<<<
* await waiter
* except:
*/
__pyx_t_2 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._init_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_cur_scope->__pyx_v_tr)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1773, __pyx_L25_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":1774
* tr._attach_fileobj(sock)
* tr._init_protocol()
* await waiter # <<<<<<<<<<<<<<
* except:
* tr._close()
*/
__pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_waiter);
__Pyx_XGOTREF(__pyx_r);
if (likely(__pyx_r)) {
__Pyx_XGIVEREF(__pyx_t_9);
__pyx_cur_scope->__pyx_t_0 = __pyx_t_9;
__Pyx_XGIVEREF(__pyx_t_10);
__pyx_cur_scope->__pyx_t_1 = __pyx_t_10;
__Pyx_XGIVEREF(__pyx_t_11);
__pyx_cur_scope->__pyx_t_2 = __pyx_t_11;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
/* return from generator, yielding value */
__pyx_generator->resume_label = 2;
return __pyx_r;
__pyx_L33_resume_from_yield:;
__pyx_t_9 = __pyx_cur_scope->__pyx_t_0;
__pyx_cur_scope->__pyx_t_0 = 0;
__Pyx_XGOTREF(__pyx_t_9);
__pyx_t_10 = __pyx_cur_scope->__pyx_t_1;
__pyx_cur_scope->__pyx_t_1 = 0;
__Pyx_XGOTREF(__pyx_t_10);
__pyx_t_11 = __pyx_cur_scope->__pyx_t_2;
__pyx_cur_scope->__pyx_t_2 = 0;
__Pyx_XGOTREF(__pyx_t_11);
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 1774, __pyx_L25_error)
} else {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(1, 1774, __pyx_L25_error)
}
}
/* "uvloop/loop.pyx":1766
* waiter = self._new_future()
* tr = UnixTransport.new(self, protocol, None, waiter)
* try: # <<<<<<<<<<<<<<
* # See a comment on os_dup in create_connection
* fileno = os_dup(sock.fileno())
*/
}
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
goto __pyx_L32_try_end;
__pyx_L25_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":1775
* tr._init_protocol()
* await waiter
* except: # <<<<<<<<<<<<<<
* tr._close()
* raise
*/
/*except:*/ {
__Pyx_AddTraceback("uvloop.loop.Loop.create_unix_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_3, &__pyx_t_13) < 0) __PYX_ERR(1, 1775, __pyx_L27_except_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GOTREF(__pyx_t_13);
/* "uvloop/loop.pyx":1776
* await waiter
* except:
* tr._close() # <<<<<<<<<<<<<<
* raise
*
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UnixTransport *)__pyx_cur_scope->__pyx_v_tr->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base.__pyx_base._close(((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_cur_scope->__pyx_v_tr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1776, __pyx_L27_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1777
* except:
* tr._close()
* raise # <<<<<<<<<<<<<<
*
* if ssl:
*/
__Pyx_GIVEREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_3);
__Pyx_XGIVEREF(__pyx_t_13);
__Pyx_ErrRestoreWithState(__pyx_t_2, __pyx_t_3, __pyx_t_13);
__pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_t_13 = 0;
__PYX_ERR(1, 1777, __pyx_L27_except_error)
}
__pyx_L27_except_error:;
/* "uvloop/loop.pyx":1766
* waiter = self._new_future()
* tr = UnixTransport.new(self, protocol, None, waiter)
* try: # <<<<<<<<<<<<<<
* # See a comment on os_dup in create_connection
* fileno = os_dup(sock.fileno())
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_XGIVEREF(__pyx_t_10);
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_ExceptionReset(__pyx_t_11, __pyx_t_10, __pyx_t_9);
goto __pyx_L1_error;
__pyx_L32_try_end:;
}
}
__pyx_L7:;
/* "uvloop/loop.pyx":1779
* raise
*
* if ssl: # <<<<<<<<<<<<<<
* await ssl_waiter
* return protocol._app_transport, app_protocol
*/
__pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_ssl); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 1779, __pyx_L1_error)
if (__pyx_t_4) {
/* "uvloop/loop.pyx":1780
*
* if ssl:
* await ssl_waiter # <<<<<<<<<<<<<<
* return protocol._app_transport, app_protocol
* else:
*/
__pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_ssl_waiter);
__Pyx_XGOTREF(__pyx_r);
if (likely(__pyx_r)) {
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
/* return from generator, yielding value */
__pyx_generator->resume_label = 3;
return __pyx_r;
__pyx_L37_resume_from_yield:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 1780, __pyx_L1_error)
} else {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(1, 1780, __pyx_L1_error)
}
}
/* "uvloop/loop.pyx":1781
* if ssl:
* await ssl_waiter
* return protocol._app_transport, app_protocol # <<<<<<<<<<<<<<
* else:
* return tr, protocol
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_13 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_protocol, __pyx_n_s_app_transport); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 1781, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_13);
__pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1781, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_13);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_13);
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_app_protocol);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_app_protocol);
PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_cur_scope->__pyx_v_app_protocol);
__pyx_t_13 = 0;
__pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = 0;
goto __pyx_L0;
/* "uvloop/loop.pyx":1779
* raise
*
* if ssl: # <<<<<<<<<<<<<<
* await ssl_waiter
* return protocol._app_transport, app_protocol
*/
}
/* "uvloop/loop.pyx":1783
* return protocol._app_transport, app_protocol
* else:
* return tr, protocol # <<<<<<<<<<<<<<
*
* def default_exception_handler(self, context):
*/
/*else*/ {
__Pyx_XDECREF(__pyx_r);
__pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1783, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_tr));
__Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_tr));
PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_cur_scope->__pyx_v_tr));
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol);
PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_cur_scope->__pyx_v_protocol);
__pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = 0;
goto __pyx_L0;
}
CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
/* "uvloop/loop.pyx":1712
* return server
*
* async def create_unix_connection(self, protocol_factory, path, *, # <<<<<<<<<<<<<<
* ssl=None, sock=None,
* server_hostname=None):
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_13);
__Pyx_AddTraceback("create_unix_connection", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_L0:;
__Pyx_XDECREF(__pyx_r); __pyx_r = 0;
__pyx_generator->resume_label = -1;
__Pyx_Coroutine_clear((PyObject*)__pyx_generator);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1785
* return tr, protocol
*
* def default_exception_handler(self, context): # <<<<<<<<<<<<<<
* """Default exception handler.
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_64default_exception_handler(PyObject *__pyx_v_self, PyObject *__pyx_v_context); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_63default_exception_handler[] = "Loop.default_exception_handler(self, context)\nDefault exception handler.\n\n This is called when an exception occurs and no exception\n handler is set, and can be called by a custom exception\n handler that wants to defer to the default behavior.\n\n The context parameter has the same meaning as in\n `call_exception_handler()`.\n ";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_64default_exception_handler(PyObject *__pyx_v_self, PyObject *__pyx_v_context) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("default_exception_handler (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_63default_exception_handler(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_context));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_63default_exception_handler(CYTHON_UNUSED struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_context) {
PyObject *__pyx_v_message = NULL;
PyObject *__pyx_v_exception = NULL;
PyObject *__pyx_v_exc_info = NULL;
PyObject *__pyx_v_log_lines = NULL;
PyObject *__pyx_v_key = NULL;
PyObject *__pyx_v_value = NULL;
PyObject *__pyx_v_tb = NULL;
PyObject *__pyx_v_ex = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
int __pyx_t_3;
int __pyx_t_4;
int __pyx_t_5;
Py_ssize_t __pyx_t_6;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
PyObject *__pyx_t_10 = NULL;
PyObject *__pyx_t_11 = NULL;
PyObject *__pyx_t_12 = NULL;
int __pyx_t_13;
PyObject *__pyx_t_14 = NULL;
PyObject *__pyx_t_15 = NULL;
PyObject *__pyx_t_16 = NULL;
int __pyx_t_17;
char const *__pyx_t_18;
PyObject *__pyx_t_19 = NULL;
PyObject *__pyx_t_20 = NULL;
PyObject *__pyx_t_21 = NULL;
PyObject *__pyx_t_22 = NULL;
PyObject *__pyx_t_23 = NULL;
PyObject *__pyx_t_24 = NULL;
__Pyx_RefNannySetupContext("default_exception_handler", 0);
/* "uvloop/loop.pyx":1795
* `call_exception_handler()`.
* """
* message = context.get('message') # <<<<<<<<<<<<<<
* if not message:
* message = 'Unhandled exception in event loop'
*/
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_context, __pyx_n_s_get); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1795, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__73, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1795, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_v_message = __pyx_t_2;
__pyx_t_2 = 0;
/* "uvloop/loop.pyx":1796
* """
* message = context.get('message')
* if not message: # <<<<<<<<<<<<<<
* message = 'Unhandled exception in event loop'
*
*/
__pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v_message); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(1, 1796, __pyx_L1_error)
__pyx_t_4 = ((!__pyx_t_3) != 0);
if (__pyx_t_4) {
/* "uvloop/loop.pyx":1797
* message = context.get('message')
* if not message:
* message = 'Unhandled exception in event loop' # <<<<<<<<<<<<<<
*
* exception = context.get('exception')
*/
__Pyx_INCREF(__pyx_kp_u_Unhandled_exception_in_event_loo);
__Pyx_DECREF_SET(__pyx_v_message, __pyx_kp_u_Unhandled_exception_in_event_loo);
/* "uvloop/loop.pyx":1796
* """
* message = context.get('message')
* if not message: # <<<<<<<<<<<<<<
* message = 'Unhandled exception in event loop'
*
*/
}
/* "uvloop/loop.pyx":1799
* message = 'Unhandled exception in event loop'
*
* exception = context.get('exception') # <<<<<<<<<<<<<<
* if exception is not None:
* exc_info = (type(exception), exception, exception.__traceback__)
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_context, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1799, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_tuple__74, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1799, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_v_exception = __pyx_t_1;
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":1800
*
* exception = context.get('exception')
* if exception is not None: # <<<<<<<<<<<<<<
* exc_info = (type(exception), exception, exception.__traceback__)
* else:
*/
__pyx_t_4 = (__pyx_v_exception != Py_None);
__pyx_t_3 = (__pyx_t_4 != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1801
* exception = context.get('exception')
* if exception is not None:
* exc_info = (type(exception), exception, exception.__traceback__) # <<<<<<<<<<<<<<
* else:
* exc_info = False
*/
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_exception, __pyx_n_s_traceback); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1801, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1801, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(((PyObject *)Py_TYPE(__pyx_v_exception)));
__Pyx_GIVEREF(((PyObject *)Py_TYPE(__pyx_v_exception)));
PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)Py_TYPE(__pyx_v_exception)));
__Pyx_INCREF(__pyx_v_exception);
__Pyx_GIVEREF(__pyx_v_exception);
PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_exception);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_1);
__pyx_t_1 = 0;
__pyx_v_exc_info = __pyx_t_2;
__pyx_t_2 = 0;
/* "uvloop/loop.pyx":1800
*
* exception = context.get('exception')
* if exception is not None: # <<<<<<<<<<<<<<
* exc_info = (type(exception), exception, exception.__traceback__)
* else:
*/
goto __pyx_L4;
}
/* "uvloop/loop.pyx":1803
* exc_info = (type(exception), exception, exception.__traceback__)
* else:
* exc_info = False # <<<<<<<<<<<<<<
*
* log_lines = [message]
*/
/*else*/ {
__Pyx_INCREF(Py_False);
__pyx_v_exc_info = Py_False;
}
__pyx_L4:;
/* "uvloop/loop.pyx":1805
* exc_info = False
*
* log_lines = [message] # <<<<<<<<<<<<<<
* for key in sorted(context):
* if key in {'message', 'exception'}:
*/
__pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1805, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_v_message);
__Pyx_GIVEREF(__pyx_v_message);
PyList_SET_ITEM(__pyx_t_2, 0, __pyx_v_message);
__pyx_v_log_lines = ((PyObject*)__pyx_t_2);
__pyx_t_2 = 0;
/* "uvloop/loop.pyx":1806
*
* log_lines = [message]
* for key in sorted(context): # <<<<<<<<<<<<<<
* if key in {'message', 'exception'}:
* continue
*/
__pyx_t_1 = PySequence_List(__pyx_v_context); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1806, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_2 = ((PyObject*)__pyx_t_1);
__pyx_t_1 = 0;
__pyx_t_5 = PyList_Sort(__pyx_t_2); if (unlikely(__pyx_t_5 == -1)) __PYX_ERR(1, 1806, __pyx_L1_error)
if (unlikely(__pyx_t_2 == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
__PYX_ERR(1, 1806, __pyx_L1_error)
}
__pyx_t_1 = __pyx_t_2; __Pyx_INCREF(__pyx_t_1); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
for (;;) {
if (__pyx_t_6 >= PyList_GET_SIZE(__pyx_t_1)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_2 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_6); __Pyx_INCREF(__pyx_t_2); __pyx_t_6++; if (unlikely(0 < 0)) __PYX_ERR(1, 1806, __pyx_L1_error)
#else
__pyx_t_2 = PySequence_ITEM(__pyx_t_1, __pyx_t_6); __pyx_t_6++; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1806, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
#endif
__Pyx_XDECREF_SET(__pyx_v_key, __pyx_t_2);
__pyx_t_2 = 0;
/* "uvloop/loop.pyx":1807
* log_lines = [message]
* for key in sorted(context):
* if key in {'message', 'exception'}: # <<<<<<<<<<<<<<
* continue
* value = context[key]
*/
__Pyx_INCREF(__pyx_v_key);
__pyx_t_2 = __pyx_v_key;
__pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_message, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 1807, __pyx_L1_error)
if (!__pyx_t_4) {
} else {
__pyx_t_3 = __pyx_t_4;
goto __pyx_L8_bool_binop_done;
}
__pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_t_2, __pyx_n_u_exception, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 1807, __pyx_L1_error)
__pyx_t_3 = __pyx_t_4;
__pyx_L8_bool_binop_done:;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_4 = (__pyx_t_3 != 0);
if (__pyx_t_4) {
/* "uvloop/loop.pyx":1808
* for key in sorted(context):
* if key in {'message', 'exception'}:
* continue # <<<<<<<<<<<<<<
* value = context[key]
* if key == 'source_traceback':
*/
goto __pyx_L5_continue;
/* "uvloop/loop.pyx":1807
* log_lines = [message]
* for key in sorted(context):
* if key in {'message', 'exception'}: # <<<<<<<<<<<<<<
* continue
* value = context[key]
*/
}
/* "uvloop/loop.pyx":1809
* if key in {'message', 'exception'}:
* continue
* value = context[key] # <<<<<<<<<<<<<<
* if key == 'source_traceback':
* tb = ''.join(tb_format_list(value))
*/
__pyx_t_2 = PyObject_GetItem(__pyx_v_context, __pyx_v_key); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1809, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_XDECREF_SET(__pyx_v_value, __pyx_t_2);
__pyx_t_2 = 0;
/* "uvloop/loop.pyx":1810
* continue
* value = context[key]
* if key == 'source_traceback': # <<<<<<<<<<<<<<
* tb = ''.join(tb_format_list(value))
* value = 'Object created at (most recent call last):\n'
*/
__pyx_t_4 = (__Pyx_PyUnicode_Equals(__pyx_v_key, __pyx_n_u_source_traceback, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 1810, __pyx_L1_error)
if (__pyx_t_4) {
/* "uvloop/loop.pyx":1811
* value = context[key]
* if key == 'source_traceback':
* tb = ''.join(tb_format_list(value)) # <<<<<<<<<<<<<<
* value = 'Object created at (most recent call last):\n'
* value += tb.rstrip()
*/
__Pyx_INCREF(__pyx_v_6uvloop_4loop_tb_format_list);
__pyx_t_7 = __pyx_v_6uvloop_4loop_tb_format_list; __pyx_t_8 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
__pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_8)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_8);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_7, function);
}
}
if (!__pyx_t_8) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1811, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_7)) {
PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_value};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1811, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_value};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1811, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else
#endif
{
__pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1811, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL;
__Pyx_INCREF(__pyx_v_value);
__Pyx_GIVEREF(__pyx_v_value);
PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_v_value);
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1811, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
}
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_7 = PyUnicode_Join(__pyx_kp_u__30, __pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1811, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_XDECREF_SET(__pyx_v_tb, ((PyObject*)__pyx_t_7));
__pyx_t_7 = 0;
/* "uvloop/loop.pyx":1812
* if key == 'source_traceback':
* tb = ''.join(tb_format_list(value))
* value = 'Object created at (most recent call last):\n' # <<<<<<<<<<<<<<
* value += tb.rstrip()
* else:
*/
__Pyx_INCREF(__pyx_kp_u_Object_created_at_most_recent_ca);
__Pyx_DECREF_SET(__pyx_v_value, __pyx_kp_u_Object_created_at_most_recent_ca);
/* "uvloop/loop.pyx":1813
* tb = ''.join(tb_format_list(value))
* value = 'Object created at (most recent call last):\n'
* value += tb.rstrip() # <<<<<<<<<<<<<<
* else:
* try:
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_tb, __pyx_n_s_rstrip); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1813, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_9 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_9 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_9)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_9);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (__pyx_t_9) {
__pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1813, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
} else {
__pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1813, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_value, __pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1813, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF_SET(__pyx_v_value, __pyx_t_2);
__pyx_t_2 = 0;
/* "uvloop/loop.pyx":1810
* continue
* value = context[key]
* if key == 'source_traceback': # <<<<<<<<<<<<<<
* tb = ''.join(tb_format_list(value))
* value = 'Object created at (most recent call last):\n'
*/
goto __pyx_L10;
}
/* "uvloop/loop.pyx":1815
* value += tb.rstrip()
* else:
* try: # <<<<<<<<<<<<<<
* value = repr(value)
* except Exception as ex:
*/
/*else*/ {
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12);
__Pyx_XGOTREF(__pyx_t_10);
__Pyx_XGOTREF(__pyx_t_11);
__Pyx_XGOTREF(__pyx_t_12);
/*try:*/ {
/* "uvloop/loop.pyx":1816
* else:
* try:
* value = repr(value) # <<<<<<<<<<<<<<
* except Exception as ex:
* value = ('Exception in __repr__ {!r}; '
*/
__pyx_t_2 = PyObject_Repr(__pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1816, __pyx_L11_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF_SET(__pyx_v_value, __pyx_t_2);
__pyx_t_2 = 0;
/* "uvloop/loop.pyx":1815
* value += tb.rstrip()
* else:
* try: # <<<<<<<<<<<<<<
* value = repr(value)
* except Exception as ex:
*/
}
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
goto __pyx_L18_try_end;
__pyx_L11_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":1817
* try:
* value = repr(value)
* except Exception as ex: # <<<<<<<<<<<<<<
* value = ('Exception in __repr__ {!r}; '
* 'value type: {!r}'.format(ex, type(value)))
*/
__pyx_t_13 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
if (__pyx_t_13) {
__Pyx_AddTraceback("uvloop.loop.Loop.default_exception_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_7, &__pyx_t_9) < 0) __PYX_ERR(1, 1817, __pyx_L13_except_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GOTREF(__pyx_t_9);
__Pyx_INCREF(__pyx_t_7);
__pyx_v_ex = __pyx_t_7;
/*try:*/ {
/* "uvloop/loop.pyx":1819
* except Exception as ex:
* value = ('Exception in __repr__ {!r}; '
* 'value type: {!r}'.format(ex, type(value))) # <<<<<<<<<<<<<<
* log_lines.append('{}: {}'.format(key, value))
*
*/
__pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_Exception_in___repr___r_value_ty, __pyx_n_s_format); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 1819, __pyx_L24_error)
__Pyx_GOTREF(__pyx_t_14);
__pyx_t_15 = NULL;
__pyx_t_13 = 0;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_14))) {
__pyx_t_15 = PyMethod_GET_SELF(__pyx_t_14);
if (likely(__pyx_t_15)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_14);
__Pyx_INCREF(__pyx_t_15);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_14, function);
__pyx_t_13 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_14)) {
PyObject *__pyx_temp[3] = {__pyx_t_15, __pyx_v_ex, ((PyObject *)Py_TYPE(__pyx_v_value))};
__pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_14, __pyx_temp+1-__pyx_t_13, 2+__pyx_t_13); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1819, __pyx_L24_error)
__Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
__Pyx_GOTREF(__pyx_t_8);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_14)) {
PyObject *__pyx_temp[3] = {__pyx_t_15, __pyx_v_ex, ((PyObject *)Py_TYPE(__pyx_v_value))};
__pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_14, __pyx_temp+1-__pyx_t_13, 2+__pyx_t_13); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1819, __pyx_L24_error)
__Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
__Pyx_GOTREF(__pyx_t_8);
} else
#endif
{
__pyx_t_16 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 1819, __pyx_L24_error)
__Pyx_GOTREF(__pyx_t_16);
if (__pyx_t_15) {
__Pyx_GIVEREF(__pyx_t_15); PyTuple_SET_ITEM(__pyx_t_16, 0, __pyx_t_15); __pyx_t_15 = NULL;
}
__Pyx_INCREF(__pyx_v_ex);
__Pyx_GIVEREF(__pyx_v_ex);
PyTuple_SET_ITEM(__pyx_t_16, 0+__pyx_t_13, __pyx_v_ex);
__Pyx_INCREF(((PyObject *)Py_TYPE(__pyx_v_value)));
__Pyx_GIVEREF(((PyObject *)Py_TYPE(__pyx_v_value)));
PyTuple_SET_ITEM(__pyx_t_16, 1+__pyx_t_13, ((PyObject *)Py_TYPE(__pyx_v_value)));
__pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_14, __pyx_t_16, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1819, __pyx_L24_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
}
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
__Pyx_DECREF_SET(__pyx_v_value, __pyx_t_8);
__pyx_t_8 = 0;
}
/* "uvloop/loop.pyx":1817
* try:
* value = repr(value)
* except Exception as ex: # <<<<<<<<<<<<<<
* value = ('Exception in __repr__ {!r}; '
* 'value type: {!r}'.format(ex, type(value)))
*/
/*finally:*/ {
/*normal exit:*/{
__Pyx_DECREF(__pyx_v_ex);
__pyx_v_ex = NULL;
goto __pyx_L25;
}
/*exception exit:*/{
__Pyx_PyThreadState_declare
__pyx_L24_error:;
__pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; __pyx_t_24 = 0;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
__Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
__Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_22, &__pyx_t_23, &__pyx_t_24);
if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_19, &__pyx_t_20, &__pyx_t_21) < 0)) __Pyx_ErrFetch(&__pyx_t_19, &__pyx_t_20, &__pyx_t_21);
__Pyx_XGOTREF(__pyx_t_19);
__Pyx_XGOTREF(__pyx_t_20);
__Pyx_XGOTREF(__pyx_t_21);
__Pyx_XGOTREF(__pyx_t_22);
__Pyx_XGOTREF(__pyx_t_23);
__Pyx_XGOTREF(__pyx_t_24);
__pyx_t_13 = __pyx_lineno; __pyx_t_17 = __pyx_clineno; __pyx_t_18 = __pyx_filename;
{
__Pyx_DECREF(__pyx_v_ex);
__pyx_v_ex = NULL;
}
__Pyx_PyThreadState_assign
if (PY_MAJOR_VERSION >= 3) {
__Pyx_XGIVEREF(__pyx_t_22);
__Pyx_XGIVEREF(__pyx_t_23);
__Pyx_XGIVEREF(__pyx_t_24);
__Pyx_ExceptionReset(__pyx_t_22, __pyx_t_23, __pyx_t_24);
}
__Pyx_XGIVEREF(__pyx_t_19);
__Pyx_XGIVEREF(__pyx_t_20);
__Pyx_XGIVEREF(__pyx_t_21);
__Pyx_ErrRestore(__pyx_t_19, __pyx_t_20, __pyx_t_21);
__pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; __pyx_t_24 = 0;
__pyx_lineno = __pyx_t_13; __pyx_clineno = __pyx_t_17; __pyx_filename = __pyx_t_18;
goto __pyx_L13_except_error;
}
__pyx_L25:;
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
goto __pyx_L12_exception_handled;
}
goto __pyx_L13_except_error;
__pyx_L13_except_error:;
/* "uvloop/loop.pyx":1815
* value += tb.rstrip()
* else:
* try: # <<<<<<<<<<<<<<
* value = repr(value)
* except Exception as ex:
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_10);
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_XGIVEREF(__pyx_t_12);
__Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
goto __pyx_L1_error;
__pyx_L12_exception_handled:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_10);
__Pyx_XGIVEREF(__pyx_t_11);
__Pyx_XGIVEREF(__pyx_t_12);
__Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12);
__pyx_L18_try_end:;
}
}
__pyx_L10:;
/* "uvloop/loop.pyx":1820
* value = ('Exception in __repr__ {!r}; '
* 'value type: {!r}'.format(ex, type(value)))
* log_lines.append('{}: {}'.format(key, value)) # <<<<<<<<<<<<<<
*
* aio_logger.error('\n'.join(log_lines), exc_info=exc_info)
*/
__pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__75, __pyx_n_s_format); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1820, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_2 = NULL;
__pyx_t_17 = 0;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
__pyx_t_2 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_2)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_2);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_7, function);
__pyx_t_17 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_7)) {
PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_key, __pyx_v_value};
__pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_17, 2+__pyx_t_17); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1820, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_GOTREF(__pyx_t_9);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
PyObject *__pyx_temp[3] = {__pyx_t_2, __pyx_v_key, __pyx_v_value};
__pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_17, 2+__pyx_t_17); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1820, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_GOTREF(__pyx_t_9);
} else
#endif
{
__pyx_t_8 = PyTuple_New(2+__pyx_t_17); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1820, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
if (__pyx_t_2) {
__Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_2); __pyx_t_2 = NULL;
}
__Pyx_INCREF(__pyx_v_key);
__Pyx_GIVEREF(__pyx_v_key);
PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_17, __pyx_v_key);
__Pyx_INCREF(__pyx_v_value);
__Pyx_GIVEREF(__pyx_v_value);
PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_17, __pyx_v_value);
__pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_8, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1820, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_5 = __Pyx_PyList_Append(__pyx_v_log_lines, __pyx_t_9); if (unlikely(__pyx_t_5 == -1)) __PYX_ERR(1, 1820, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
/* "uvloop/loop.pyx":1806
*
* log_lines = [message]
* for key in sorted(context): # <<<<<<<<<<<<<<
* if key in {'message', 'exception'}:
* continue
*/
__pyx_L5_continue:;
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1822
* log_lines.append('{}: {}'.format(key, value))
*
* aio_logger.error('\n'.join(log_lines), exc_info=exc_info) # <<<<<<<<<<<<<<
*
* def get_exception_handler(self):
*/
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_error); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1822, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_9 = PyUnicode_Join(__pyx_kp_u__76, __pyx_v_log_lines); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1822, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1822, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_9);
PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_9);
__pyx_t_9 = 0;
__pyx_t_9 = PyDict_New(); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1822, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
if (PyDict_SetItem(__pyx_t_9, __pyx_n_s_exc_info, __pyx_v_exc_info) < 0) __PYX_ERR(1, 1822, __pyx_L1_error)
__pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, __pyx_t_9); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1822, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
/* "uvloop/loop.pyx":1785
* return tr, protocol
*
* def default_exception_handler(self, context): # <<<<<<<<<<<<<<
* """Default exception handler.
*
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_XDECREF(__pyx_t_9);
__Pyx_XDECREF(__pyx_t_14);
__Pyx_XDECREF(__pyx_t_15);
__Pyx_XDECREF(__pyx_t_16);
__Pyx_AddTraceback("uvloop.loop.Loop.default_exception_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_message);
__Pyx_XDECREF(__pyx_v_exception);
__Pyx_XDECREF(__pyx_v_exc_info);
__Pyx_XDECREF(__pyx_v_log_lines);
__Pyx_XDECREF(__pyx_v_key);
__Pyx_XDECREF(__pyx_v_value);
__Pyx_XDECREF(__pyx_v_tb);
__Pyx_XDECREF(__pyx_v_ex);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1824
* aio_logger.error('\n'.join(log_lines), exc_info=exc_info)
*
* def get_exception_handler(self): # <<<<<<<<<<<<<<
* """Return an exception handler, or None if the default one is in use.
* """
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_66get_exception_handler(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_65get_exception_handler[] = "Loop.get_exception_handler(self)\nReturn an exception handler, or None if the default one is in use.\n ";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_66get_exception_handler(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("get_exception_handler (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_65get_exception_handler(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_65get_exception_handler(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("get_exception_handler", 0);
/* "uvloop/loop.pyx":1827
* """Return an exception handler, or None if the default one is in use.
* """
* return self._exception_handler # <<<<<<<<<<<<<<
*
* def set_exception_handler(self, handler):
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v_self->_exception_handler);
__pyx_r = __pyx_v_self->_exception_handler;
goto __pyx_L0;
/* "uvloop/loop.pyx":1824
* aio_logger.error('\n'.join(log_lines), exc_info=exc_info)
*
* def get_exception_handler(self): # <<<<<<<<<<<<<<
* """Return an exception handler, or None if the default one is in use.
* """
*/
/* function exit code */
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1829
* return self._exception_handler
*
* def set_exception_handler(self, handler): # <<<<<<<<<<<<<<
* """Set handler as the new event loop exception handler.
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_68set_exception_handler(PyObject *__pyx_v_self, PyObject *__pyx_v_handler); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_67set_exception_handler[] = "Loop.set_exception_handler(self, handler)\nSet handler as the new event loop exception handler.\n\n If handler is None, the default exception handler will\n be set.\n\n If handler is a callable object, it should have a\n signature matching '(loop, context)', where 'loop'\n will be a reference to the active event loop, 'context'\n will be a dict object (see `call_exception_handler()`\n documentation for details about context).\n ";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_68set_exception_handler(PyObject *__pyx_v_self, PyObject *__pyx_v_handler) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("set_exception_handler (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_67set_exception_handler(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_handler));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_67set_exception_handler(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_handler) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
__Pyx_RefNannySetupContext("set_exception_handler", 0);
/* "uvloop/loop.pyx":1841
* documentation for details about context).
* """
* if handler is not None and not callable(handler): # <<<<<<<<<<<<<<
* raise TypeError('A callable object or None is expected, '
* 'got {!r}'.format(handler))
*/
__pyx_t_2 = (__pyx_v_handler != Py_None);
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
} else {
__pyx_t_1 = __pyx_t_3;
goto __pyx_L4_bool_binop_done;
}
__pyx_t_3 = __Pyx_PyCallable_Check(__pyx_v_handler); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(1, 1841, __pyx_L1_error)
__pyx_t_2 = ((!(__pyx_t_3 != 0)) != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L4_bool_binop_done:;
if (__pyx_t_1) {
/* "uvloop/loop.pyx":1843
* if handler is not None and not callable(handler):
* raise TypeError('A callable object or None is expected, '
* 'got {!r}'.format(handler)) # <<<<<<<<<<<<<<
* self._exception_handler = handler
*
*/
__pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_A_callable_object_or_None_is_exp, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1843, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_5, function);
}
}
if (!__pyx_t_6) {
__pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_handler); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1843, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_5)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_handler};
__pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1843, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_4);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_handler};
__pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1843, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_4);
} else
#endif
{
__pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1843, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_INCREF(__pyx_v_handler);
__Pyx_GIVEREF(__pyx_v_handler);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_v_handler);
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1843, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":1842
* """
* if handler is not None and not callable(handler):
* raise TypeError('A callable object or None is expected, ' # <<<<<<<<<<<<<<
* 'got {!r}'.format(handler))
* self._exception_handler = handler
*/
__pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1842, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4);
__pyx_t_4 = 0;
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1842, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__PYX_ERR(1, 1842, __pyx_L1_error)
/* "uvloop/loop.pyx":1841
* documentation for details about context).
* """
* if handler is not None and not callable(handler): # <<<<<<<<<<<<<<
* raise TypeError('A callable object or None is expected, '
* 'got {!r}'.format(handler))
*/
}
/* "uvloop/loop.pyx":1844
* raise TypeError('A callable object or None is expected, '
* 'got {!r}'.format(handler))
* self._exception_handler = handler # <<<<<<<<<<<<<<
*
* def call_exception_handler(self, context):
*/
__Pyx_INCREF(__pyx_v_handler);
__Pyx_GIVEREF(__pyx_v_handler);
__Pyx_GOTREF(__pyx_v_self->_exception_handler);
__Pyx_DECREF(__pyx_v_self->_exception_handler);
__pyx_v_self->_exception_handler = __pyx_v_handler;
/* "uvloop/loop.pyx":1829
* return self._exception_handler
*
* def set_exception_handler(self, handler): # <<<<<<<<<<<<<<
* """Set handler as the new event loop exception handler.
*
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_AddTraceback("uvloop.loop.Loop.set_exception_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1846
* self._exception_handler = handler
*
* def call_exception_handler(self, context): # <<<<<<<<<<<<<<
* """Call the current event loop's exception handler.
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_70call_exception_handler(PyObject *__pyx_v_self, PyObject *__pyx_v_context); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_69call_exception_handler[] = "Loop.call_exception_handler(self, context)\nCall the current event loop's exception handler.\n\n The context argument is a dict containing the following keys:\n\n - 'message': Error message;\n - 'exception' (optional): Exception object;\n - 'future' (optional): Future instance;\n - 'handle' (optional): Handle instance;\n - 'protocol' (optional): Protocol instance;\n - 'transport' (optional): Transport instance;\n - 'socket' (optional): Socket instance.\n\n New keys maybe introduced in the future.\n\n Note: do not overload this method in an event loop subclass.\n For custom exception handling, use the\n `set_exception_handler()` method.\n ";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_70call_exception_handler(PyObject *__pyx_v_self, PyObject *__pyx_v_context) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("call_exception_handler (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_69call_exception_handler(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_context));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_69call_exception_handler(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_context) {
PyObject *__pyx_v_exc = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
int __pyx_t_10;
PyObject *__pyx_t_11 = NULL;
PyObject *__pyx_t_12 = NULL;
PyObject *__pyx_t_13 = NULL;
PyObject *__pyx_t_14 = NULL;
PyObject *__pyx_t_15 = NULL;
PyObject *__pyx_t_16 = NULL;
PyObject *__pyx_t_17 = NULL;
PyObject *__pyx_t_18 = NULL;
int __pyx_t_19;
char const *__pyx_t_20;
PyObject *__pyx_t_21 = NULL;
PyObject *__pyx_t_22 = NULL;
PyObject *__pyx_t_23 = NULL;
__Pyx_RefNannySetupContext("call_exception_handler", 0);
/* "uvloop/loop.pyx":1865
* `set_exception_handler()` method.
* """
* if UVLOOP_DEBUG: # <<<<<<<<<<<<<<
* self._debug_exception_handler_cnt += 1
*
*/
__pyx_t_1 = (UVLOOP_DEBUG != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":1866
* """
* if UVLOOP_DEBUG:
* self._debug_exception_handler_cnt += 1 # <<<<<<<<<<<<<<
*
* if self._exception_handler is None:
*/
__pyx_v_self->_debug_exception_handler_cnt = (__pyx_v_self->_debug_exception_handler_cnt + 1);
/* "uvloop/loop.pyx":1865
* `set_exception_handler()` method.
* """
* if UVLOOP_DEBUG: # <<<<<<<<<<<<<<
* self._debug_exception_handler_cnt += 1
*
*/
}
/* "uvloop/loop.pyx":1868
* self._debug_exception_handler_cnt += 1
*
* if self._exception_handler is None: # <<<<<<<<<<<<<<
* try:
* self.default_exception_handler(context)
*/
__pyx_t_1 = (__pyx_v_self->_exception_handler == Py_None);
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":1869
*
* if self._exception_handler is None:
* try: # <<<<<<<<<<<<<<
* self.default_exception_handler(context)
* except Exception:
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5);
__Pyx_XGOTREF(__pyx_t_3);
__Pyx_XGOTREF(__pyx_t_4);
__Pyx_XGOTREF(__pyx_t_5);
/*try:*/ {
/* "uvloop/loop.pyx":1870
* if self._exception_handler is None:
* try:
* self.default_exception_handler(context) # <<<<<<<<<<<<<<
* except Exception:
* # Second protection layer for unexpected errors
*/
__pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_default_exception_handler); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 1870, __pyx_L5_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_8 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
__pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_8)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_8);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_7, function);
}
}
if (!__pyx_t_8) {
__pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_v_context); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1870, __pyx_L5_error)
__Pyx_GOTREF(__pyx_t_6);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_7)) {
PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_context};
__pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1870, __pyx_L5_error)
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_GOTREF(__pyx_t_6);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
PyObject *__pyx_temp[2] = {__pyx_t_8, __pyx_v_context};
__pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1870, __pyx_L5_error)
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_GOTREF(__pyx_t_6);
} else
#endif
{
__pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1870, __pyx_L5_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_8); __pyx_t_8 = NULL;
__Pyx_INCREF(__pyx_v_context);
__Pyx_GIVEREF(__pyx_v_context);
PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_v_context);
__pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_9, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1870, __pyx_L5_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
}
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "uvloop/loop.pyx":1869
*
* if self._exception_handler is None:
* try: # <<<<<<<<<<<<<<
* self.default_exception_handler(context)
* except Exception:
*/
}
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
goto __pyx_L12_try_end;
__pyx_L5_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "uvloop/loop.pyx":1871
* try:
* self.default_exception_handler(context)
* except Exception: # <<<<<<<<<<<<<<
* # Second protection layer for unexpected errors
* # in the default implementation, as well as for subclassed
*/
__pyx_t_10 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
if (__pyx_t_10) {
__Pyx_AddTraceback("uvloop.loop.Loop.call_exception_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_7, &__pyx_t_9) < 0) __PYX_ERR(1, 1871, __pyx_L7_except_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GOTREF(__pyx_t_9);
/* "uvloop/loop.pyx":1875
* # in the default implementation, as well as for subclassed
* # event loops with overloaded "default_exception_handler".
* aio_logger.error('Exception in default exception handler', # <<<<<<<<<<<<<<
* exc_info=True)
* else:
*/
__pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_error); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1875, __pyx_L7_except_error)
__Pyx_GOTREF(__pyx_t_8);
/* "uvloop/loop.pyx":1876
* # event loops with overloaded "default_exception_handler".
* aio_logger.error('Exception in default exception handler',
* exc_info=True) # <<<<<<<<<<<<<<
* else:
* try:
*/
__pyx_t_11 = PyDict_New(); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 1876, __pyx_L7_except_error)
__Pyx_GOTREF(__pyx_t_11);
if (PyDict_SetItem(__pyx_t_11, __pyx_n_s_exc_info, Py_True) < 0) __PYX_ERR(1, 1876, __pyx_L7_except_error)
/* "uvloop/loop.pyx":1875
* # in the default implementation, as well as for subclassed
* # event loops with overloaded "default_exception_handler".
* aio_logger.error('Exception in default exception handler', # <<<<<<<<<<<<<<
* exc_info=True)
* else:
*/
__pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_tuple__77, __pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 1875, __pyx_L7_except_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
goto __pyx_L6_exception_handled;
}
goto __pyx_L7_except_error;
__pyx_L7_except_error:;
/* "uvloop/loop.pyx":1869
*
* if self._exception_handler is None:
* try: # <<<<<<<<<<<<<<
* self.default_exception_handler(context)
* except Exception:
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5);
goto __pyx_L1_error;
__pyx_L6_exception_handled:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5);
__pyx_L12_try_end:;
}
/* "uvloop/loop.pyx":1868
* self._debug_exception_handler_cnt += 1
*
* if self._exception_handler is None: # <<<<<<<<<<<<<<
* try:
* self.default_exception_handler(context)
*/
goto __pyx_L4;
}
/* "uvloop/loop.pyx":1878
* exc_info=True)
* else:
* try: # <<<<<<<<<<<<<<
* self._exception_handler(self, context)
* except Exception as exc:
*/
/*else*/ {
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_5, &__pyx_t_4, &__pyx_t_3);
__Pyx_XGOTREF(__pyx_t_5);
__Pyx_XGOTREF(__pyx_t_4);
__Pyx_XGOTREF(__pyx_t_3);
/*try:*/ {
/* "uvloop/loop.pyx":1879
* else:
* try:
* self._exception_handler(self, context) # <<<<<<<<<<<<<<
* except Exception as exc:
* # Exception in the user set custom exception handler.
*/
__Pyx_INCREF(__pyx_v_self->_exception_handler);
__pyx_t_7 = __pyx_v_self->_exception_handler; __pyx_t_6 = NULL;
__pyx_t_10 = 0;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_7, function);
__pyx_t_10 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_7)) {
PyObject *__pyx_temp[3] = {__pyx_t_6, ((PyObject *)__pyx_v_self), __pyx_v_context};
__pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1879, __pyx_L15_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_9);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
PyObject *__pyx_temp[3] = {__pyx_t_6, ((PyObject *)__pyx_v_self), __pyx_v_context};
__pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1879, __pyx_L15_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_9);
} else
#endif
{
__pyx_t_12 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 1879, __pyx_L15_error)
__Pyx_GOTREF(__pyx_t_12);
if (__pyx_t_6) {
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_6); __pyx_t_6 = NULL;
}
__Pyx_INCREF(((PyObject *)__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_v_self));
PyTuple_SET_ITEM(__pyx_t_12, 0+__pyx_t_10, ((PyObject *)__pyx_v_self));
__Pyx_INCREF(__pyx_v_context);
__Pyx_GIVEREF(__pyx_v_context);
PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_10, __pyx_v_context);
__pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_12, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1879, __pyx_L15_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
/* "uvloop/loop.pyx":1878
* exc_info=True)
* else:
* try: # <<<<<<<<<<<<<<
* self._exception_handler(self, context)
* except Exception as exc:
*/
}
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
goto __pyx_L22_try_end;
__pyx_L15_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
/* "uvloop/loop.pyx":1880
* try:
* self._exception_handler(self, context)
* except Exception as exc: # <<<<<<<<<<<<<<
* # Exception in the user set custom exception handler.
* try:
*/
__pyx_t_10 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
if (__pyx_t_10) {
__Pyx_AddTraceback("uvloop.loop.Loop.call_exception_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_7, &__pyx_t_12) < 0) __PYX_ERR(1, 1880, __pyx_L17_except_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GOTREF(__pyx_t_12);
__Pyx_INCREF(__pyx_t_7);
__pyx_v_exc = __pyx_t_7;
/*try:*/ {
/* "uvloop/loop.pyx":1882
* except Exception as exc:
* # Exception in the user set custom exception handler.
* try: # <<<<<<<<<<<<<<
* # Let's try default handler.
* self.default_exception_handler({
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15);
__Pyx_XGOTREF(__pyx_t_13);
__Pyx_XGOTREF(__pyx_t_14);
__Pyx_XGOTREF(__pyx_t_15);
/*try:*/ {
/* "uvloop/loop.pyx":1884
* try:
* # Let's try default handler.
* self.default_exception_handler({ # <<<<<<<<<<<<<<
* 'message': 'Unhandled error in exception handler',
* 'exception': exc,
*/
__pyx_t_11 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_default_exception_handler); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 1884, __pyx_L30_error)
__Pyx_GOTREF(__pyx_t_11);
/* "uvloop/loop.pyx":1885
* # Let's try default handler.
* self.default_exception_handler({
* 'message': 'Unhandled error in exception handler', # <<<<<<<<<<<<<<
* 'exception': exc,
* 'context': context,
*/
__pyx_t_8 = PyDict_New(); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1885, __pyx_L30_error)
__Pyx_GOTREF(__pyx_t_8);
if (PyDict_SetItem(__pyx_t_8, __pyx_n_u_message, __pyx_kp_u_Unhandled_error_in_exception_han) < 0) __PYX_ERR(1, 1885, __pyx_L30_error)
/* "uvloop/loop.pyx":1886
* self.default_exception_handler({
* 'message': 'Unhandled error in exception handler',
* 'exception': exc, # <<<<<<<<<<<<<<
* 'context': context,
* })
*/
if (PyDict_SetItem(__pyx_t_8, __pyx_n_u_exception, __pyx_v_exc) < 0) __PYX_ERR(1, 1885, __pyx_L30_error)
/* "uvloop/loop.pyx":1887
* 'message': 'Unhandled error in exception handler',
* 'exception': exc,
* 'context': context, # <<<<<<<<<<<<<<
* })
* except Exception:
*/
if (PyDict_SetItem(__pyx_t_8, __pyx_n_u_context, __pyx_v_context) < 0) __PYX_ERR(1, 1885, __pyx_L30_error)
__pyx_t_16 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) {
__pyx_t_16 = PyMethod_GET_SELF(__pyx_t_11);
if (likely(__pyx_t_16)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11);
__Pyx_INCREF(__pyx_t_16);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_11, function);
}
}
if (!__pyx_t_16) {
__pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1884, __pyx_L30_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_GOTREF(__pyx_t_6);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_11)) {
PyObject *__pyx_temp[2] = {__pyx_t_16, __pyx_t_8};
__pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_11, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1884, __pyx_L30_error)
__Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_11)) {
PyObject *__pyx_temp[2] = {__pyx_t_16, __pyx_t_8};
__pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_11, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1884, __pyx_L30_error)
__Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
} else
#endif
{
__pyx_t_17 = PyTuple_New(1+1); if (unlikely(!__pyx_t_17)) __PYX_ERR(1, 1884, __pyx_L30_error)
__Pyx_GOTREF(__pyx_t_17);
__Pyx_GIVEREF(__pyx_t_16); PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_16); __pyx_t_16 = NULL;
__Pyx_GIVEREF(__pyx_t_8);
PyTuple_SET_ITEM(__pyx_t_17, 0+1, __pyx_t_8);
__pyx_t_8 = 0;
__pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_11, __pyx_t_17, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 1884, __pyx_L30_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
}
}
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "uvloop/loop.pyx":1882
* except Exception as exc:
* # Exception in the user set custom exception handler.
* try: # <<<<<<<<<<<<<<
* # Let's try default handler.
* self.default_exception_handler({
*/
}
__Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
__Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0;
__Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0;
goto __pyx_L37_try_end;
__pyx_L30_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "uvloop/loop.pyx":1889
* 'context': context,
* })
* except Exception: # <<<<<<<<<<<<<<
* # Guard 'default_exception_handler' in case it is
* # overloaded.
*/
__pyx_t_10 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
if (__pyx_t_10) {
__Pyx_AddTraceback("uvloop.loop.Loop.call_exception_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_11, &__pyx_t_17) < 0) __PYX_ERR(1, 1889, __pyx_L32_except_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GOTREF(__pyx_t_11);
__Pyx_GOTREF(__pyx_t_17);
/* "uvloop/loop.pyx":1892
* # Guard 'default_exception_handler' in case it is
* # overloaded.
* aio_logger.error('Exception in default exception handler ' # <<<<<<<<<<<<<<
* 'while handling an unexpected error '
* 'in custom exception handler',
*/
__pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_6uvloop_4loop_aio_logger, __pyx_n_s_error); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 1892, __pyx_L32_except_error)
__Pyx_GOTREF(__pyx_t_8);
/* "uvloop/loop.pyx":1895
* 'while handling an unexpected error '
* 'in custom exception handler',
* exc_info=True) # <<<<<<<<<<<<<<
*
* def add_reader(self, fd, callback, *args):
*/
__pyx_t_16 = PyDict_New(); if (unlikely(!__pyx_t_16)) __PYX_ERR(1, 1895, __pyx_L32_except_error)
__Pyx_GOTREF(__pyx_t_16);
if (PyDict_SetItem(__pyx_t_16, __pyx_n_s_exc_info, Py_True) < 0) __PYX_ERR(1, 1895, __pyx_L32_except_error)
/* "uvloop/loop.pyx":1892
* # Guard 'default_exception_handler' in case it is
* # overloaded.
* aio_logger.error('Exception in default exception handler ' # <<<<<<<<<<<<<<
* 'while handling an unexpected error '
* 'in custom exception handler',
*/
__pyx_t_18 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_tuple__78, __pyx_t_16); if (unlikely(!__pyx_t_18)) __PYX_ERR(1, 1892, __pyx_L32_except_error)
__Pyx_GOTREF(__pyx_t_18);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_16); __pyx_t_16 = 0;
__Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0;
goto __pyx_L31_exception_handled;
}
goto __pyx_L32_except_error;
__pyx_L32_except_error:;
/* "uvloop/loop.pyx":1882
* except Exception as exc:
* # Exception in the user set custom exception handler.
* try: # <<<<<<<<<<<<<<
* # Let's try default handler.
* self.default_exception_handler({
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_13);
__Pyx_XGIVEREF(__pyx_t_14);
__Pyx_XGIVEREF(__pyx_t_15);
__Pyx_ExceptionReset(__pyx_t_13, __pyx_t_14, __pyx_t_15);
goto __pyx_L28_error;
__pyx_L31_exception_handled:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_13);
__Pyx_XGIVEREF(__pyx_t_14);
__Pyx_XGIVEREF(__pyx_t_15);
__Pyx_ExceptionReset(__pyx_t_13, __pyx_t_14, __pyx_t_15);
__pyx_L37_try_end:;
}
}
/* "uvloop/loop.pyx":1880
* try:
* self._exception_handler(self, context)
* except Exception as exc: # <<<<<<<<<<<<<<
* # Exception in the user set custom exception handler.
* try:
*/
/*finally:*/ {
/*normal exit:*/{
__Pyx_DECREF(__pyx_v_exc);
__pyx_v_exc = NULL;
goto __pyx_L29;
}
/*exception exit:*/{
__Pyx_PyThreadState_declare
__pyx_L28_error:;
__pyx_t_15 = 0; __pyx_t_14 = 0; __pyx_t_13 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0;
__Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
__Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0;
if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_21, &__pyx_t_22, &__pyx_t_23);
if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_15, &__pyx_t_14, &__pyx_t_13) < 0)) __Pyx_ErrFetch(&__pyx_t_15, &__pyx_t_14, &__pyx_t_13);
__Pyx_XGOTREF(__pyx_t_15);
__Pyx_XGOTREF(__pyx_t_14);
__Pyx_XGOTREF(__pyx_t_13);
__Pyx_XGOTREF(__pyx_t_21);
__Pyx_XGOTREF(__pyx_t_22);
__Pyx_XGOTREF(__pyx_t_23);
__pyx_t_10 = __pyx_lineno; __pyx_t_19 = __pyx_clineno; __pyx_t_20 = __pyx_filename;
{
__Pyx_DECREF(__pyx_v_exc);
__pyx_v_exc = NULL;
}
__Pyx_PyThreadState_assign
if (PY_MAJOR_VERSION >= 3) {
__Pyx_XGIVEREF(__pyx_t_21);
__Pyx_XGIVEREF(__pyx_t_22);
__Pyx_XGIVEREF(__pyx_t_23);
__Pyx_ExceptionReset(__pyx_t_21, __pyx_t_22, __pyx_t_23);
}
__Pyx_XGIVEREF(__pyx_t_15);
__Pyx_XGIVEREF(__pyx_t_14);
__Pyx_XGIVEREF(__pyx_t_13);
__Pyx_ErrRestore(__pyx_t_15, __pyx_t_14, __pyx_t_13);
__pyx_t_15 = 0; __pyx_t_14 = 0; __pyx_t_13 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0;
__pyx_lineno = __pyx_t_10; __pyx_clineno = __pyx_t_19; __pyx_filename = __pyx_t_20;
goto __pyx_L17_except_error;
}
__pyx_L29:;
}
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
goto __pyx_L16_exception_handled;
}
goto __pyx_L17_except_error;
__pyx_L17_except_error:;
/* "uvloop/loop.pyx":1878
* exc_info=True)
* else:
* try: # <<<<<<<<<<<<<<
* self._exception_handler(self, context)
* except Exception as exc:
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_ExceptionReset(__pyx_t_5, __pyx_t_4, __pyx_t_3);
goto __pyx_L1_error;
__pyx_L16_exception_handled:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_XGIVEREF(__pyx_t_3);
__Pyx_ExceptionReset(__pyx_t_5, __pyx_t_4, __pyx_t_3);
__pyx_L22_try_end:;
}
}
__pyx_L4:;
/* "uvloop/loop.pyx":1846
* self._exception_handler = handler
*
* def call_exception_handler(self, context): # <<<<<<<<<<<<<<
* """Call the current event loop's exception handler.
*
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_XDECREF(__pyx_t_9);
__Pyx_XDECREF(__pyx_t_11);
__Pyx_XDECREF(__pyx_t_12);
__Pyx_XDECREF(__pyx_t_16);
__Pyx_XDECREF(__pyx_t_17);
__Pyx_XDECREF(__pyx_t_18);
__Pyx_AddTraceback("uvloop.loop.Loop.call_exception_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_exc);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1897
* exc_info=True)
*
* def add_reader(self, fd, callback, *args): # <<<<<<<<<<<<<<
* """Add a reader callback."""
* self._ensure_fd_no_transport(fd)
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_72add_reader(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_71add_reader[] = "Loop.add_reader(self, fd, callback, *args)\nAdd a reader callback.";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_72add_reader(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_fd = 0;
PyObject *__pyx_v_callback = 0;
PyObject *__pyx_v_args = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("add_reader (wrapper)", 0);
if (PyTuple_GET_SIZE(__pyx_args) > 2) {
__pyx_v_args = PyTuple_GetSlice(__pyx_args, 2, PyTuple_GET_SIZE(__pyx_args));
if (unlikely(!__pyx_v_args)) {
__Pyx_RefNannyFinishContext();
return NULL;
}
__Pyx_GOTREF(__pyx_v_args);
} else {
__pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple);
}
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_fd,&__pyx_n_s_callback,0};
PyObject* values[2] = {0,0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
default:
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
case 0: break;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_fd)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("add_reader", 0, 2, 2, 1); __PYX_ERR(1, 1897, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
const Py_ssize_t used_pos_args = (pos_args < 2) ? pos_args : 2;
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "add_reader") < 0)) __PYX_ERR(1, 1897, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) < 2) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
}
__pyx_v_fd = values[0];
__pyx_v_callback = values[1];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("add_reader", 0, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1897, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0;
__Pyx_AddTraceback("uvloop.loop.Loop.add_reader", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_71add_reader(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_fd, __pyx_v_callback, __pyx_v_args);
/* function exit code */
__Pyx_XDECREF(__pyx_v_args);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_71add_reader(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fd, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
Py_ssize_t __pyx_t_2;
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
__Pyx_RefNannySetupContext("add_reader", 0);
__Pyx_INCREF(__pyx_v_args);
/* "uvloop/loop.pyx":1899
* def add_reader(self, fd, callback, *args):
* """Add a reader callback."""
* self._ensure_fd_no_transport(fd) # <<<<<<<<<<<<<<
* if len(args) == 0:
* args = None
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_ensure_fd_no_transport(__pyx_v_self, __pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1899, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1900
* """Add a reader callback."""
* self._ensure_fd_no_transport(fd)
* if len(args) == 0: # <<<<<<<<<<<<<<
* args = None
* self._add_reader(fd, new_Handle(self, callback, args))
*/
__pyx_t_2 = PyObject_Length(__pyx_v_args); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(1, 1900, __pyx_L1_error)
__pyx_t_3 = ((__pyx_t_2 == 0) != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1901
* self._ensure_fd_no_transport(fd)
* if len(args) == 0:
* args = None # <<<<<<<<<<<<<<
* self._add_reader(fd, new_Handle(self, callback, args))
*
*/
__Pyx_INCREF(Py_None);
__Pyx_DECREF_SET(__pyx_v_args, Py_None);
/* "uvloop/loop.pyx":1900
* """Add a reader callback."""
* self._ensure_fd_no_transport(fd)
* if len(args) == 0: # <<<<<<<<<<<<<<
* args = None
* self._add_reader(fd, new_Handle(self, callback, args))
*/
}
/* "uvloop/loop.pyx":1902
* if len(args) == 0:
* args = None
* self._add_reader(fd, new_Handle(self, callback, args)) # <<<<<<<<<<<<<<
*
* def remove_reader(self, fd):
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_new_Handle(__pyx_v_self, __pyx_v_callback, __pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1902, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(1, 1902, __pyx_L1_error)
__pyx_t_4 = __pyx_f_6uvloop_4loop_4Loop__add_reader(__pyx_v_self, __pyx_v_fd, ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1902, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":1897
* exc_info=True)
*
* def add_reader(self, fd, callback, *args): # <<<<<<<<<<<<<<
* """Add a reader callback."""
* self._ensure_fd_no_transport(fd)
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_AddTraceback("uvloop.loop.Loop.add_reader", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_args);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1904
* self._add_reader(fd, new_Handle(self, callback, args))
*
* def remove_reader(self, fd): # <<<<<<<<<<<<<<
* """Remove a reader callback."""
* self._ensure_fd_no_transport(fd)
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_74remove_reader(PyObject *__pyx_v_self, PyObject *__pyx_v_fd); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_73remove_reader[] = "Loop.remove_reader(self, fd)\nRemove a reader callback.";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_74remove_reader(PyObject *__pyx_v_self, PyObject *__pyx_v_fd) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("remove_reader (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_73remove_reader(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_fd));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_73remove_reader(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fd) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("remove_reader", 0);
/* "uvloop/loop.pyx":1906
* def remove_reader(self, fd):
* """Remove a reader callback."""
* self._ensure_fd_no_transport(fd) # <<<<<<<<<<<<<<
* self._remove_reader(fd)
*
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_ensure_fd_no_transport(__pyx_v_self, __pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1906, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1907
* """Remove a reader callback."""
* self._ensure_fd_no_transport(fd)
* self._remove_reader(fd) # <<<<<<<<<<<<<<
*
* def add_writer(self, fd, callback, *args):
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__remove_reader(__pyx_v_self, __pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1907, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1904
* self._add_reader(fd, new_Handle(self, callback, args))
*
* def remove_reader(self, fd): # <<<<<<<<<<<<<<
* """Remove a reader callback."""
* self._ensure_fd_no_transport(fd)
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop.remove_reader", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1909
* self._remove_reader(fd)
*
* def add_writer(self, fd, callback, *args): # <<<<<<<<<<<<<<
* """Add a writer callback.."""
* self._ensure_fd_no_transport(fd)
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_76add_writer(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_75add_writer[] = "Loop.add_writer(self, fd, callback, *args)\nAdd a writer callback..";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_76add_writer(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_fd = 0;
PyObject *__pyx_v_callback = 0;
PyObject *__pyx_v_args = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("add_writer (wrapper)", 0);
if (PyTuple_GET_SIZE(__pyx_args) > 2) {
__pyx_v_args = PyTuple_GetSlice(__pyx_args, 2, PyTuple_GET_SIZE(__pyx_args));
if (unlikely(!__pyx_v_args)) {
__Pyx_RefNannyFinishContext();
return NULL;
}
__Pyx_GOTREF(__pyx_v_args);
} else {
__pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple);
}
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_fd,&__pyx_n_s_callback,0};
PyObject* values[2] = {0,0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
default:
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
case 0: break;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_fd)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("add_writer", 0, 2, 2, 1); __PYX_ERR(1, 1909, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
const Py_ssize_t used_pos_args = (pos_args < 2) ? pos_args : 2;
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "add_writer") < 0)) __PYX_ERR(1, 1909, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) < 2) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
}
__pyx_v_fd = values[0];
__pyx_v_callback = values[1];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("add_writer", 0, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1909, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0;
__Pyx_AddTraceback("uvloop.loop.Loop.add_writer", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_75add_writer(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_fd, __pyx_v_callback, __pyx_v_args);
/* function exit code */
__Pyx_XDECREF(__pyx_v_args);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_75add_writer(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fd, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
Py_ssize_t __pyx_t_2;
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
__Pyx_RefNannySetupContext("add_writer", 0);
__Pyx_INCREF(__pyx_v_args);
/* "uvloop/loop.pyx":1911
* def add_writer(self, fd, callback, *args):
* """Add a writer callback.."""
* self._ensure_fd_no_transport(fd) # <<<<<<<<<<<<<<
* if len(args) == 0:
* args = None
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_ensure_fd_no_transport(__pyx_v_self, __pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1911, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1912
* """Add a writer callback.."""
* self._ensure_fd_no_transport(fd)
* if len(args) == 0: # <<<<<<<<<<<<<<
* args = None
* self._add_writer(fd, new_Handle(self, callback, args))
*/
__pyx_t_2 = PyObject_Length(__pyx_v_args); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(1, 1912, __pyx_L1_error)
__pyx_t_3 = ((__pyx_t_2 == 0) != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":1913
* self._ensure_fd_no_transport(fd)
* if len(args) == 0:
* args = None # <<<<<<<<<<<<<<
* self._add_writer(fd, new_Handle(self, callback, args))
*
*/
__Pyx_INCREF(Py_None);
__Pyx_DECREF_SET(__pyx_v_args, Py_None);
/* "uvloop/loop.pyx":1912
* """Add a writer callback.."""
* self._ensure_fd_no_transport(fd)
* if len(args) == 0: # <<<<<<<<<<<<<<
* args = None
* self._add_writer(fd, new_Handle(self, callback, args))
*/
}
/* "uvloop/loop.pyx":1914
* if len(args) == 0:
* args = None
* self._add_writer(fd, new_Handle(self, callback, args)) # <<<<<<<<<<<<<<
*
* def remove_writer(self, fd):
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_new_Handle(__pyx_v_self, __pyx_v_callback, __pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1914, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(1, 1914, __pyx_L1_error)
__pyx_t_4 = __pyx_f_6uvloop_4loop_4Loop__add_writer(__pyx_v_self, __pyx_v_fd, ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1914, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":1909
* self._remove_reader(fd)
*
* def add_writer(self, fd, callback, *args): # <<<<<<<<<<<<<<
* """Add a writer callback.."""
* self._ensure_fd_no_transport(fd)
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_AddTraceback("uvloop.loop.Loop.add_writer", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_args);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1916
* self._add_writer(fd, new_Handle(self, callback, args))
*
* def remove_writer(self, fd): # <<<<<<<<<<<<<<
* """Remove a writer callback."""
* self._ensure_fd_no_transport(fd)
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_78remove_writer(PyObject *__pyx_v_self, PyObject *__pyx_v_fd); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_77remove_writer[] = "Loop.remove_writer(self, fd)\nRemove a writer callback.";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_78remove_writer(PyObject *__pyx_v_self, PyObject *__pyx_v_fd) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("remove_writer (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_77remove_writer(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_fd));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_77remove_writer(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_fd) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("remove_writer", 0);
/* "uvloop/loop.pyx":1918
* def remove_writer(self, fd):
* """Remove a writer callback."""
* self._ensure_fd_no_transport(fd) # <<<<<<<<<<<<<<
* self._remove_writer(fd)
*
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_ensure_fd_no_transport(__pyx_v_self, __pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1918, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1919
* """Remove a writer callback."""
* self._ensure_fd_no_transport(fd)
* self._remove_writer(fd) # <<<<<<<<<<<<<<
*
* def sock_recv(self, sock, n):
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__remove_writer(__pyx_v_self, __pyx_v_fd); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1919, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":1916
* self._add_writer(fd, new_Handle(self, callback, args))
*
* def remove_writer(self, fd): # <<<<<<<<<<<<<<
* """Remove a writer callback."""
* self._ensure_fd_no_transport(fd)
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop.remove_writer", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1921
* self._remove_writer(fd)
*
* def sock_recv(self, sock, n): # <<<<<<<<<<<<<<
* """Receive data from the socket.
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_80sock_recv(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_79sock_recv[] = "Loop.sock_recv(self, sock, n)\nReceive data from the socket.\n\n The return value is a bytes object representing the data received.\n The maximum amount of data to be received at once is specified by\n nbytes.\n\n This method is a coroutine.\n ";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_80sock_recv(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_sock = 0;
PyObject *__pyx_v_n = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("sock_recv (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sock,&__pyx_n_s_n,0};
PyObject* values[2] = {0,0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_sock)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_n)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("sock_recv", 1, 2, 2, 1); __PYX_ERR(1, 1921, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "sock_recv") < 0)) __PYX_ERR(1, 1921, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
}
__pyx_v_sock = values[0];
__pyx_v_n = values[1];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("sock_recv", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1921, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.sock_recv", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_79sock_recv(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_sock, __pyx_v_n);
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_79sock_recv(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sock, PyObject *__pyx_v_n) {
struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle = 0;
int __pyx_v_fd;
PyObject *__pyx_v_fut = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_t_6;
__Pyx_RefNannySetupContext("sock_recv", 0);
/* "uvloop/loop.pyx":1934
* int fd
*
* if self._debug and sock.gettimeout() != 0: # <<<<<<<<<<<<<<
* raise ValueError("the socket must be non-blocking")
*
*/
__pyx_t_2 = (__pyx_v_self->_debug != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L4_bool_binop_done;
}
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_gettimeout); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1934, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (__pyx_t_5) {
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1934, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
__pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1934, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1934, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 1934, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_1 = __pyx_t_2;
__pyx_L4_bool_binop_done:;
if (__pyx_t_1) {
/* "uvloop/loop.pyx":1935
*
* if self._debug and sock.gettimeout() != 0:
* raise ValueError("the socket must be non-blocking") # <<<<<<<<<<<<<<
*
* fut = self._new_future()
*/
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__79, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1935, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__PYX_ERR(1, 1935, __pyx_L1_error)
/* "uvloop/loop.pyx":1934
* int fd
*
* if self._debug and sock.gettimeout() != 0: # <<<<<<<<<<<<<<
* raise ValueError("the socket must be non-blocking")
*
*/
}
/* "uvloop/loop.pyx":1937
* raise ValueError("the socket must be non-blocking")
*
* fut = self._new_future() # <<<<<<<<<<<<<<
* handle = new_MethodHandle3(
* self,
*/
__pyx_t_4 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_v_self); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1937, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_v_fut = __pyx_t_4;
__pyx_t_4 = 0;
/* "uvloop/loop.pyx":1938
*
* fut = self._new_future()
* handle = new_MethodHandle3( # <<<<<<<<<<<<<<
* self,
* "Loop._sock_recv",
*/
__pyx_t_4 = __pyx_f_6uvloop_4loop_new_MethodHandle3(__pyx_v_self, __pyx_kp_u_Loop__sock_recv, ((__pyx_t_6uvloop_4loop_method3_t)((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_sock_recv), ((PyObject *)__pyx_v_self), __pyx_v_fut, __pyx_v_sock, __pyx_v_n); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1938, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(1, 1938, __pyx_L1_error)
__pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_4);
__pyx_t_4 = 0;
/* "uvloop/loop.pyx":1945
* fut, sock, n)
*
* fd = sock.fileno() # <<<<<<<<<<<<<<
* self._add_reader(fd, handle)
* return fut
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_fileno); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1945, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (__pyx_t_5) {
__pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1945, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
__pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1945, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1945, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_v_fd = __pyx_t_6;
/* "uvloop/loop.pyx":1946
*
* fd = sock.fileno()
* self._add_reader(fd, handle) # <<<<<<<<<<<<<<
* return fut
*
*/
__pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_fd); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1946, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = __pyx_f_6uvloop_4loop_4Loop__add_reader(__pyx_v_self, __pyx_t_4, __pyx_v_handle); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1946, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":1947
* fd = sock.fileno()
* self._add_reader(fd, handle)
* return fut # <<<<<<<<<<<<<<
*
* async def sock_sendall(self, sock, data):
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v_fut);
__pyx_r = __pyx_v_fut;
goto __pyx_L0;
/* "uvloop/loop.pyx":1921
* self._remove_writer(fd)
*
* def sock_recv(self, sock, n): # <<<<<<<<<<<<<<
* """Receive data from the socket.
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("uvloop.loop.Loop.sock_recv", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_handle);
__Pyx_XDECREF(__pyx_v_fut);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_83generator5(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */
/* "uvloop/loop.pyx":1949
* return fut
*
* async def sock_sendall(self, sock, data): # <<<<<<<<<<<<<<
* """Send data to the socket.
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_82sock_sendall(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_81sock_sendall[] = "Loop.sock_sendall(self, sock, data)\nSend data to the socket.\n\n The socket must be connected to a remote socket. This method continues\n to send data from data until either all data has been sent or an\n error occurs. None is returned on success. On error, an exception is\n raised, and there is no way to determine how much data, if any, was\n successfully processed by the receiving end of the connection.\n\n This method is a coroutine.\n ";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_82sock_sendall(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_sock = 0;
PyObject *__pyx_v_data = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("sock_sendall (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sock,&__pyx_n_s_data,0};
PyObject* values[2] = {0,0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_sock)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_data)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("sock_sendall", 1, 2, 2, 1); __PYX_ERR(1, 1949, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "sock_sendall") < 0)) __PYX_ERR(1, 1949, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
}
__pyx_v_sock = values[0];
__pyx_v_data = values[1];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("sock_sendall", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1949, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.sock_sendall", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_81sock_sendall(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_sock, __pyx_v_data);
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_81sock_sendall(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sock, PyObject *__pyx_v_data) {
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_11_sock_sendall *__pyx_cur_scope;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("sock_sendall", 0);
__pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_11_sock_sendall *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_11_sock_sendall(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_11_sock_sendall, __pyx_empty_tuple, NULL);
if (unlikely(!__pyx_cur_scope)) {
__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_11_sock_sendall *)Py_None);
__Pyx_INCREF(Py_None);
__PYX_ERR(1, 1949, __pyx_L1_error)
} else {
__Pyx_GOTREF(__pyx_cur_scope);
}
__pyx_cur_scope->__pyx_v_self = __pyx_v_self;
__Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__pyx_cur_scope->__pyx_v_sock = __pyx_v_sock;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
__pyx_cur_scope->__pyx_v_data = __pyx_v_data;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_data);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_data);
{
__pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_83generator5, (PyObject *) __pyx_cur_scope, __pyx_n_s_sock_sendall, __pyx_n_s_Loop_sock_sendall, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(1, 1949, __pyx_L1_error)
__Pyx_DECREF(__pyx_cur_scope);
__Pyx_RefNannyFinishContext();
return (PyObject *) gen;
}
/* function exit code */
__pyx_L1_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.sock_sendall", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__Pyx_DECREF(((PyObject *)__pyx_cur_scope));
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_83generator5(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */
{
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_11_sock_sendall *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_11_sock_sendall *)__pyx_generator->closure);
PyObject *__pyx_r = NULL;
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
int __pyx_t_10;
Py_ssize_t __pyx_t_11;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("None", 0);
switch (__pyx_generator->resume_label) {
case 0: goto __pyx_L3_first_run;
case 1: goto __pyx_L19_resume_from_yield;
default: /* CPython raises the right error here */
__Pyx_RefNannyFinishContext();
return NULL;
}
__pyx_L3_first_run:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 1949, __pyx_L1_error)
/* "uvloop/loop.pyx":1965
* int fd
*
* if self._debug and sock.gettimeout() != 0: # <<<<<<<<<<<<<<
* raise ValueError("the socket must be non-blocking")
*
*/
__pyx_t_2 = (__pyx_cur_scope->__pyx_v_self->_debug != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L5_bool_binop_done;
}
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_gettimeout); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1965, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (__pyx_t_5) {
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1965, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
__pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1965, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1965, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 1965, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_1 = __pyx_t_2;
__pyx_L5_bool_binop_done:;
if (__pyx_t_1) {
/* "uvloop/loop.pyx":1966
*
* if self._debug and sock.gettimeout() != 0:
* raise ValueError("the socket must be non-blocking") # <<<<<<<<<<<<<<
*
* if not data:
*/
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__80, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1966, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__PYX_ERR(1, 1966, __pyx_L1_error)
/* "uvloop/loop.pyx":1965
* int fd
*
* if self._debug and sock.gettimeout() != 0: # <<<<<<<<<<<<<<
* raise ValueError("the socket must be non-blocking")
*
*/
}
/* "uvloop/loop.pyx":1968
* raise ValueError("the socket must be non-blocking")
*
* if not data: # <<<<<<<<<<<<<<
* return
*
*/
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_data); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 1968, __pyx_L1_error)
__pyx_t_2 = ((!__pyx_t_1) != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":1969
*
* if not data:
* return # <<<<<<<<<<<<<<
*
* try:
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = NULL;
goto __pyx_L0;
/* "uvloop/loop.pyx":1968
* raise ValueError("the socket must be non-blocking")
*
* if not data: # <<<<<<<<<<<<<<
* return
*
*/
}
/* "uvloop/loop.pyx":1971
* return
*
* try: # <<<<<<<<<<<<<<
* n = sock.send(data)
* except (BlockingIOError, InterruptedError):
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8);
__Pyx_XGOTREF(__pyx_t_6);
__Pyx_XGOTREF(__pyx_t_7);
__Pyx_XGOTREF(__pyx_t_8);
/*try:*/ {
/* "uvloop/loop.pyx":1972
*
* try:
* n = sock.send(data) # <<<<<<<<<<<<<<
* except (BlockingIOError, InterruptedError):
* pass
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_send); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1972, __pyx_L8_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (!__pyx_t_5) {
__pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_cur_scope->__pyx_v_data); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1972, __pyx_L8_error)
__Pyx_GOTREF(__pyx_t_4);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_cur_scope->__pyx_v_data};
__pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1972, __pyx_L8_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_4);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_cur_scope->__pyx_v_data};
__pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1972, __pyx_L8_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_4);
} else
#endif
{
__pyx_t_9 = PyTuple_New(1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 1972, __pyx_L8_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_data);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_data);
PyTuple_SET_ITEM(__pyx_t_9, 0+1, __pyx_cur_scope->__pyx_v_data);
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_9, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1972, __pyx_L8_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
}
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_10 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1972, __pyx_L8_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_cur_scope->__pyx_v_n = __pyx_t_10;
/* "uvloop/loop.pyx":1971
* return
*
* try: # <<<<<<<<<<<<<<
* n = sock.send(data)
* except (BlockingIOError, InterruptedError):
*/
}
/* "uvloop/loop.pyx":1976
* pass
* else:
* if UVLOOP_DEBUG: # <<<<<<<<<<<<<<
* # This can be a partial success, i.e. only part
* # of the data was sent
*/
/*else:*/ {
__pyx_t_2 = (UVLOOP_DEBUG != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":1979
* # This can be a partial success, i.e. only part
* # of the data was sent
* self._sock_try_write_total += 1 # <<<<<<<<<<<<<<
*
* if n == len(data):
*/
__pyx_cur_scope->__pyx_v_self->_sock_try_write_total = (__pyx_cur_scope->__pyx_v_self->_sock_try_write_total + 1);
/* "uvloop/loop.pyx":1976
* pass
* else:
* if UVLOOP_DEBUG: # <<<<<<<<<<<<<<
* # This can be a partial success, i.e. only part
* # of the data was sent
*/
}
/* "uvloop/loop.pyx":1981
* self._sock_try_write_total += 1
*
* if n == len(data): # <<<<<<<<<<<<<<
* return
* if not isinstance(data, memoryview):
*/
__pyx_t_11 = PyObject_Length(__pyx_cur_scope->__pyx_v_data); if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(1, 1981, __pyx_L10_except_error)
__pyx_t_2 = ((__pyx_cur_scope->__pyx_v_n == __pyx_t_11) != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":1982
*
* if n == len(data):
* return # <<<<<<<<<<<<<<
* if not isinstance(data, memoryview):
* data = memoryview(data)
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = NULL;
goto __pyx_L11_except_return;
/* "uvloop/loop.pyx":1981
* self._sock_try_write_total += 1
*
* if n == len(data): # <<<<<<<<<<<<<<
* return
* if not isinstance(data, memoryview):
*/
}
/* "uvloop/loop.pyx":1983
* if n == len(data):
* return
* if not isinstance(data, memoryview): # <<<<<<<<<<<<<<
* data = memoryview(data)
* data = data[n:]
*/
__pyx_t_2 = PyObject_IsInstance(__pyx_cur_scope->__pyx_v_data, __pyx_builtin_memoryview); if (unlikely(__pyx_t_2 == -1)) __PYX_ERR(1, 1983, __pyx_L10_except_error)
__pyx_t_1 = ((!(__pyx_t_2 != 0)) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":1984
* return
* if not isinstance(data, memoryview):
* data = memoryview(data) # <<<<<<<<<<<<<<
* data = data[n:]
*
*/
__pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1984, __pyx_L10_except_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_data);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_data);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_cur_scope->__pyx_v_data);
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_memoryview, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1984, __pyx_L10_except_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_data);
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_data, __pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
__pyx_t_3 = 0;
/* "uvloop/loop.pyx":1983
* if n == len(data):
* return
* if not isinstance(data, memoryview): # <<<<<<<<<<<<<<
* data = memoryview(data)
* data = data[n:]
*/
}
/* "uvloop/loop.pyx":1985
* if not isinstance(data, memoryview):
* data = memoryview(data)
* data = data[n:] # <<<<<<<<<<<<<<
*
* fut = self._new_future()
*/
__pyx_t_3 = __Pyx_PyObject_GetSlice(__pyx_cur_scope->__pyx_v_data, __pyx_cur_scope->__pyx_v_n, 0, NULL, NULL, NULL, 1, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1985, __pyx_L10_except_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_data);
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_data, __pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
__pyx_t_3 = 0;
}
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
goto __pyx_L15_try_end;
__pyx_L8_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":1973
* try:
* n = sock.send(data)
* except (BlockingIOError, InterruptedError): # <<<<<<<<<<<<<<
* pass
* else:
*/
__pyx_t_10 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_BlockingIOError) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_InterruptedError);
if (__pyx_t_10) {
__Pyx_ErrRestore(0,0,0);
goto __pyx_L9_exception_handled;
}
goto __pyx_L10_except_error;
__pyx_L10_except_error:;
/* "uvloop/loop.pyx":1971
* return
*
* try: # <<<<<<<<<<<<<<
* n = sock.send(data)
* except (BlockingIOError, InterruptedError):
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
goto __pyx_L1_error;
__pyx_L11_except_return:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
goto __pyx_L0;
__pyx_L9_exception_handled:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
__pyx_L15_try_end:;
}
/* "uvloop/loop.pyx":1987
* data = data[n:]
*
* fut = self._new_future() # <<<<<<<<<<<<<<
* handle = new_MethodHandle3(
* self,
*/
__pyx_t_3 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1987, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
__pyx_cur_scope->__pyx_v_fut = __pyx_t_3;
__pyx_t_3 = 0;
/* "uvloop/loop.pyx":1988
*
* fut = self._new_future()
* handle = new_MethodHandle3( # <<<<<<<<<<<<<<
* self,
* "Loop._sock_sendall",
*/
__pyx_t_3 = __pyx_f_6uvloop_4loop_new_MethodHandle3(__pyx_cur_scope->__pyx_v_self, __pyx_kp_u_Loop__sock_sendall, ((__pyx_t_6uvloop_4loop_method3_t)((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_sock_sendall), ((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_cur_scope->__pyx_v_fut, __pyx_cur_scope->__pyx_v_sock, __pyx_cur_scope->__pyx_v_data); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1988, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(1, 1988, __pyx_L1_error)
__Pyx_GIVEREF(__pyx_t_3);
__pyx_cur_scope->__pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_3);
__pyx_t_3 = 0;
/* "uvloop/loop.pyx":1995
* fut, sock, data)
*
* fd = sock.fileno() # <<<<<<<<<<<<<<
* self._add_writer(fd, handle)
* return await fut
*/
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_fileno); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1995, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_9 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_9 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_9)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_9);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (__pyx_t_9) {
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1995, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
} else {
__pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1995, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_10 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 1995, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_cur_scope->__pyx_v_fd = __pyx_t_10;
/* "uvloop/loop.pyx":1996
*
* fd = sock.fileno()
* self._add_writer(fd, handle) # <<<<<<<<<<<<<<
* return await fut
*
*/
__pyx_t_3 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_fd); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1996, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = __pyx_f_6uvloop_4loop_4Loop__add_writer(__pyx_cur_scope->__pyx_v_self, __pyx_t_3, __pyx_cur_scope->__pyx_v_handle); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1996, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":1997
* fd = sock.fileno()
* self._add_writer(fd, handle)
* return await fut # <<<<<<<<<<<<<<
*
* def sock_accept(self, sock):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_fut);
__Pyx_XGOTREF(__pyx_r);
if (likely(__pyx_r)) {
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
/* return from generator, yielding value */
__pyx_generator->resume_label = 1;
return __pyx_r;
__pyx_L19_resume_from_yield:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 1997, __pyx_L1_error)
__pyx_t_4 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_4);
} else {
__pyx_t_4 = NULL;
if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_4) < 0) __PYX_ERR(1, 1997, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
}
__pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_4);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_4 = 0;
goto __pyx_L0;
CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
/* "uvloop/loop.pyx":1949
* return fut
*
* async def sock_sendall(self, sock, data): # <<<<<<<<<<<<<<
* """Send data to the socket.
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_9);
__Pyx_AddTraceback("sock_sendall", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_L0:;
__Pyx_XDECREF(__pyx_r); __pyx_r = 0;
__pyx_generator->resume_label = -1;
__Pyx_Coroutine_clear((PyObject*)__pyx_generator);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":1999
* return await fut
*
* def sock_accept(self, sock): # <<<<<<<<<<<<<<
* """Accept a connection.
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_85sock_accept(PyObject *__pyx_v_self, PyObject *__pyx_v_sock); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_84sock_accept[] = "Loop.sock_accept(self, sock)\nAccept a connection.\n\n The socket must be bound to an address and listening for connections.\n The return value is a pair (conn, address) where conn is a new socket\n object usable to send and receive data on the connection, and address\n is the address bound to the socket on the other end of the connection.\n\n This method is a coroutine.\n ";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_85sock_accept(PyObject *__pyx_v_self, PyObject *__pyx_v_sock) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("sock_accept (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_84sock_accept(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_sock));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_84sock_accept(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sock) {
struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_handle = 0;
int __pyx_v_fd;
PyObject *__pyx_v_fut = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_t_6;
__Pyx_RefNannySetupContext("sock_accept", 0);
/* "uvloop/loop.pyx":2013
* int fd
*
* if self._debug and sock.gettimeout() != 0: # <<<<<<<<<<<<<<
* raise ValueError("the socket must be non-blocking")
*
*/
__pyx_t_2 = (__pyx_v_self->_debug != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L4_bool_binop_done;
}
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_gettimeout); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2013, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (__pyx_t_5) {
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2013, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
__pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2013, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2013, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 2013, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_1 = __pyx_t_2;
__pyx_L4_bool_binop_done:;
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2014
*
* if self._debug and sock.gettimeout() != 0:
* raise ValueError("the socket must be non-blocking") # <<<<<<<<<<<<<<
*
* fut = self._new_future()
*/
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__81, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2014, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__PYX_ERR(1, 2014, __pyx_L1_error)
/* "uvloop/loop.pyx":2013
* int fd
*
* if self._debug and sock.gettimeout() != 0: # <<<<<<<<<<<<<<
* raise ValueError("the socket must be non-blocking")
*
*/
}
/* "uvloop/loop.pyx":2016
* raise ValueError("the socket must be non-blocking")
*
* fut = self._new_future() # <<<<<<<<<<<<<<
* handle = new_MethodHandle2(
* self,
*/
__pyx_t_4 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_v_self); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2016, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_v_fut = __pyx_t_4;
__pyx_t_4 = 0;
/* "uvloop/loop.pyx":2017
*
* fut = self._new_future()
* handle = new_MethodHandle2( # <<<<<<<<<<<<<<
* self,
* "Loop._sock_accept",
*/
__pyx_t_4 = __pyx_f_6uvloop_4loop_new_MethodHandle2(__pyx_v_self, __pyx_kp_u_Loop__sock_accept, ((__pyx_t_6uvloop_4loop_method2_t)((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_sock_accept), ((PyObject *)__pyx_v_self), __pyx_v_fut, __pyx_v_sock); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2017, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(1, 2017, __pyx_L1_error)
__pyx_v_handle = ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_4);
__pyx_t_4 = 0;
/* "uvloop/loop.pyx":2024
* fut, sock)
*
* fd = sock.fileno() # <<<<<<<<<<<<<<
* self._add_reader(fd, handle)
* return fut
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_sock, __pyx_n_s_fileno); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2024, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (__pyx_t_5) {
__pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2024, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
__pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2024, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_4); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 2024, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_v_fd = __pyx_t_6;
/* "uvloop/loop.pyx":2025
*
* fd = sock.fileno()
* self._add_reader(fd, handle) # <<<<<<<<<<<<<<
* return fut
*
*/
__pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_fd); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2025, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = __pyx_f_6uvloop_4loop_4Loop__add_reader(__pyx_v_self, __pyx_t_4, __pyx_v_handle); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2025, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":2026
* fd = sock.fileno()
* self._add_reader(fd, handle)
* return fut # <<<<<<<<<<<<<<
*
* async def sock_connect(self, sock, address):
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v_fut);
__pyx_r = __pyx_v_fut;
goto __pyx_L0;
/* "uvloop/loop.pyx":1999
* return await fut
*
* def sock_accept(self, sock): # <<<<<<<<<<<<<<
* """Accept a connection.
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("uvloop.loop.Loop.sock_accept", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_handle);
__Pyx_XDECREF(__pyx_v_fut);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_88generator6(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */
/* "uvloop/loop.pyx":2028
* return fut
*
* async def sock_connect(self, sock, address): # <<<<<<<<<<<<<<
* """Connect to a remote socket at address.
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_87sock_connect(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_86sock_connect[] = "Loop.sock_connect(self, sock, address)\nConnect to a remote socket at address.\n\n This method is a coroutine.\n ";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_87sock_connect(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_sock = 0;
PyObject *__pyx_v_address = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("sock_connect (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sock,&__pyx_n_s_address,0};
PyObject* values[2] = {0,0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_sock)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_address)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("sock_connect", 1, 2, 2, 1); __PYX_ERR(1, 2028, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "sock_connect") < 0)) __PYX_ERR(1, 2028, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
}
__pyx_v_sock = values[0];
__pyx_v_address = values[1];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("sock_connect", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2028, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.sock_connect", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_86sock_connect(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_sock, __pyx_v_address);
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_86sock_connect(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sock, PyObject *__pyx_v_address) {
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_12_sock_connect *__pyx_cur_scope;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("sock_connect", 0);
__pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_12_sock_connect *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_12_sock_connect(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_12_sock_connect, __pyx_empty_tuple, NULL);
if (unlikely(!__pyx_cur_scope)) {
__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_12_sock_connect *)Py_None);
__Pyx_INCREF(Py_None);
__PYX_ERR(1, 2028, __pyx_L1_error)
} else {
__Pyx_GOTREF(__pyx_cur_scope);
}
__pyx_cur_scope->__pyx_v_self = __pyx_v_self;
__Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__pyx_cur_scope->__pyx_v_sock = __pyx_v_sock;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
__pyx_cur_scope->__pyx_v_address = __pyx_v_address;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_address);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_address);
{
__pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_88generator6, (PyObject *) __pyx_cur_scope, __pyx_n_s_sock_connect, __pyx_n_s_Loop_sock_connect, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(1, 2028, __pyx_L1_error)
__Pyx_DECREF(__pyx_cur_scope);
__Pyx_RefNannyFinishContext();
return (PyObject *) gen;
}
/* function exit code */
__pyx_L1_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.sock_connect", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__Pyx_DECREF(((PyObject *)__pyx_cur_scope));
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_88generator6(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */
{
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_12_sock_connect *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_12_sock_connect *)__pyx_generator->closure);
PyObject *__pyx_r = NULL;
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
PyObject *(*__pyx_t_10)(PyObject *);
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("None", 0);
switch (__pyx_generator->resume_label) {
case 0: goto __pyx_L3_first_run;
case 1: goto __pyx_L8_resume_from_yield;
case 2: goto __pyx_L9_resume_from_yield;
case 3: goto __pyx_L12_resume_from_yield;
default: /* CPython raises the right error here */
__Pyx_RefNannyFinishContext();
return NULL;
}
__pyx_L3_first_run:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 2028, __pyx_L1_error)
/* "uvloop/loop.pyx":2033
* This method is a coroutine.
* """
* if self._debug and sock.gettimeout() != 0: # <<<<<<<<<<<<<<
* raise ValueError("the socket must be non-blocking")
*
*/
__pyx_t_2 = (__pyx_cur_scope->__pyx_v_self->_debug != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L5_bool_binop_done;
}
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_gettimeout); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2033, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (__pyx_t_5) {
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2033, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
__pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2033, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2033, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 2033, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_1 = __pyx_t_2;
__pyx_L5_bool_binop_done:;
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2034
* """
* if self._debug and sock.gettimeout() != 0:
* raise ValueError("the socket must be non-blocking") # <<<<<<<<<<<<<<
*
* fut = self._new_future()
*/
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__82, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2034, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__PYX_ERR(1, 2034, __pyx_L1_error)
/* "uvloop/loop.pyx":2033
* This method is a coroutine.
* """
* if self._debug and sock.gettimeout() != 0: # <<<<<<<<<<<<<<
* raise ValueError("the socket must be non-blocking")
*
*/
}
/* "uvloop/loop.pyx":2036
* raise ValueError("the socket must be non-blocking")
*
* fut = self._new_future() # <<<<<<<<<<<<<<
* if sock.family == uv.AF_UNIX:
* self._sock_connect(fut, sock, address)
*/
__pyx_t_4 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2036, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_4);
__pyx_cur_scope->__pyx_v_fut = __pyx_t_4;
__pyx_t_4 = 0;
/* "uvloop/loop.pyx":2037
*
* fut = self._new_future()
* if sock.family == uv.AF_UNIX: # <<<<<<<<<<<<<<
* self._sock_connect(fut, sock, address)
* await fut
*/
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_family); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2037, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = __Pyx_PyInt_From_int(AF_UNIX); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2037, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_5 = PyObject_RichCompare(__pyx_t_4, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2037, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 2037, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2038
* fut = self._new_future()
* if sock.family == uv.AF_UNIX:
* self._sock_connect(fut, sock, address) # <<<<<<<<<<<<<<
* await fut
* return
*/
__pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_sock_connect(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_fut, __pyx_cur_scope->__pyx_v_sock, __pyx_cur_scope->__pyx_v_address); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2038, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":2039
* if sock.family == uv.AF_UNIX:
* self._sock_connect(fut, sock, address)
* await fut # <<<<<<<<<<<<<<
* return
*
*/
__pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_fut);
__Pyx_XGOTREF(__pyx_r);
if (likely(__pyx_r)) {
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
/* return from generator, yielding value */
__pyx_generator->resume_label = 1;
return __pyx_r;
__pyx_L8_resume_from_yield:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 2039, __pyx_L1_error)
} else {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(1, 2039, __pyx_L1_error)
}
}
/* "uvloop/loop.pyx":2040
* self._sock_connect(fut, sock, address)
* await fut
* return # <<<<<<<<<<<<<<
*
* _, _, _, _, address = (await self.getaddrinfo(*address))[0]
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = NULL;
goto __pyx_L0;
/* "uvloop/loop.pyx":2037
*
* fut = self._new_future()
* if sock.family == uv.AF_UNIX: # <<<<<<<<<<<<<<
* self._sock_connect(fut, sock, address)
* await fut
*/
}
/* "uvloop/loop.pyx":2042
* return
*
* _, _, _, _, address = (await self.getaddrinfo(*address))[0] # <<<<<<<<<<<<<<
* self._sock_connect(fut, sock, address)
* await fut
*/
__pyx_t_5 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_getaddrinfo); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2042, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_3 = PySequence_Tuple(__pyx_cur_scope->__pyx_v_address); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2042, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2042, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_4);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XGOTREF(__pyx_r);
if (likely(__pyx_r)) {
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
/* return from generator, yielding value */
__pyx_generator->resume_label = 2;
return __pyx_r;
__pyx_L9_resume_from_yield:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 2042, __pyx_L1_error)
__pyx_t_4 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_4);
} else {
__pyx_t_4 = NULL;
if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_4) < 0) __PYX_ERR(1, 2042, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
}
__pyx_t_3 = __Pyx_GetItemInt(__pyx_t_4, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2042, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) {
PyObject* sequence = __pyx_t_3;
#if !CYTHON_COMPILING_IN_PYPY
Py_ssize_t size = Py_SIZE(sequence);
#else
Py_ssize_t size = PySequence_Size(sequence);
#endif
if (unlikely(size != 5)) {
if (size > 5) __Pyx_RaiseTooManyValuesError(5);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
__PYX_ERR(1, 2042, __pyx_L1_error)
}
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
if (likely(PyTuple_CheckExact(sequence))) {
__pyx_t_4 = PyTuple_GET_ITEM(sequence, 0);
__pyx_t_5 = PyTuple_GET_ITEM(sequence, 1);
__pyx_t_6 = PyTuple_GET_ITEM(sequence, 2);
__pyx_t_7 = PyTuple_GET_ITEM(sequence, 3);
__pyx_t_8 = PyTuple_GET_ITEM(sequence, 4);
} else {
__pyx_t_4 = PyList_GET_ITEM(sequence, 0);
__pyx_t_5 = PyList_GET_ITEM(sequence, 1);
__pyx_t_6 = PyList_GET_ITEM(sequence, 2);
__pyx_t_7 = PyList_GET_ITEM(sequence, 3);
__pyx_t_8 = PyList_GET_ITEM(sequence, 4);
}
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(__pyx_t_7);
__Pyx_INCREF(__pyx_t_8);
#else
{
Py_ssize_t i;
PyObject** temps[5] = {&__pyx_t_4,&__pyx_t_5,&__pyx_t_6,&__pyx_t_7,&__pyx_t_8};
for (i=0; i < 5; i++) {
PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(1, 2042, __pyx_L1_error)
__Pyx_GOTREF(item);
*(temps[i]) = item;
}
}
#endif
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else {
Py_ssize_t index = -1;
PyObject** temps[5] = {&__pyx_t_4,&__pyx_t_5,&__pyx_t_6,&__pyx_t_7,&__pyx_t_8};
__pyx_t_9 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 2042, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_10 = Py_TYPE(__pyx_t_9)->tp_iternext;
for (index=0; index < 5; index++) {
PyObject* item = __pyx_t_10(__pyx_t_9); if (unlikely(!item)) goto __pyx_L10_unpacking_failed;
__Pyx_GOTREF(item);
*(temps[index]) = item;
}
if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 5) < 0) __PYX_ERR(1, 2042, __pyx_L1_error)
__pyx_t_10 = NULL;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
goto __pyx_L11_unpacking_done;
__pyx_L10_unpacking_failed:;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__pyx_t_10 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
__PYX_ERR(1, 2042, __pyx_L1_error)
__pyx_L11_unpacking_done:;
}
__Pyx_GIVEREF(__pyx_t_4);
__pyx_cur_scope->__pyx_v__ = __pyx_t_4;
__pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v__);
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v__, __pyx_t_5);
__Pyx_GIVEREF(__pyx_t_5);
__pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v__);
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v__, __pyx_t_6);
__Pyx_GIVEREF(__pyx_t_6);
__pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v__);
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v__, __pyx_t_7);
__Pyx_GIVEREF(__pyx_t_7);
__pyx_t_7 = 0;
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_address);
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_address, __pyx_t_8);
__Pyx_GIVEREF(__pyx_t_8);
__pyx_t_8 = 0;
/* "uvloop/loop.pyx":2043
*
* _, _, _, _, address = (await self.getaddrinfo(*address))[0]
* self._sock_connect(fut, sock, address) # <<<<<<<<<<<<<<
* await fut
*
*/
__pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_sock_connect(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_fut, __pyx_cur_scope->__pyx_v_sock, __pyx_cur_scope->__pyx_v_address); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2043, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":2044
* _, _, _, _, address = (await self.getaddrinfo(*address))[0]
* self._sock_connect(fut, sock, address)
* await fut # <<<<<<<<<<<<<<
*
* async def connect_accepted_socket(self, protocol_factory, sock, *,
*/
__pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_fut);
__Pyx_XGOTREF(__pyx_r);
if (likely(__pyx_r)) {
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
/* return from generator, yielding value */
__pyx_generator->resume_label = 3;
return __pyx_r;
__pyx_L12_resume_from_yield:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 2044, __pyx_L1_error)
} else {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(1, 2044, __pyx_L1_error)
}
}
CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
/* "uvloop/loop.pyx":2028
* return fut
*
* async def sock_connect(self, sock, address): # <<<<<<<<<<<<<<
* """Connect to a remote socket at address.
*
*/
/* function exit code */
PyErr_SetNone(PyExc_StopIteration);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_XDECREF(__pyx_t_9);
__Pyx_AddTraceback("sock_connect", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_L0:;
__Pyx_XDECREF(__pyx_r); __pyx_r = 0;
__pyx_generator->resume_label = -1;
__Pyx_Coroutine_clear((PyObject*)__pyx_generator);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_91generator7(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */
/* "uvloop/loop.pyx":2046
* await fut
*
* async def connect_accepted_socket(self, protocol_factory, sock, *, # <<<<<<<<<<<<<<
* ssl=None):
* """Handle an accepted connection.
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_90connect_accepted_socket(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_89connect_accepted_socket[] = "Loop.connect_accepted_socket(self, protocol_factory, sock, *, ssl=None)\nHandle an accepted connection.\n\n This is used by servers that accept connections outside of\n asyncio but that use asyncio to handle connections.\n\n This method is a coroutine. When completed, the coroutine\n returns a (transport, protocol) pair.\n ";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_90connect_accepted_socket(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_protocol_factory = 0;
PyObject *__pyx_v_sock = 0;
PyObject *__pyx_v_ssl = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("connect_accepted_socket (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_protocol_factory,&__pyx_n_s_sock,&__pyx_n_s_ssl,0};
PyObject* values[3] = {0,0,0};
/* "uvloop/loop.pyx":2047
*
* async def connect_accepted_socket(self, protocol_factory, sock, *,
* ssl=None): # <<<<<<<<<<<<<<
* """Handle an accepted connection.
*
*/
values[2] = ((PyObject *)Py_None);
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_protocol_factory)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_sock)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("connect_accepted_socket", 1, 2, 2, 1); __PYX_ERR(1, 2046, __pyx_L3_error)
}
}
if (kw_args == 1) {
const Py_ssize_t index = 2;
PyObject* value = PyDict_GetItem(__pyx_kwds, *__pyx_pyargnames[index]);
if (value) { values[index] = value; kw_args--; }
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "connect_accepted_socket") < 0)) __PYX_ERR(1, 2046, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
}
__pyx_v_protocol_factory = values[0];
__pyx_v_sock = values[1];
__pyx_v_ssl = values[2];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("connect_accepted_socket", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2046, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.connect_accepted_socket", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_89connect_accepted_socket(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_protocol_factory, __pyx_v_sock, __pyx_v_ssl);
/* "uvloop/loop.pyx":2046
* await fut
*
* async def connect_accepted_socket(self, protocol_factory, sock, *, # <<<<<<<<<<<<<<
* ssl=None):
* """Handle an accepted connection.
*/
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_89connect_accepted_socket(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_sock, PyObject *__pyx_v_ssl) {
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_13_connect_accepted_socket *__pyx_cur_scope;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("connect_accepted_socket", 0);
__pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_13_connect_accepted_socket *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_13_connect_accepted_socket(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_13_connect_accepted_socket, __pyx_empty_tuple, NULL);
if (unlikely(!__pyx_cur_scope)) {
__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_13_connect_accepted_socket *)Py_None);
__Pyx_INCREF(Py_None);
__PYX_ERR(1, 2046, __pyx_L1_error)
} else {
__Pyx_GOTREF(__pyx_cur_scope);
}
__pyx_cur_scope->__pyx_v_self = __pyx_v_self;
__Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__pyx_cur_scope->__pyx_v_protocol_factory = __pyx_v_protocol_factory;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol_factory);
__pyx_cur_scope->__pyx_v_sock = __pyx_v_sock;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
__pyx_cur_scope->__pyx_v_ssl = __pyx_v_ssl;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl);
{
__pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_91generator7, (PyObject *) __pyx_cur_scope, __pyx_n_s_connect_accepted_socket, __pyx_n_s_Loop_connect_accepted_socket, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(1, 2046, __pyx_L1_error)
__Pyx_DECREF(__pyx_cur_scope);
__Pyx_RefNannyFinishContext();
return (PyObject *) gen;
}
/* function exit code */
__pyx_L1_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.connect_accepted_socket", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__Pyx_DECREF(((PyObject *)__pyx_cur_scope));
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_91generator7(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */
{
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_13_connect_accepted_socket *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_13_connect_accepted_socket *)__pyx_generator->closure);
PyObject *__pyx_r = NULL;
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
int __pyx_t_9;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("None", 0);
switch (__pyx_generator->resume_label) {
case 0: goto __pyx_L3_first_run;
case 1: goto __pyx_L13_resume_from_yield;
default: /* CPython raises the right error here */
__Pyx_RefNannyFinishContext();
return NULL;
}
__pyx_L3_first_run:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 2046, __pyx_L1_error)
/* "uvloop/loop.pyx":2058
*
* cdef:
* UVStream transport = None # <<<<<<<<<<<<<<
*
* if ssl is not None and not isinstance(ssl, ssl_SSLContext):
*/
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__pyx_cur_scope->__pyx_v_transport = ((struct __pyx_obj_6uvloop_4loop_UVStream *)Py_None);
/* "uvloop/loop.pyx":2060
* UVStream transport = None
*
* if ssl is not None and not isinstance(ssl, ssl_SSLContext): # <<<<<<<<<<<<<<
* raise TypeError('ssl argument must be an SSLContext or None')
* if not _is_sock_stream(sock.type):
*/
__pyx_t_2 = (__pyx_cur_scope->__pyx_v_ssl != Py_None);
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
} else {
__pyx_t_1 = __pyx_t_3;
goto __pyx_L5_bool_binop_done;
}
__pyx_t_4 = __pyx_v_6uvloop_4loop_ssl_SSLContext;
__Pyx_INCREF(__pyx_t_4);
__pyx_t_3 = PyObject_IsInstance(__pyx_cur_scope->__pyx_v_ssl, __pyx_t_4); if (unlikely(__pyx_t_3 == -1)) __PYX_ERR(1, 2060, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_2 = ((!(__pyx_t_3 != 0)) != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L5_bool_binop_done:;
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2061
*
* if ssl is not None and not isinstance(ssl, ssl_SSLContext):
* raise TypeError('ssl argument must be an SSLContext or None') # <<<<<<<<<<<<<<
* if not _is_sock_stream(sock.type):
* raise ValueError(
*/
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__83, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2061, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__PYX_ERR(1, 2061, __pyx_L1_error)
/* "uvloop/loop.pyx":2060
* UVStream transport = None
*
* if ssl is not None and not isinstance(ssl, ssl_SSLContext): # <<<<<<<<<<<<<<
* raise TypeError('ssl argument must be an SSLContext or None')
* if not _is_sock_stream(sock.type):
*/
}
/* "uvloop/loop.pyx":2062
* if ssl is not None and not isinstance(ssl, ssl_SSLContext):
* raise TypeError('ssl argument must be an SSLContext or None')
* if not _is_sock_stream(sock.type): # <<<<<<<<<<<<<<
* raise ValueError(
* 'A Stream Socket was expected, got {!r}'.format(sock))
*/
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_type); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2062, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = __pyx_f_6uvloop_4loop__is_sock_stream(__pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2062, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 2062, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_2 = ((!__pyx_t_1) != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":2064
* if not _is_sock_stream(sock.type):
* raise ValueError(
* 'A Stream Socket was expected, got {!r}'.format(sock)) # <<<<<<<<<<<<<<
*
* # See a comment on os_dup in create_connection
*/
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_A_Stream_Socket_was_expected_got, __pyx_n_s_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2064, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (!__pyx_t_6) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_cur_scope->__pyx_v_sock); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2064, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_cur_scope->__pyx_v_sock};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2064, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_cur_scope->__pyx_v_sock};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2064, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else
#endif
{
__pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2064, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_cur_scope->__pyx_v_sock);
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2064, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":2063
* raise TypeError('ssl argument must be an SSLContext or None')
* if not _is_sock_stream(sock.type):
* raise ValueError( # <<<<<<<<<<<<<<
* 'A Stream Socket was expected, got {!r}'.format(sock))
*
*/
__pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2063, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_5);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5);
__pyx_t_5 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2063, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_5, 0, 0, 0);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__PYX_ERR(1, 2063, __pyx_L1_error)
/* "uvloop/loop.pyx":2062
* if ssl is not None and not isinstance(ssl, ssl_SSLContext):
* raise TypeError('ssl argument must be an SSLContext or None')
* if not _is_sock_stream(sock.type): # <<<<<<<<<<<<<<
* raise ValueError(
* 'A Stream Socket was expected, got {!r}'.format(sock))
*/
}
/* "uvloop/loop.pyx":2067
*
* # See a comment on os_dup in create_connection
* fileno = os_dup(sock.fileno()) # <<<<<<<<<<<<<<
*
* app_protocol = protocol_factory()
*/
__pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_fileno); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2067, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_7, function);
}
}
if (__pyx_t_6) {
__pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2067, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
__pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2067, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_INCREF(__pyx_v_6uvloop_4loop_os_dup);
__pyx_t_7 = __pyx_v_6uvloop_4loop_os_dup; __pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_7, function);
}
}
if (!__pyx_t_6) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2067, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_7)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_4};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2067, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_4};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2067, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
{
__pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2067, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_4);
__pyx_t_4 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_8, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2067, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
}
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GIVEREF(__pyx_t_5);
__pyx_cur_scope->__pyx_v_fileno = __pyx_t_5;
__pyx_t_5 = 0;
/* "uvloop/loop.pyx":2069
* fileno = os_dup(sock.fileno())
*
* app_protocol = protocol_factory() # <<<<<<<<<<<<<<
* waiter = self._new_future()
* transport_waiter = None
*/
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
__pyx_t_7 = __pyx_cur_scope->__pyx_v_protocol_factory; __pyx_t_8 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
__pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_8)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_8);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_7, function);
}
}
if (__pyx_t_8) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2069, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
} else {
__pyx_t_5 = __Pyx_PyObject_CallNoArg(__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2069, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GIVEREF(__pyx_t_5);
__pyx_cur_scope->__pyx_v_app_protocol = __pyx_t_5;
__pyx_t_5 = 0;
/* "uvloop/loop.pyx":2070
*
* app_protocol = protocol_factory()
* waiter = self._new_future() # <<<<<<<<<<<<<<
* transport_waiter = None
*
*/
__pyx_t_5 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2070, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_5);
__pyx_cur_scope->__pyx_v_waiter = __pyx_t_5;
__pyx_t_5 = 0;
/* "uvloop/loop.pyx":2071
* app_protocol = protocol_factory()
* waiter = self._new_future()
* transport_waiter = None # <<<<<<<<<<<<<<
*
* if ssl is None:
*/
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__pyx_cur_scope->__pyx_v_transport_waiter = Py_None;
/* "uvloop/loop.pyx":2073
* transport_waiter = None
*
* if ssl is None: # <<<<<<<<<<<<<<
* protocol = app_protocol
* transport_waiter = waiter
*/
__pyx_t_2 = (__pyx_cur_scope->__pyx_v_ssl == Py_None);
__pyx_t_1 = (__pyx_t_2 != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2074
*
* if ssl is None:
* protocol = app_protocol # <<<<<<<<<<<<<<
* transport_waiter = waiter
* else:
*/
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_app_protocol);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_app_protocol);
__pyx_cur_scope->__pyx_v_protocol = __pyx_cur_scope->__pyx_v_app_protocol;
/* "uvloop/loop.pyx":2075
* if ssl is None:
* protocol = app_protocol
* transport_waiter = waiter # <<<<<<<<<<<<<<
* else:
* protocol = aio_SSLProtocol(
*/
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_waiter);
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_transport_waiter);
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_transport_waiter, __pyx_cur_scope->__pyx_v_waiter);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_waiter);
/* "uvloop/loop.pyx":2073
* transport_waiter = None
*
* if ssl is None: # <<<<<<<<<<<<<<
* protocol = app_protocol
* transport_waiter = waiter
*/
goto __pyx_L8;
}
/* "uvloop/loop.pyx":2077
* transport_waiter = waiter
* else:
* protocol = aio_SSLProtocol( # <<<<<<<<<<<<<<
* self, app_protocol, ssl, waiter,
* True, # server_side
*/
/*else*/ {
/* "uvloop/loop.pyx":2080
* self, app_protocol, ssl, waiter,
* True, # server_side
* None) # server_hostname # <<<<<<<<<<<<<<
* transport_waiter = None
*
*/
__Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_SSLProtocol);
__pyx_t_7 = __pyx_v_6uvloop_4loop_aio_SSLProtocol; __pyx_t_8 = NULL;
__pyx_t_9 = 0;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) {
__pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7);
if (likely(__pyx_t_8)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7);
__Pyx_INCREF(__pyx_t_8);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_7, function);
__pyx_t_9 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_7)) {
PyObject *__pyx_temp[7] = {__pyx_t_8, ((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_cur_scope->__pyx_v_app_protocol, __pyx_cur_scope->__pyx_v_ssl, __pyx_cur_scope->__pyx_v_waiter, Py_True, Py_None};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 6+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2077, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) {
PyObject *__pyx_temp[7] = {__pyx_t_8, ((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_cur_scope->__pyx_v_app_protocol, __pyx_cur_scope->__pyx_v_ssl, __pyx_cur_scope->__pyx_v_waiter, Py_True, Py_None};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_9, 6+__pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2077, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else
#endif
{
__pyx_t_4 = PyTuple_New(6+__pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2077, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
if (__pyx_t_8) {
__Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_8); __pyx_t_8 = NULL;
}
__Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
__Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_self));
PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_9, ((PyObject *)__pyx_cur_scope->__pyx_v_self));
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_app_protocol);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_app_protocol);
PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_9, __pyx_cur_scope->__pyx_v_app_protocol);
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_ssl);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ssl);
PyTuple_SET_ITEM(__pyx_t_4, 2+__pyx_t_9, __pyx_cur_scope->__pyx_v_ssl);
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_waiter);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_waiter);
PyTuple_SET_ITEM(__pyx_t_4, 3+__pyx_t_9, __pyx_cur_scope->__pyx_v_waiter);
__Pyx_INCREF(Py_True);
__Pyx_GIVEREF(Py_True);
PyTuple_SET_ITEM(__pyx_t_4, 4+__pyx_t_9, Py_True);
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
PyTuple_SET_ITEM(__pyx_t_4, 5+__pyx_t_9, Py_None);
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2077, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GIVEREF(__pyx_t_5);
__pyx_cur_scope->__pyx_v_protocol = __pyx_t_5;
__pyx_t_5 = 0;
/* "uvloop/loop.pyx":2081
* True, # server_side
* None) # server_hostname
* transport_waiter = None # <<<<<<<<<<<<<<
*
* if sock.family == uv.AF_UNIX:
*/
__Pyx_INCREF(Py_None);
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_transport_waiter);
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_transport_waiter, Py_None);
__Pyx_GIVEREF(Py_None);
}
__pyx_L8:;
/* "uvloop/loop.pyx":2083
* transport_waiter = None
*
* if sock.family == uv.AF_UNIX: # <<<<<<<<<<<<<<
* transport = UnixTransport.new(
* self, protocol, None, transport_waiter)
*/
__pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_family); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2083, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_7 = __Pyx_PyInt_From_int(AF_UNIX); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2083, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_4 = PyObject_RichCompare(__pyx_t_5, __pyx_t_7, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2083, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 2083, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2084
*
* if sock.family == uv.AF_UNIX:
* transport = UnixTransport.new( # <<<<<<<<<<<<<<
* self, protocol, None, transport_waiter)
* elif sock.family in (uv.AF_INET, uv.AF_INET6):
*/
__pyx_t_4 = ((PyObject *)__pyx_f_6uvloop_4loop_13UnixTransport_new(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_protocol, ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None), __pyx_cur_scope->__pyx_v_transport_waiter)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2084, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_7 = __pyx_t_4;
__Pyx_INCREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_transport));
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_transport, ((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_t_7));
__Pyx_GIVEREF(__pyx_t_7);
__pyx_t_7 = 0;
/* "uvloop/loop.pyx":2083
* transport_waiter = None
*
* if sock.family == uv.AF_UNIX: # <<<<<<<<<<<<<<
* transport = UnixTransport.new(
* self, protocol, None, transport_waiter)
*/
goto __pyx_L9;
}
/* "uvloop/loop.pyx":2086
* transport = UnixTransport.new(
* self, protocol, None, transport_waiter)
* elif sock.family in (uv.AF_INET, uv.AF_INET6): # <<<<<<<<<<<<<<
* transport = TCPTransport.new(
* self, protocol, None, transport_waiter)
*/
__pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_family); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2086, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_4 = __Pyx_PyInt_From_int(AF_INET); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2086, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_5 = PyObject_RichCompare(__pyx_t_7, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2086, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 2086, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
if (!__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L10_bool_binop_done;
}
__pyx_t_5 = __Pyx_PyInt_From_int(AF_INET6); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2086, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_4 = PyObject_RichCompare(__pyx_t_7, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2086, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 2086, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_1 = __pyx_t_2;
__pyx_L10_bool_binop_done:;
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":2087
* self, protocol, None, transport_waiter)
* elif sock.family in (uv.AF_INET, uv.AF_INET6):
* transport = TCPTransport.new( # <<<<<<<<<<<<<<
* self, protocol, None, transport_waiter)
*
*/
__pyx_t_7 = ((PyObject *)__pyx_f_6uvloop_4loop_12TCPTransport_new(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_protocol, ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None), __pyx_cur_scope->__pyx_v_transport_waiter)); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2087, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_4 = __pyx_t_7;
__Pyx_INCREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_GOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_transport));
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_transport, ((struct __pyx_obj_6uvloop_4loop_UVStream *)__pyx_t_4));
__Pyx_GIVEREF(__pyx_t_4);
__pyx_t_4 = 0;
/* "uvloop/loop.pyx":2086
* transport = UnixTransport.new(
* self, protocol, None, transport_waiter)
* elif sock.family in (uv.AF_INET, uv.AF_INET6): # <<<<<<<<<<<<<<
* transport = TCPTransport.new(
* self, protocol, None, transport_waiter)
*/
}
__pyx_L9:;
/* "uvloop/loop.pyx":2090
* self, protocol, None, transport_waiter)
*
* if transport is None: # <<<<<<<<<<<<<<
* raise ValueError(
* 'invalid socket family, expected AF_UNIX, AF_INET or AF_INET6')
*/
__pyx_t_2 = (((PyObject *)__pyx_cur_scope->__pyx_v_transport) == Py_None);
__pyx_t_1 = (__pyx_t_2 != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2091
*
* if transport is None:
* raise ValueError( # <<<<<<<<<<<<<<
* 'invalid socket family, expected AF_UNIX, AF_INET or AF_INET6')
*
*/
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__84, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2091, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__PYX_ERR(1, 2091, __pyx_L1_error)
/* "uvloop/loop.pyx":2090
* self, protocol, None, transport_waiter)
*
* if transport is None: # <<<<<<<<<<<<<<
* raise ValueError(
* 'invalid socket family, expected AF_UNIX, AF_INET or AF_INET6')
*/
}
/* "uvloop/loop.pyx":2094
* 'invalid socket family, expected AF_UNIX, AF_INET or AF_INET6')
*
* transport._open(fileno) # <<<<<<<<<<<<<<
* transport._init_protocol()
*
*/
__pyx_t_9 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_fileno); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 2094, __pyx_L1_error)
__pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_cur_scope->__pyx_v_transport->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._open(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_transport), __pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2094, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":2095
*
* transport._open(fileno)
* transport._init_protocol() # <<<<<<<<<<<<<<
*
* await waiter
*/
__pyx_t_4 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVStream *)__pyx_cur_scope->__pyx_v_transport->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._init_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_cur_scope->__pyx_v_transport)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2095, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":2097
* transport._init_protocol()
*
* await waiter # <<<<<<<<<<<<<<
* return transport, protocol
*
*/
__pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_waiter);
__Pyx_XGOTREF(__pyx_r);
if (likely(__pyx_r)) {
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
/* return from generator, yielding value */
__pyx_generator->resume_label = 1;
return __pyx_r;
__pyx_L13_resume_from_yield:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 2097, __pyx_L1_error)
} else {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(1, 2097, __pyx_L1_error)
}
}
/* "uvloop/loop.pyx":2098
*
* await waiter
* return transport, protocol # <<<<<<<<<<<<<<
*
* def run_in_executor(self, executor, func, *args):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2098, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_transport));
__Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_transport));
PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)__pyx_cur_scope->__pyx_v_transport));
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol);
PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_cur_scope->__pyx_v_protocol);
__pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_4);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_4 = 0;
goto __pyx_L0;
CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
/* "uvloop/loop.pyx":2046
* await fut
*
* async def connect_accepted_socket(self, protocol_factory, sock, *, # <<<<<<<<<<<<<<
* ssl=None):
* """Handle an accepted connection.
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_AddTraceback("connect_accepted_socket", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_L0:;
__Pyx_XDECREF(__pyx_r); __pyx_r = 0;
__pyx_generator->resume_label = -1;
__Pyx_Coroutine_clear((PyObject*)__pyx_generator);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":2100
* return transport, protocol
*
* def run_in_executor(self, executor, func, *args): # <<<<<<<<<<<<<<
* if aio_iscoroutine(func) or aio_iscoroutinefunction(func):
* raise TypeError("coroutines cannot be used with run_in_executor()")
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_93run_in_executor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_92run_in_executor[] = "Loop.run_in_executor(self, executor, func, *args)";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_93run_in_executor(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_executor = 0;
PyObject *__pyx_v_func = 0;
PyObject *__pyx_v_args = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("run_in_executor (wrapper)", 0);
if (PyTuple_GET_SIZE(__pyx_args) > 2) {
__pyx_v_args = PyTuple_GetSlice(__pyx_args, 2, PyTuple_GET_SIZE(__pyx_args));
if (unlikely(!__pyx_v_args)) {
__Pyx_RefNannyFinishContext();
return NULL;
}
__Pyx_GOTREF(__pyx_v_args);
} else {
__pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple);
}
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_executor,&__pyx_n_s_func,0};
PyObject* values[2] = {0,0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
default:
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
case 0: break;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_executor)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_func)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("run_in_executor", 0, 2, 2, 1); __PYX_ERR(1, 2100, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
const Py_ssize_t used_pos_args = (pos_args < 2) ? pos_args : 2;
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "run_in_executor") < 0)) __PYX_ERR(1, 2100, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) < 2) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
}
__pyx_v_executor = values[0];
__pyx_v_func = values[1];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("run_in_executor", 0, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2100, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0;
__Pyx_AddTraceback("uvloop.loop.Loop.run_in_executor", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_92run_in_executor(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_executor, __pyx_v_func, __pyx_v_args);
/* function exit code */
__Pyx_XDECREF(__pyx_v_args);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_92run_in_executor(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_executor, PyObject *__pyx_v_func, PyObject *__pyx_v_args) {
PyObject *__pyx_v_new_fut = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_t_6;
__Pyx_RefNannySetupContext("run_in_executor", 0);
__Pyx_INCREF(__pyx_v_executor);
/* "uvloop/loop.pyx":2101
*
* def run_in_executor(self, executor, func, *args):
* if aio_iscoroutine(func) or aio_iscoroutinefunction(func): # <<<<<<<<<<<<<<
* raise TypeError("coroutines cannot be used with run_in_executor()")
*
*/
__Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_iscoroutine);
__pyx_t_3 = __pyx_v_6uvloop_4loop_aio_iscoroutine; __pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (!__pyx_t_4) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_func); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2101, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_func};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2101, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_func};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2101, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else
#endif
{
__pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2101, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
__Pyx_INCREF(__pyx_v_func);
__Pyx_GIVEREF(__pyx_v_func);
PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_func);
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2101, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 2101, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
if (!__pyx_t_6) {
} else {
__pyx_t_1 = __pyx_t_6;
goto __pyx_L4_bool_binop_done;
}
__Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_iscoroutinefunction);
__pyx_t_3 = __pyx_v_6uvloop_4loop_aio_iscoroutinefunction; __pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (!__pyx_t_5) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_func); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2101, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_v_func};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2101, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_v_func};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2101, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else
#endif
{
__pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2101, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_INCREF(__pyx_v_func);
__Pyx_GIVEREF(__pyx_v_func);
PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_func);
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2101, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_6 < 0)) __PYX_ERR(1, 2101, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_1 = __pyx_t_6;
__pyx_L4_bool_binop_done:;
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2102
* def run_in_executor(self, executor, func, *args):
* if aio_iscoroutine(func) or aio_iscoroutinefunction(func):
* raise TypeError("coroutines cannot be used with run_in_executor()") # <<<<<<<<<<<<<<
*
* self._check_closed()
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__85, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2102, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__PYX_ERR(1, 2102, __pyx_L1_error)
/* "uvloop/loop.pyx":2101
*
* def run_in_executor(self, executor, func, *args):
* if aio_iscoroutine(func) or aio_iscoroutinefunction(func): # <<<<<<<<<<<<<<
* raise TypeError("coroutines cannot be used with run_in_executor()")
*
*/
}
/* "uvloop/loop.pyx":2104
* raise TypeError("coroutines cannot be used with run_in_executor()")
*
* self._check_closed() # <<<<<<<<<<<<<<
*
* if executor is None:
*/
__pyx_t_2 = __pyx_f_6uvloop_4loop_4Loop__check_closed(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2104, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":2106
* self._check_closed()
*
* if executor is None: # <<<<<<<<<<<<<<
* executor = self._default_executor
* if executor is None:
*/
__pyx_t_1 = (__pyx_v_executor == Py_None);
__pyx_t_6 = (__pyx_t_1 != 0);
if (__pyx_t_6) {
/* "uvloop/loop.pyx":2107
*
* if executor is None:
* executor = self._default_executor # <<<<<<<<<<<<<<
* if executor is None:
* executor = cc_ThreadPoolExecutor()
*/
__pyx_t_2 = __pyx_v_self->_default_executor;
__Pyx_INCREF(__pyx_t_2);
__Pyx_DECREF_SET(__pyx_v_executor, __pyx_t_2);
__pyx_t_2 = 0;
/* "uvloop/loop.pyx":2108
* if executor is None:
* executor = self._default_executor
* if executor is None: # <<<<<<<<<<<<<<
* executor = cc_ThreadPoolExecutor()
* self._default_executor = executor
*/
__pyx_t_6 = (__pyx_v_executor == Py_None);
__pyx_t_1 = (__pyx_t_6 != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2109
* executor = self._default_executor
* if executor is None:
* executor = cc_ThreadPoolExecutor() # <<<<<<<<<<<<<<
* self._default_executor = executor
*
*/
__Pyx_INCREF(__pyx_v_6uvloop_4loop_cc_ThreadPoolExecutor);
__pyx_t_3 = __pyx_v_6uvloop_4loop_cc_ThreadPoolExecutor; __pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (__pyx_t_4) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2109, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
__pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2109, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF_SET(__pyx_v_executor, __pyx_t_2);
__pyx_t_2 = 0;
/* "uvloop/loop.pyx":2110
* if executor is None:
* executor = cc_ThreadPoolExecutor()
* self._default_executor = executor # <<<<<<<<<<<<<<
*
* new_fut = self._new_future()
*/
__Pyx_INCREF(__pyx_v_executor);
__Pyx_GIVEREF(__pyx_v_executor);
__Pyx_GOTREF(__pyx_v_self->_default_executor);
__Pyx_DECREF(__pyx_v_self->_default_executor);
__pyx_v_self->_default_executor = __pyx_v_executor;
/* "uvloop/loop.pyx":2108
* if executor is None:
* executor = self._default_executor
* if executor is None: # <<<<<<<<<<<<<<
* executor = cc_ThreadPoolExecutor()
* self._default_executor = executor
*/
}
/* "uvloop/loop.pyx":2106
* self._check_closed()
*
* if executor is None: # <<<<<<<<<<<<<<
* executor = self._default_executor
* if executor is None:
*/
}
/* "uvloop/loop.pyx":2112
* self._default_executor = executor
*
* new_fut = self._new_future() # <<<<<<<<<<<<<<
* _chain_future(executor.submit(func, *args), new_fut)
* return new_fut
*/
__pyx_t_2 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2112, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_v_new_fut = __pyx_t_2;
__pyx_t_2 = 0;
/* "uvloop/loop.pyx":2113
*
* new_fut = self._new_future()
* _chain_future(executor.submit(func, *args), new_fut) # <<<<<<<<<<<<<<
* return new_fut
*
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_executor, __pyx_n_s_submit); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2113, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2113, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_v_func);
__Pyx_GIVEREF(__pyx_v_func);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_func);
__pyx_t_4 = PyNumber_Add(__pyx_t_3, __pyx_v_args); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2113, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2113, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_4 = __pyx_f_6uvloop_4loop__chain_future(__pyx_t_3, __pyx_v_new_fut); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2113, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":2114
* new_fut = self._new_future()
* _chain_future(executor.submit(func, *args), new_fut)
* return new_fut # <<<<<<<<<<<<<<
*
* def set_default_executor(self, executor):
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v_new_fut);
__pyx_r = __pyx_v_new_fut;
goto __pyx_L0;
/* "uvloop/loop.pyx":2100
* return transport, protocol
*
* def run_in_executor(self, executor, func, *args): # <<<<<<<<<<<<<<
* if aio_iscoroutine(func) or aio_iscoroutinefunction(func):
* raise TypeError("coroutines cannot be used with run_in_executor()")
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("uvloop.loop.Loop.run_in_executor", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_new_fut);
__Pyx_XDECREF(__pyx_v_executor);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":2116
* return new_fut
*
* def set_default_executor(self, executor): # <<<<<<<<<<<<<<
* self._default_executor = executor
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_95set_default_executor(PyObject *__pyx_v_self, PyObject *__pyx_v_executor); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_94set_default_executor[] = "Loop.set_default_executor(self, executor)";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_95set_default_executor(PyObject *__pyx_v_self, PyObject *__pyx_v_executor) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("set_default_executor (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_94set_default_executor(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_executor));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_94set_default_executor(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_executor) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("set_default_executor", 0);
/* "uvloop/loop.pyx":2117
*
* def set_default_executor(self, executor):
* self._default_executor = executor # <<<<<<<<<<<<<<
*
* async def __subprocess_run(self, protocol_factory, args,
*/
__Pyx_INCREF(__pyx_v_executor);
__Pyx_GIVEREF(__pyx_v_executor);
__Pyx_GOTREF(__pyx_v_self->_default_executor);
__Pyx_DECREF(__pyx_v_self->_default_executor);
__pyx_v_self->_default_executor = __pyx_v_executor;
/* "uvloop/loop.pyx":2116
* return new_fut
*
* def set_default_executor(self, executor): # <<<<<<<<<<<<<<
* self._default_executor = executor
*
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_98generator8(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */
/* "uvloop/loop.pyx":2119
* self._default_executor = executor
*
* async def __subprocess_run(self, protocol_factory, args, # <<<<<<<<<<<<<<
* stdin=subprocess_PIPE,
* stdout=subprocess_PIPE,
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_97__subprocess_run(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_96__subprocess_run[] = "Loop.__subprocess_run(self, protocol_factory, args, stdin=subprocess_PIPE, stdout=subprocess_PIPE, stderr=subprocess_PIPE, universal_newlines=False, shell=True, bufsize=0, preexec_fn=None, close_fds=None, cwd=None, env=None, startupinfo=None, creationflags=0, restore_signals=True, start_new_session=False, executable=None, pass_fds=(), __uvloop_sleep_after_fork=False)";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_97__subprocess_run(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_protocol_factory = 0;
PyObject *__pyx_v_args = 0;
PyObject *__pyx_v_stdin = 0;
PyObject *__pyx_v_stdout = 0;
PyObject *__pyx_v_stderr = 0;
PyObject *__pyx_v_universal_newlines = 0;
CYTHON_UNUSED PyObject *__pyx_v_shell = 0;
PyObject *__pyx_v_bufsize = 0;
PyObject *__pyx_v_preexec_fn = 0;
CYTHON_UNUSED PyObject *__pyx_v_close_fds = 0;
PyObject *__pyx_v_cwd = 0;
PyObject *__pyx_v_env = 0;
PyObject *__pyx_v_startupinfo = 0;
PyObject *__pyx_v_creationflags = 0;
PyObject *__pyx_v_restore_signals = 0;
PyObject *__pyx_v_start_new_session = 0;
PyObject *__pyx_v_executable = 0;
PyObject *__pyx_v_pass_fds = 0;
PyObject *__pyx_v___uvloop_sleep_after_fork = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__subprocess_run (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_protocol_factory,&__pyx_n_s_args,&__pyx_n_s_stdin,&__pyx_n_s_stdout,&__pyx_n_s_stderr,&__pyx_n_s_universal_newlines,&__pyx_n_s_shell,&__pyx_n_s_bufsize,&__pyx_n_s_preexec_fn,&__pyx_n_s_close_fds,&__pyx_n_s_cwd,&__pyx_n_s_env,&__pyx_n_s_startupinfo,&__pyx_n_s_creationflags,&__pyx_n_s_restore_signals,&__pyx_n_s_start_new_session,&__pyx_n_s_executable,&__pyx_n_s_pass_fds,&__pyx_n_s_uvloop_sleep_after_fork,0};
PyObject* values[19] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
values[2] = __pyx_k__86;
values[3] = __pyx_k__87;
values[4] = __pyx_k__88;
/* "uvloop/loop.pyx":2123
* stdout=subprocess_PIPE,
* stderr=subprocess_PIPE,
* universal_newlines=False, # <<<<<<<<<<<<<<
* shell=True,
* bufsize=0,
*/
values[5] = ((PyObject *)Py_False);
/* "uvloop/loop.pyx":2124
* stderr=subprocess_PIPE,
* universal_newlines=False,
* shell=True, # <<<<<<<<<<<<<<
* bufsize=0,
* preexec_fn=None,
*/
values[6] = ((PyObject *)Py_True);
values[7] = ((PyObject *)__pyx_int_0);
/* "uvloop/loop.pyx":2126
* shell=True,
* bufsize=0,
* preexec_fn=None, # <<<<<<<<<<<<<<
* close_fds=None,
* cwd=None,
*/
values[8] = ((PyObject *)Py_None);
/* "uvloop/loop.pyx":2127
* bufsize=0,
* preexec_fn=None,
* close_fds=None, # <<<<<<<<<<<<<<
* cwd=None,
* env=None,
*/
values[9] = ((PyObject *)Py_None);
/* "uvloop/loop.pyx":2128
* preexec_fn=None,
* close_fds=None,
* cwd=None, # <<<<<<<<<<<<<<
* env=None,
* startupinfo=None,
*/
values[10] = ((PyObject *)Py_None);
/* "uvloop/loop.pyx":2129
* close_fds=None,
* cwd=None,
* env=None, # <<<<<<<<<<<<<<
* startupinfo=None,
* creationflags=0,
*/
values[11] = ((PyObject *)Py_None);
/* "uvloop/loop.pyx":2130
* cwd=None,
* env=None,
* startupinfo=None, # <<<<<<<<<<<<<<
* creationflags=0,
* restore_signals=True,
*/
values[12] = ((PyObject *)Py_None);
values[13] = ((PyObject *)__pyx_int_0);
/* "uvloop/loop.pyx":2132
* startupinfo=None,
* creationflags=0,
* restore_signals=True, # <<<<<<<<<<<<<<
* start_new_session=False,
* executable=None,
*/
values[14] = ((PyObject *)Py_True);
/* "uvloop/loop.pyx":2133
* creationflags=0,
* restore_signals=True,
* start_new_session=False, # <<<<<<<<<<<<<<
* executable=None,
* pass_fds=(),
*/
values[15] = ((PyObject *)Py_False);
/* "uvloop/loop.pyx":2134
* restore_signals=True,
* start_new_session=False,
* executable=None, # <<<<<<<<<<<<<<
* pass_fds=(),
*
*/
values[16] = ((PyObject *)Py_None);
/* "uvloop/loop.pyx":2135
* start_new_session=False,
* executable=None,
* pass_fds=(), # <<<<<<<<<<<<<<
*
* # For tests only! Do not use in your code. Ever.
*/
values[17] = ((PyObject *)__pyx_empty_tuple);
/* "uvloop/loop.pyx":2138
*
* # For tests only! Do not use in your code. Ever.
* __uvloop_sleep_after_fork=False # <<<<<<<<<<<<<<
* ):
*
*/
values[18] = ((PyObject *)Py_False);
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 19: values[18] = PyTuple_GET_ITEM(__pyx_args, 18);
case 18: values[17] = PyTuple_GET_ITEM(__pyx_args, 17);
case 17: values[16] = PyTuple_GET_ITEM(__pyx_args, 16);
case 16: values[15] = PyTuple_GET_ITEM(__pyx_args, 15);
case 15: values[14] = PyTuple_GET_ITEM(__pyx_args, 14);
case 14: values[13] = PyTuple_GET_ITEM(__pyx_args, 13);
case 13: values[12] = PyTuple_GET_ITEM(__pyx_args, 12);
case 12: values[11] = PyTuple_GET_ITEM(__pyx_args, 11);
case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10);
case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9);
case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_protocol_factory)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_args)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("__subprocess_run", 0, 2, 19, 1); __PYX_ERR(1, 2119, __pyx_L3_error)
}
case 2:
if (kw_args > 0) {
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_stdin);
if (value) { values[2] = value; kw_args--; }
}
case 3:
if (kw_args > 0) {
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_stdout);
if (value) { values[3] = value; kw_args--; }
}
case 4:
if (kw_args > 0) {
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_stderr);
if (value) { values[4] = value; kw_args--; }
}
case 5:
if (kw_args > 0) {
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_universal_newlines);
if (value) { values[5] = value; kw_args--; }
}
case 6:
if (kw_args > 0) {
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_shell);
if (value) { values[6] = value; kw_args--; }
}
case 7:
if (kw_args > 0) {
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_bufsize);
if (value) { values[7] = value; kw_args--; }
}
case 8:
if (kw_args > 0) {
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_preexec_fn);
if (value) { values[8] = value; kw_args--; }
}
case 9:
if (kw_args > 0) {
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_close_fds);
if (value) { values[9] = value; kw_args--; }
}
case 10:
if (kw_args > 0) {
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_cwd);
if (value) { values[10] = value; kw_args--; }
}
case 11:
if (kw_args > 0) {
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_env);
if (value) { values[11] = value; kw_args--; }
}
case 12:
if (kw_args > 0) {
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_startupinfo);
if (value) { values[12] = value; kw_args--; }
}
case 13:
if (kw_args > 0) {
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_creationflags);
if (value) { values[13] = value; kw_args--; }
}
case 14:
if (kw_args > 0) {
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_restore_signals);
if (value) { values[14] = value; kw_args--; }
}
case 15:
if (kw_args > 0) {
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_start_new_session);
if (value) { values[15] = value; kw_args--; }
}
case 16:
if (kw_args > 0) {
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_executable);
if (value) { values[16] = value; kw_args--; }
}
case 17:
if (kw_args > 0) {
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pass_fds);
if (value) { values[17] = value; kw_args--; }
}
case 18:
if (kw_args > 0) {
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_uvloop_sleep_after_fork);
if (value) { values[18] = value; kw_args--; }
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__subprocess_run") < 0)) __PYX_ERR(1, 2119, __pyx_L3_error)
}
} else {
switch (PyTuple_GET_SIZE(__pyx_args)) {
case 19: values[18] = PyTuple_GET_ITEM(__pyx_args, 18);
case 18: values[17] = PyTuple_GET_ITEM(__pyx_args, 17);
case 17: values[16] = PyTuple_GET_ITEM(__pyx_args, 16);
case 16: values[15] = PyTuple_GET_ITEM(__pyx_args, 15);
case 15: values[14] = PyTuple_GET_ITEM(__pyx_args, 14);
case 14: values[13] = PyTuple_GET_ITEM(__pyx_args, 13);
case 13: values[12] = PyTuple_GET_ITEM(__pyx_args, 12);
case 12: values[11] = PyTuple_GET_ITEM(__pyx_args, 11);
case 11: values[10] = PyTuple_GET_ITEM(__pyx_args, 10);
case 10: values[9] = PyTuple_GET_ITEM(__pyx_args, 9);
case 9: values[8] = PyTuple_GET_ITEM(__pyx_args, 8);
case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7);
case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6);
case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5);
case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4);
case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
break;
default: goto __pyx_L5_argtuple_error;
}
}
__pyx_v_protocol_factory = values[0];
__pyx_v_args = values[1];
__pyx_v_stdin = values[2];
__pyx_v_stdout = values[3];
__pyx_v_stderr = values[4];
__pyx_v_universal_newlines = values[5];
__pyx_v_shell = values[6];
__pyx_v_bufsize = values[7];
__pyx_v_preexec_fn = values[8];
__pyx_v_close_fds = values[9];
__pyx_v_cwd = values[10];
__pyx_v_env = values[11];
__pyx_v_startupinfo = values[12];
__pyx_v_creationflags = values[13];
__pyx_v_restore_signals = values[14];
__pyx_v_start_new_session = values[15];
__pyx_v_executable = values[16];
__pyx_v_pass_fds = values[17];
__pyx_v___uvloop_sleep_after_fork = values[18];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("__subprocess_run", 0, 2, 19, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2119, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.__subprocess_run", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_96__subprocess_run(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_protocol_factory, __pyx_v_args, __pyx_v_stdin, __pyx_v_stdout, __pyx_v_stderr, __pyx_v_universal_newlines, __pyx_v_shell, __pyx_v_bufsize, __pyx_v_preexec_fn, __pyx_v_close_fds, __pyx_v_cwd, __pyx_v_env, __pyx_v_startupinfo, __pyx_v_creationflags, __pyx_v_restore_signals, __pyx_v_start_new_session, __pyx_v_executable, __pyx_v_pass_fds, __pyx_v___uvloop_sleep_after_fork);
/* "uvloop/loop.pyx":2119
* self._default_executor = executor
*
* async def __subprocess_run(self, protocol_factory, args, # <<<<<<<<<<<<<<
* stdin=subprocess_PIPE,
* stdout=subprocess_PIPE,
*/
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_96__subprocess_run(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_args, PyObject *__pyx_v_stdin, PyObject *__pyx_v_stdout, PyObject *__pyx_v_stderr, PyObject *__pyx_v_universal_newlines, CYTHON_UNUSED PyObject *__pyx_v_shell, PyObject *__pyx_v_bufsize, PyObject *__pyx_v_preexec_fn, CYTHON_UNUSED PyObject *__pyx_v_close_fds, PyObject *__pyx_v_cwd, PyObject *__pyx_v_env, PyObject *__pyx_v_startupinfo, PyObject *__pyx_v_creationflags, PyObject *__pyx_v_restore_signals, PyObject *__pyx_v_start_new_session, PyObject *__pyx_v_executable, PyObject *__pyx_v_pass_fds, PyObject *__pyx_v___uvloop_sleep_after_fork) {
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_14___subprocess_run *__pyx_cur_scope;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__subprocess_run", 0);
__pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_14___subprocess_run *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_14___subprocess_run(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_14___subprocess_run, __pyx_empty_tuple, NULL);
if (unlikely(!__pyx_cur_scope)) {
__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_14___subprocess_run *)Py_None);
__Pyx_INCREF(Py_None);
__PYX_ERR(1, 2119, __pyx_L1_error)
} else {
__Pyx_GOTREF(__pyx_cur_scope);
}
__pyx_cur_scope->__pyx_v_self = __pyx_v_self;
__Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__pyx_cur_scope->__pyx_v_protocol_factory = __pyx_v_protocol_factory;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol_factory);
__pyx_cur_scope->__pyx_v_args = __pyx_v_args;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_args);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_args);
__pyx_cur_scope->__pyx_v_stdin = __pyx_v_stdin;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_stdin);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_stdin);
__pyx_cur_scope->__pyx_v_stdout = __pyx_v_stdout;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_stdout);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_stdout);
__pyx_cur_scope->__pyx_v_stderr = __pyx_v_stderr;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_stderr);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_stderr);
__pyx_cur_scope->__pyx_v_universal_newlines = __pyx_v_universal_newlines;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_universal_newlines);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_universal_newlines);
__pyx_cur_scope->__pyx_v_shell = __pyx_v_shell;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_shell);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_shell);
__pyx_cur_scope->__pyx_v_bufsize = __pyx_v_bufsize;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_bufsize);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_bufsize);
__pyx_cur_scope->__pyx_v_preexec_fn = __pyx_v_preexec_fn;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_preexec_fn);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_preexec_fn);
__pyx_cur_scope->__pyx_v_close_fds = __pyx_v_close_fds;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_close_fds);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_close_fds);
__pyx_cur_scope->__pyx_v_cwd = __pyx_v_cwd;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_cwd);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_cwd);
__pyx_cur_scope->__pyx_v_env = __pyx_v_env;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_env);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_env);
__pyx_cur_scope->__pyx_v_startupinfo = __pyx_v_startupinfo;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_startupinfo);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_startupinfo);
__pyx_cur_scope->__pyx_v_creationflags = __pyx_v_creationflags;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_creationflags);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_creationflags);
__pyx_cur_scope->__pyx_v_restore_signals = __pyx_v_restore_signals;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_restore_signals);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_restore_signals);
__pyx_cur_scope->__pyx_v_start_new_session = __pyx_v_start_new_session;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_start_new_session);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_start_new_session);
__pyx_cur_scope->__pyx_v_executable = __pyx_v_executable;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_executable);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_executable);
__pyx_cur_scope->__pyx_v_pass_fds = __pyx_v_pass_fds;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_pass_fds);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_pass_fds);
__pyx_cur_scope->__pyx_v___uvloop_sleep_after_fork = __pyx_v___uvloop_sleep_after_fork;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v___uvloop_sleep_after_fork);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v___uvloop_sleep_after_fork);
{
__pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_98generator8, (PyObject *) __pyx_cur_scope, __pyx_n_s_subprocess_run, __pyx_n_s_Loop___subprocess_run, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(1, 2119, __pyx_L1_error)
__Pyx_DECREF(__pyx_cur_scope);
__Pyx_RefNannyFinishContext();
return (PyObject *) gen;
}
/* function exit code */
__pyx_L1_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.__subprocess_run", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__Pyx_DECREF(((PyObject *)__pyx_cur_scope));
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_98generator8(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */
{
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_14___subprocess_run *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_14___subprocess_run *)__pyx_generator->closure);
PyObject *__pyx_r = NULL;
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
PyObject *__pyx_t_10 = NULL;
PyObject *__pyx_t_11 = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("None", 0);
switch (__pyx_generator->resume_label) {
case 0: goto __pyx_L3_first_run;
case 1: goto __pyx_L18_resume_from_yield;
default: /* CPython raises the right error here */
__Pyx_RefNannyFinishContext();
return NULL;
}
__pyx_L3_first_run:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 2119, __pyx_L1_error)
/* "uvloop/loop.pyx":2145
*
* cdef:
* int debug_flags = 0 # <<<<<<<<<<<<<<
*
* if universal_newlines:
*/
__pyx_cur_scope->__pyx_v_debug_flags = 0;
/* "uvloop/loop.pyx":2147
* int debug_flags = 0
*
* if universal_newlines: # <<<<<<<<<<<<<<
* raise ValueError("universal_newlines must be False")
* if bufsize != 0:
*/
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_universal_newlines); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 2147, __pyx_L1_error)
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2148
*
* if universal_newlines:
* raise ValueError("universal_newlines must be False") # <<<<<<<<<<<<<<
* if bufsize != 0:
* raise ValueError("bufsize must be 0")
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__89, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2148, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__PYX_ERR(1, 2148, __pyx_L1_error)
/* "uvloop/loop.pyx":2147
* int debug_flags = 0
*
* if universal_newlines: # <<<<<<<<<<<<<<
* raise ValueError("universal_newlines must be False")
* if bufsize != 0:
*/
}
/* "uvloop/loop.pyx":2149
* if universal_newlines:
* raise ValueError("universal_newlines must be False")
* if bufsize != 0: # <<<<<<<<<<<<<<
* raise ValueError("bufsize must be 0")
* if startupinfo is not None:
*/
__pyx_t_2 = PyObject_RichCompare(__pyx_cur_scope->__pyx_v_bufsize, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2149, __pyx_L1_error)
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 2149, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2150
* raise ValueError("universal_newlines must be False")
* if bufsize != 0:
* raise ValueError("bufsize must be 0") # <<<<<<<<<<<<<<
* if startupinfo is not None:
* raise ValueError('startupinfo is not supported')
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__90, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2150, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__PYX_ERR(1, 2150, __pyx_L1_error)
/* "uvloop/loop.pyx":2149
* if universal_newlines:
* raise ValueError("universal_newlines must be False")
* if bufsize != 0: # <<<<<<<<<<<<<<
* raise ValueError("bufsize must be 0")
* if startupinfo is not None:
*/
}
/* "uvloop/loop.pyx":2151
* if bufsize != 0:
* raise ValueError("bufsize must be 0")
* if startupinfo is not None: # <<<<<<<<<<<<<<
* raise ValueError('startupinfo is not supported')
* if creationflags != 0:
*/
__pyx_t_1 = (__pyx_cur_scope->__pyx_v_startupinfo != Py_None);
__pyx_t_3 = (__pyx_t_1 != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":2152
* raise ValueError("bufsize must be 0")
* if startupinfo is not None:
* raise ValueError('startupinfo is not supported') # <<<<<<<<<<<<<<
* if creationflags != 0:
* raise ValueError('creationflags is not supported')
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__91, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2152, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__PYX_ERR(1, 2152, __pyx_L1_error)
/* "uvloop/loop.pyx":2151
* if bufsize != 0:
* raise ValueError("bufsize must be 0")
* if startupinfo is not None: # <<<<<<<<<<<<<<
* raise ValueError('startupinfo is not supported')
* if creationflags != 0:
*/
}
/* "uvloop/loop.pyx":2153
* if startupinfo is not None:
* raise ValueError('startupinfo is not supported')
* if creationflags != 0: # <<<<<<<<<<<<<<
* raise ValueError('creationflags is not supported')
*
*/
__pyx_t_2 = PyObject_RichCompare(__pyx_cur_scope->__pyx_v_creationflags, __pyx_int_0, Py_NE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2153, __pyx_L1_error)
__pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(1, 2153, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
if (__pyx_t_3) {
/* "uvloop/loop.pyx":2154
* raise ValueError('startupinfo is not supported')
* if creationflags != 0:
* raise ValueError('creationflags is not supported') # <<<<<<<<<<<<<<
*
* if executable is not None:
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__92, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2154, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__PYX_ERR(1, 2154, __pyx_L1_error)
/* "uvloop/loop.pyx":2153
* if startupinfo is not None:
* raise ValueError('startupinfo is not supported')
* if creationflags != 0: # <<<<<<<<<<<<<<
* raise ValueError('creationflags is not supported')
*
*/
}
/* "uvloop/loop.pyx":2156
* raise ValueError('creationflags is not supported')
*
* if executable is not None: # <<<<<<<<<<<<<<
* args[0] = executable
*
*/
__pyx_t_3 = (__pyx_cur_scope->__pyx_v_executable != Py_None);
__pyx_t_1 = (__pyx_t_3 != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2157
*
* if executable is not None:
* args[0] = executable # <<<<<<<<<<<<<<
*
* if __uvloop_sleep_after_fork:
*/
if (unlikely(__Pyx_SetItemInt(__pyx_cur_scope->__pyx_v_args, 0, __pyx_cur_scope->__pyx_v_executable, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) __PYX_ERR(1, 2157, __pyx_L1_error)
/* "uvloop/loop.pyx":2156
* raise ValueError('creationflags is not supported')
*
* if executable is not None: # <<<<<<<<<<<<<<
* args[0] = executable
*
*/
}
/* "uvloop/loop.pyx":2159
* args[0] = executable
*
* if __uvloop_sleep_after_fork: # <<<<<<<<<<<<<<
* debug_flags |= __PROCESS_DEBUG_SLEEP_AFTER_FORK
*
*/
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v___uvloop_sleep_after_fork); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 2159, __pyx_L1_error)
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2160
*
* if __uvloop_sleep_after_fork:
* debug_flags |= __PROCESS_DEBUG_SLEEP_AFTER_FORK # <<<<<<<<<<<<<<
*
* waiter = self._new_future()
*/
__pyx_cur_scope->__pyx_v_debug_flags = (__pyx_cur_scope->__pyx_v_debug_flags | 1);
/* "uvloop/loop.pyx":2159
* args[0] = executable
*
* if __uvloop_sleep_after_fork: # <<<<<<<<<<<<<<
* debug_flags |= __PROCESS_DEBUG_SLEEP_AFTER_FORK
*
*/
}
/* "uvloop/loop.pyx":2162
* debug_flags |= __PROCESS_DEBUG_SLEEP_AFTER_FORK
*
* waiter = self._new_future() # <<<<<<<<<<<<<<
* protocol = protocol_factory()
* proc = UVProcessTransport.new(self, protocol,
*/
__pyx_t_2 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2162, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_2);
__pyx_cur_scope->__pyx_v_waiter = __pyx_t_2;
__pyx_t_2 = 0;
/* "uvloop/loop.pyx":2163
*
* waiter = self._new_future()
* protocol = protocol_factory() # <<<<<<<<<<<<<<
* proc = UVProcessTransport.new(self, protocol,
* args, env, cwd, start_new_session,
*/
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
__pyx_t_4 = __pyx_cur_scope->__pyx_v_protocol_factory; __pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (__pyx_t_5) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2163, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
__pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2163, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GIVEREF(__pyx_t_2);
__pyx_cur_scope->__pyx_v_protocol = __pyx_t_2;
__pyx_t_2 = 0;
/* "uvloop/loop.pyx":2168
* stdin, stdout, stderr, pass_fds,
* waiter,
* debug_flags, # <<<<<<<<<<<<<<
* preexec_fn,
* restore_signals)
*/
__pyx_t_2 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_debug_flags); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2168, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
/* "uvloop/loop.pyx":2164
* waiter = self._new_future()
* protocol = protocol_factory()
* proc = UVProcessTransport.new(self, protocol, # <<<<<<<<<<<<<<
* args, env, cwd, start_new_session,
* stdin, stdout, stderr, pass_fds,
*/
__pyx_t_4 = ((PyObject *)__pyx_f_6uvloop_4loop_18UVProcessTransport_new(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_protocol, __pyx_cur_scope->__pyx_v_args, __pyx_cur_scope->__pyx_v_env, __pyx_cur_scope->__pyx_v_cwd, __pyx_cur_scope->__pyx_v_start_new_session, __pyx_cur_scope->__pyx_v_stdin, __pyx_cur_scope->__pyx_v_stdout, __pyx_cur_scope->__pyx_v_stderr, __pyx_cur_scope->__pyx_v_pass_fds, __pyx_cur_scope->__pyx_v_waiter, __pyx_t_2, __pyx_cur_scope->__pyx_v_preexec_fn, __pyx_cur_scope->__pyx_v_restore_signals)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2164, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_GIVEREF(__pyx_t_4);
__pyx_cur_scope->__pyx_v_proc = ((struct __pyx_obj_6uvloop_4loop_UVProcessTransport *)__pyx_t_4);
__pyx_t_4 = 0;
/* "uvloop/loop.pyx":2172
* restore_signals)
*
* try: # <<<<<<<<<<<<<<
* await waiter
* except:
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8);
__Pyx_XGOTREF(__pyx_t_6);
__Pyx_XGOTREF(__pyx_t_7);
__Pyx_XGOTREF(__pyx_t_8);
/*try:*/ {
/* "uvloop/loop.pyx":2173
*
* try:
* await waiter # <<<<<<<<<<<<<<
* except:
* proc.close()
*/
__pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_waiter);
__Pyx_XGOTREF(__pyx_r);
if (likely(__pyx_r)) {
__Pyx_XGIVEREF(__pyx_t_6);
__pyx_cur_scope->__pyx_t_0 = __pyx_t_6;
__Pyx_XGIVEREF(__pyx_t_7);
__pyx_cur_scope->__pyx_t_1 = __pyx_t_7;
__Pyx_XGIVEREF(__pyx_t_8);
__pyx_cur_scope->__pyx_t_2 = __pyx_t_8;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
/* return from generator, yielding value */
__pyx_generator->resume_label = 1;
return __pyx_r;
__pyx_L18_resume_from_yield:;
__pyx_t_6 = __pyx_cur_scope->__pyx_t_0;
__pyx_cur_scope->__pyx_t_0 = 0;
__Pyx_XGOTREF(__pyx_t_6);
__pyx_t_7 = __pyx_cur_scope->__pyx_t_1;
__pyx_cur_scope->__pyx_t_1 = 0;
__Pyx_XGOTREF(__pyx_t_7);
__pyx_t_8 = __pyx_cur_scope->__pyx_t_2;
__pyx_cur_scope->__pyx_t_2 = 0;
__Pyx_XGOTREF(__pyx_t_8);
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 2173, __pyx_L10_error)
} else {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(1, 2173, __pyx_L10_error)
}
}
/* "uvloop/loop.pyx":2172
* restore_signals)
*
* try: # <<<<<<<<<<<<<<
* await waiter
* except:
*/
}
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
goto __pyx_L17_try_end;
__pyx_L10_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":2174
* try:
* await waiter
* except: # <<<<<<<<<<<<<<
* proc.close()
* raise
*/
/*except:*/ {
__Pyx_AddTraceback("uvloop.loop.Loop.__subprocess_run", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_2, &__pyx_t_5) < 0) __PYX_ERR(1, 2174, __pyx_L12_except_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GOTREF(__pyx_t_5);
/* "uvloop/loop.pyx":2175
* await waiter
* except:
* proc.close() # <<<<<<<<<<<<<<
* raise
*
*/
__pyx_t_10 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_proc), __pyx_n_s_close); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 2175, __pyx_L12_except_error)
__Pyx_GOTREF(__pyx_t_10);
__pyx_t_11 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) {
__pyx_t_11 = PyMethod_GET_SELF(__pyx_t_10);
if (likely(__pyx_t_11)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
__Pyx_INCREF(__pyx_t_11);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_10, function);
}
}
if (__pyx_t_11) {
__pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_t_11); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 2175, __pyx_L12_except_error)
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
} else {
__pyx_t_9 = __Pyx_PyObject_CallNoArg(__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 2175, __pyx_L12_except_error)
}
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
/* "uvloop/loop.pyx":2176
* except:
* proc.close()
* raise # <<<<<<<<<<<<<<
*
* return proc, protocol
*/
__Pyx_GIVEREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_2);
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_ErrRestoreWithState(__pyx_t_4, __pyx_t_2, __pyx_t_5);
__pyx_t_4 = 0; __pyx_t_2 = 0; __pyx_t_5 = 0;
__PYX_ERR(1, 2176, __pyx_L12_except_error)
}
__pyx_L12_except_error:;
/* "uvloop/loop.pyx":2172
* restore_signals)
*
* try: # <<<<<<<<<<<<<<
* await waiter
* except:
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8);
goto __pyx_L1_error;
__pyx_L17_try_end:;
}
/* "uvloop/loop.pyx":2178
* raise
*
* return proc, protocol # <<<<<<<<<<<<<<
*
* def subprocess_shell(self, protocol_factory, cmd, *,
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2178, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_proc));
__Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_proc));
PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)__pyx_cur_scope->__pyx_v_proc));
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol);
PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_cur_scope->__pyx_v_protocol);
__pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_5 = 0;
goto __pyx_L0;
CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
/* "uvloop/loop.pyx":2119
* self._default_executor = executor
*
* async def __subprocess_run(self, protocol_factory, args, # <<<<<<<<<<<<<<
* stdin=subprocess_PIPE,
* stdout=subprocess_PIPE,
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_9);
__Pyx_XDECREF(__pyx_t_10);
__Pyx_XDECREF(__pyx_t_11);
__Pyx_AddTraceback("__subprocess_run", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_L0:;
__Pyx_XDECREF(__pyx_r); __pyx_r = 0;
__pyx_generator->resume_label = -1;
__Pyx_Coroutine_clear((PyObject*)__pyx_generator);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":2180
* return proc, protocol
*
* def subprocess_shell(self, protocol_factory, cmd, *, # <<<<<<<<<<<<<<
* shell=True,
* **kwargs):
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_100subprocess_shell(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_99subprocess_shell[] = "Loop.subprocess_shell(self, protocol_factory, cmd, *, shell=True, **kwargs)";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_100subprocess_shell(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_protocol_factory = 0;
PyObject *__pyx_v_cmd = 0;
PyObject *__pyx_v_shell = 0;
PyObject *__pyx_v_kwargs = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("subprocess_shell (wrapper)", 0);
__pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL;
__Pyx_GOTREF(__pyx_v_kwargs);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_protocol_factory,&__pyx_n_s_cmd,&__pyx_n_s_shell,0};
PyObject* values[3] = {0,0,0};
/* "uvloop/loop.pyx":2181
*
* def subprocess_shell(self, protocol_factory, cmd, *,
* shell=True, # <<<<<<<<<<<<<<
* **kwargs):
*
*/
values[2] = ((PyObject *)Py_True);
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_protocol_factory)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_cmd)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("subprocess_shell", 1, 2, 2, 1); __PYX_ERR(1, 2180, __pyx_L3_error)
}
}
if (kw_args == 1) {
const Py_ssize_t index = 2;
PyObject* value = PyDict_GetItem(__pyx_kwds, *__pyx_pyargnames[index]);
if (value) { values[index] = value; kw_args--; }
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, pos_args, "subprocess_shell") < 0)) __PYX_ERR(1, 2180, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
}
__pyx_v_protocol_factory = values[0];
__pyx_v_cmd = values[1];
__pyx_v_shell = values[2];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("subprocess_shell", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2180, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
__Pyx_AddTraceback("uvloop.loop.Loop.subprocess_shell", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_99subprocess_shell(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_protocol_factory, __pyx_v_cmd, __pyx_v_shell, __pyx_v_kwargs);
/* "uvloop/loop.pyx":2180
* return proc, protocol
*
* def subprocess_shell(self, protocol_factory, cmd, *, # <<<<<<<<<<<<<<
* shell=True,
* **kwargs):
*/
/* function exit code */
__Pyx_XDECREF(__pyx_v_kwargs);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_99subprocess_shell(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_cmd, PyObject *__pyx_v_shell, PyObject *__pyx_v_kwargs) {
PyObject *__pyx_v_args = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
__Pyx_RefNannySetupContext("subprocess_shell", 0);
/* "uvloop/loop.pyx":2184
* **kwargs):
*
* if not shell: # <<<<<<<<<<<<<<
* raise ValueError("shell must be True")
*
*/
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_shell); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 2184, __pyx_L1_error)
__pyx_t_2 = ((!__pyx_t_1) != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":2185
*
* if not shell:
* raise ValueError("shell must be True") # <<<<<<<<<<<<<<
*
* args = [cmd]
*/
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__93, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2185, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 2185, __pyx_L1_error)
/* "uvloop/loop.pyx":2184
* **kwargs):
*
* if not shell: # <<<<<<<<<<<<<<
* raise ValueError("shell must be True")
*
*/
}
/* "uvloop/loop.pyx":2187
* raise ValueError("shell must be True")
*
* args = [cmd] # <<<<<<<<<<<<<<
* if shell:
* args = [b'/bin/sh', b'-c'] + args
*/
__pyx_t_3 = PyList_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2187, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_v_cmd);
__Pyx_GIVEREF(__pyx_v_cmd);
PyList_SET_ITEM(__pyx_t_3, 0, __pyx_v_cmd);
__pyx_v_args = ((PyObject*)__pyx_t_3);
__pyx_t_3 = 0;
/* "uvloop/loop.pyx":2188
*
* args = [cmd]
* if shell: # <<<<<<<<<<<<<<
* args = [b'/bin/sh', b'-c'] + args
*
*/
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_shell); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 2188, __pyx_L1_error)
if (__pyx_t_2) {
/* "uvloop/loop.pyx":2189
* args = [cmd]
* if shell:
* args = [b'/bin/sh', b'-c'] + args # <<<<<<<<<<<<<<
*
* return self.__subprocess_run(protocol_factory, args, shell=True,
*/
__pyx_t_3 = PyList_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2189, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_kp_b_bin_sh);
__Pyx_GIVEREF(__pyx_kp_b_bin_sh);
PyList_SET_ITEM(__pyx_t_3, 0, __pyx_kp_b_bin_sh);
__Pyx_INCREF(__pyx_kp_b_c);
__Pyx_GIVEREF(__pyx_kp_b_c);
PyList_SET_ITEM(__pyx_t_3, 1, __pyx_kp_b_c);
__pyx_t_4 = PyNumber_Add(__pyx_t_3, __pyx_v_args); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2189, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF_SET(__pyx_v_args, ((PyObject*)__pyx_t_4));
__pyx_t_4 = 0;
/* "uvloop/loop.pyx":2188
*
* args = [cmd]
* if shell: # <<<<<<<<<<<<<<
* args = [b'/bin/sh', b'-c'] + args
*
*/
}
/* "uvloop/loop.pyx":2191
* args = [b'/bin/sh', b'-c'] + args
*
* return self.__subprocess_run(protocol_factory, args, shell=True, # <<<<<<<<<<<<<<
* **kwargs)
*
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_subprocess_run); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2191, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2191, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_v_protocol_factory);
__Pyx_GIVEREF(__pyx_v_protocol_factory);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_protocol_factory);
__Pyx_INCREF(__pyx_v_args);
__Pyx_GIVEREF(__pyx_v_args);
PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_args);
__pyx_t_6 = PyDict_New(); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2191, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_shell, Py_True) < 0) __PYX_ERR(1, 2191, __pyx_L1_error)
__pyx_t_5 = __pyx_t_6;
__pyx_t_6 = 0;
/* "uvloop/loop.pyx":2192
*
* return self.__subprocess_run(protocol_factory, args, shell=True,
* **kwargs) # <<<<<<<<<<<<<<
*
* def subprocess_exec(self, protocol_factory, program, *args,
*/
if (__Pyx_MergeKeywords(__pyx_t_5, __pyx_v_kwargs) < 0) __PYX_ERR(1, 2192, __pyx_L1_error)
/* "uvloop/loop.pyx":2191
* args = [b'/bin/sh', b'-c'] + args
*
* return self.__subprocess_run(protocol_factory, args, shell=True, # <<<<<<<<<<<<<<
* **kwargs)
*
*/
__pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2191, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_r = __pyx_t_6;
__pyx_t_6 = 0;
goto __pyx_L0;
/* "uvloop/loop.pyx":2180
* return proc, protocol
*
* def subprocess_shell(self, protocol_factory, cmd, *, # <<<<<<<<<<<<<<
* shell=True,
* **kwargs):
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_AddTraceback("uvloop.loop.Loop.subprocess_shell", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_args);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":2194
* **kwargs)
*
* def subprocess_exec(self, protocol_factory, program, *args, # <<<<<<<<<<<<<<
* shell=False, **kwargs):
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_102subprocess_exec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_101subprocess_exec[] = "Loop.subprocess_exec(self, protocol_factory, program, *args, shell=False, **kwargs)";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_102subprocess_exec(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_protocol_factory = 0;
PyObject *__pyx_v_program = 0;
PyObject *__pyx_v_shell = 0;
PyObject *__pyx_v_args = 0;
PyObject *__pyx_v_kwargs = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("subprocess_exec (wrapper)", 0);
__pyx_v_kwargs = PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL;
__Pyx_GOTREF(__pyx_v_kwargs);
if (PyTuple_GET_SIZE(__pyx_args) > 2) {
__pyx_v_args = PyTuple_GetSlice(__pyx_args, 2, PyTuple_GET_SIZE(__pyx_args));
if (unlikely(!__pyx_v_args)) {
__Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
__Pyx_RefNannyFinishContext();
return NULL;
}
__Pyx_GOTREF(__pyx_v_args);
} else {
__pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple);
}
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_protocol_factory,&__pyx_n_s_program,&__pyx_n_s_shell,0};
PyObject* values[3] = {0,0,0};
/* "uvloop/loop.pyx":2195
*
* def subprocess_exec(self, protocol_factory, program, *args,
* shell=False, **kwargs): # <<<<<<<<<<<<<<
*
* if shell:
*/
values[2] = ((PyObject *)Py_False);
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
default:
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
case 0: break;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_protocol_factory)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_program)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("subprocess_exec", 0, 2, 2, 1); __PYX_ERR(1, 2194, __pyx_L3_error)
}
}
if (kw_args == 1) {
const Py_ssize_t index = 2;
PyObject* value = PyDict_GetItem(__pyx_kwds, *__pyx_pyargnames[index]);
if (value) { values[index] = value; kw_args--; }
}
if (unlikely(kw_args > 0)) {
const Py_ssize_t used_pos_args = (pos_args < 2) ? pos_args : 2;
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, __pyx_v_kwargs, values, used_pos_args, "subprocess_exec") < 0)) __PYX_ERR(1, 2194, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) < 2) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
}
__pyx_v_protocol_factory = values[0];
__pyx_v_program = values[1];
__pyx_v_shell = values[2];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("subprocess_exec", 0, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2194, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0;
__Pyx_DECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0;
__Pyx_AddTraceback("uvloop.loop.Loop.subprocess_exec", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_101subprocess_exec(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_protocol_factory, __pyx_v_program, __pyx_v_shell, __pyx_v_args, __pyx_v_kwargs);
/* "uvloop/loop.pyx":2194
* **kwargs)
*
* def subprocess_exec(self, protocol_factory, program, *args, # <<<<<<<<<<<<<<
* shell=False, **kwargs):
*
*/
/* function exit code */
__Pyx_XDECREF(__pyx_v_args);
__Pyx_XDECREF(__pyx_v_kwargs);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_101subprocess_exec(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_program, PyObject *__pyx_v_shell, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
__Pyx_RefNannySetupContext("subprocess_exec", 0);
__Pyx_INCREF(__pyx_v_args);
/* "uvloop/loop.pyx":2197
* shell=False, **kwargs):
*
* if shell: # <<<<<<<<<<<<<<
* raise ValueError("shell must be False")
*
*/
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_shell); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 2197, __pyx_L1_error)
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2198
*
* if shell:
* raise ValueError("shell must be False") # <<<<<<<<<<<<<<
*
* args = list((program,) + args)
*/
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__94, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2198, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_Raise(__pyx_t_2, 0, 0, 0);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__PYX_ERR(1, 2198, __pyx_L1_error)
/* "uvloop/loop.pyx":2197
* shell=False, **kwargs):
*
* if shell: # <<<<<<<<<<<<<<
* raise ValueError("shell must be False")
*
*/
}
/* "uvloop/loop.pyx":2200
* raise ValueError("shell must be False")
*
* args = list((program,) + args) # <<<<<<<<<<<<<<
*
* return self.__subprocess_run(protocol_factory, args, shell=False,
*/
__pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2200, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_INCREF(__pyx_v_program);
__Pyx_GIVEREF(__pyx_v_program);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_program);
__pyx_t_3 = PyNumber_Add(__pyx_t_2, __pyx_v_args); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2200, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_2 = PySequence_List(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2200, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF_SET(__pyx_v_args, __pyx_t_2);
__pyx_t_2 = 0;
/* "uvloop/loop.pyx":2202
* args = list((program,) + args)
*
* return self.__subprocess_run(protocol_factory, args, shell=False, # <<<<<<<<<<<<<<
* **kwargs)
*
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_subprocess_run); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2202, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2202, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_v_protocol_factory);
__Pyx_GIVEREF(__pyx_v_protocol_factory);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_protocol_factory);
__Pyx_INCREF(__pyx_v_args);
__Pyx_GIVEREF(__pyx_v_args);
PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_args);
__pyx_t_5 = PyDict_New(); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2202, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
if (PyDict_SetItem(__pyx_t_5, __pyx_n_s_shell, Py_False) < 0) __PYX_ERR(1, 2202, __pyx_L1_error)
__pyx_t_4 = __pyx_t_5;
__pyx_t_5 = 0;
/* "uvloop/loop.pyx":2203
*
* return self.__subprocess_run(protocol_factory, args, shell=False,
* **kwargs) # <<<<<<<<<<<<<<
*
* async def connect_read_pipe(self, proto_factory, pipe):
*/
if (__Pyx_MergeKeywords(__pyx_t_4, __pyx_v_kwargs) < 0) __PYX_ERR(1, 2203, __pyx_L1_error)
/* "uvloop/loop.pyx":2202
* args = list((program,) + args)
*
* return self.__subprocess_run(protocol_factory, args, shell=False, # <<<<<<<<<<<<<<
* **kwargs)
*
*/
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2202, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_r = __pyx_t_5;
__pyx_t_5 = 0;
goto __pyx_L0;
/* "uvloop/loop.pyx":2194
* **kwargs)
*
* def subprocess_exec(self, protocol_factory, program, *args, # <<<<<<<<<<<<<<
* shell=False, **kwargs):
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("uvloop.loop.Loop.subprocess_exec", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_args);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_105generator9(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */
/* "uvloop/loop.pyx":2205
* **kwargs)
*
* async def connect_read_pipe(self, proto_factory, pipe): # <<<<<<<<<<<<<<
* """Register read pipe in event loop. Set the pipe to non-blocking mode.
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_104connect_read_pipe(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_103connect_read_pipe[] = "Loop.connect_read_pipe(self, proto_factory, pipe)\nRegister read pipe in event loop. Set the pipe to non-blocking mode.\n\n protocol_factory should instantiate object with Protocol interface.\n pipe is a file-like object.\n Return pair (transport, protocol), where transport supports the\n ReadTransport interface.";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_104connect_read_pipe(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_proto_factory = 0;
PyObject *__pyx_v_pipe = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("connect_read_pipe (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_proto_factory,&__pyx_n_s_pipe,0};
PyObject* values[2] = {0,0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_proto_factory)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pipe)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("connect_read_pipe", 1, 2, 2, 1); __PYX_ERR(1, 2205, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "connect_read_pipe") < 0)) __PYX_ERR(1, 2205, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
}
__pyx_v_proto_factory = values[0];
__pyx_v_pipe = values[1];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("connect_read_pipe", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2205, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.connect_read_pipe", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_103connect_read_pipe(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_proto_factory, __pyx_v_pipe);
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_103connect_read_pipe(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_proto_factory, PyObject *__pyx_v_pipe) {
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_15_connect_read_pipe *__pyx_cur_scope;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("connect_read_pipe", 0);
__pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_15_connect_read_pipe *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_15_connect_read_pipe(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_15_connect_read_pipe, __pyx_empty_tuple, NULL);
if (unlikely(!__pyx_cur_scope)) {
__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_15_connect_read_pipe *)Py_None);
__Pyx_INCREF(Py_None);
__PYX_ERR(1, 2205, __pyx_L1_error)
} else {
__Pyx_GOTREF(__pyx_cur_scope);
}
__pyx_cur_scope->__pyx_v_self = __pyx_v_self;
__Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__pyx_cur_scope->__pyx_v_proto_factory = __pyx_v_proto_factory;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_proto_factory);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_proto_factory);
__pyx_cur_scope->__pyx_v_pipe = __pyx_v_pipe;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_pipe);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_pipe);
{
__pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_105generator9, (PyObject *) __pyx_cur_scope, __pyx_n_s_connect_read_pipe, __pyx_n_s_Loop_connect_read_pipe, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(1, 2205, __pyx_L1_error)
__Pyx_DECREF(__pyx_cur_scope);
__Pyx_RefNannyFinishContext();
return (PyObject *) gen;
}
/* function exit code */
__pyx_L1_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.connect_read_pipe", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__Pyx_DECREF(((PyObject *)__pyx_cur_scope));
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_105generator9(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */
{
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_15_connect_read_pipe *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_15_connect_read_pipe *)__pyx_generator->closure);
PyObject *__pyx_r = NULL;
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_t_6;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
PyObject *__pyx_t_10 = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("None", 0);
switch (__pyx_generator->resume_label) {
case 0: goto __pyx_L3_first_run;
case 1: goto __pyx_L12_resume_from_yield;
default: /* CPython raises the right error here */
__Pyx_RefNannyFinishContext();
return NULL;
}
__pyx_L3_first_run:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 2205, __pyx_L1_error)
/* "uvloop/loop.pyx":2215
* ReadUnixTransport transp
* # See a comment on os_dup in create_connection
* int fileno = os_dup(pipe.fileno()) # <<<<<<<<<<<<<<
*
* waiter = self._new_future()
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_pipe, __pyx_n_s_fileno); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2215, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (__pyx_t_4) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2215, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
__pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2215, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_INCREF(__pyx_v_6uvloop_4loop_os_dup);
__pyx_t_3 = __pyx_v_6uvloop_4loop_os_dup; __pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (!__pyx_t_4) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2215, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2};
__pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2215, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2};
__pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2215, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
} else
#endif
{
__pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2215, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_2);
__pyx_t_2 = 0;
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2215, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 2215, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_cur_scope->__pyx_v_fileno = __pyx_t_6;
/* "uvloop/loop.pyx":2217
* int fileno = os_dup(pipe.fileno())
*
* waiter = self._new_future() # <<<<<<<<<<<<<<
* proto = proto_factory()
* transp = ReadUnixTransport.new(self, proto, None, waiter)
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2217, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
__pyx_cur_scope->__pyx_v_waiter = __pyx_t_1;
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":2218
*
* waiter = self._new_future()
* proto = proto_factory() # <<<<<<<<<<<<<<
* transp = ReadUnixTransport.new(self, proto, None, waiter)
* transp._add_extra_info('pipe', pipe)
*/
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_proto_factory);
__pyx_t_3 = __pyx_cur_scope->__pyx_v_proto_factory; __pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (__pyx_t_5) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2218, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2218, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GIVEREF(__pyx_t_1);
__pyx_cur_scope->__pyx_v_proto = __pyx_t_1;
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":2219
* waiter = self._new_future()
* proto = proto_factory()
* transp = ReadUnixTransport.new(self, proto, None, waiter) # <<<<<<<<<<<<<<
* transp._add_extra_info('pipe', pipe)
* transp._attach_fileobj(pipe)
*/
__pyx_t_1 = ((PyObject *)__pyx_f_6uvloop_4loop_17ReadUnixTransport_new(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_proto, ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None), __pyx_cur_scope->__pyx_v_waiter)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2219, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
__pyx_cur_scope->__pyx_v_transp = ((struct __pyx_obj_6uvloop_4loop_ReadUnixTransport *)__pyx_t_1);
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":2220
* proto = proto_factory()
* transp = ReadUnixTransport.new(self, proto, None, waiter)
* transp._add_extra_info('pipe', pipe) # <<<<<<<<<<<<<<
* transp._attach_fileobj(pipe)
* try:
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_ReadUnixTransport *)__pyx_cur_scope->__pyx_v_transp->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._add_extra_info(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_cur_scope->__pyx_v_transp), __pyx_n_u_pipe, __pyx_cur_scope->__pyx_v_pipe); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2220, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":2221
* transp = ReadUnixTransport.new(self, proto, None, waiter)
* transp._add_extra_info('pipe', pipe)
* transp._attach_fileobj(pipe) # <<<<<<<<<<<<<<
* try:
* transp._open(fileno)
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_ReadUnixTransport *)__pyx_cur_scope->__pyx_v_transp->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._attach_fileobj(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_transp), __pyx_cur_scope->__pyx_v_pipe); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2221, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":2222
* transp._add_extra_info('pipe', pipe)
* transp._attach_fileobj(pipe)
* try: # <<<<<<<<<<<<<<
* transp._open(fileno)
* transp._init_protocol()
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9);
__Pyx_XGOTREF(__pyx_t_7);
__Pyx_XGOTREF(__pyx_t_8);
__Pyx_XGOTREF(__pyx_t_9);
/*try:*/ {
/* "uvloop/loop.pyx":2223
* transp._attach_fileobj(pipe)
* try:
* transp._open(fileno) # <<<<<<<<<<<<<<
* transp._init_protocol()
* await waiter
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_ReadUnixTransport *)__pyx_cur_scope->__pyx_v_transp->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._open(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_transp), __pyx_cur_scope->__pyx_v_fileno); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2223, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":2224
* try:
* transp._open(fileno)
* transp._init_protocol() # <<<<<<<<<<<<<<
* await waiter
* except:
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_ReadUnixTransport *)__pyx_cur_scope->__pyx_v_transp->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._init_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_cur_scope->__pyx_v_transp)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2224, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":2225
* transp._open(fileno)
* transp._init_protocol()
* await waiter # <<<<<<<<<<<<<<
* except:
* transp.close()
*/
__pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_waiter);
__Pyx_XGOTREF(__pyx_r);
if (likely(__pyx_r)) {
__Pyx_XGIVEREF(__pyx_t_7);
__pyx_cur_scope->__pyx_t_0 = __pyx_t_7;
__Pyx_XGIVEREF(__pyx_t_8);
__pyx_cur_scope->__pyx_t_1 = __pyx_t_8;
__Pyx_XGIVEREF(__pyx_t_9);
__pyx_cur_scope->__pyx_t_2 = __pyx_t_9;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
/* return from generator, yielding value */
__pyx_generator->resume_label = 1;
return __pyx_r;
__pyx_L12_resume_from_yield:;
__pyx_t_7 = __pyx_cur_scope->__pyx_t_0;
__pyx_cur_scope->__pyx_t_0 = 0;
__Pyx_XGOTREF(__pyx_t_7);
__pyx_t_8 = __pyx_cur_scope->__pyx_t_1;
__pyx_cur_scope->__pyx_t_1 = 0;
__Pyx_XGOTREF(__pyx_t_8);
__pyx_t_9 = __pyx_cur_scope->__pyx_t_2;
__pyx_cur_scope->__pyx_t_2 = 0;
__Pyx_XGOTREF(__pyx_t_9);
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 2225, __pyx_L4_error)
} else {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(1, 2225, __pyx_L4_error)
}
}
/* "uvloop/loop.pyx":2222
* transp._add_extra_info('pipe', pipe)
* transp._attach_fileobj(pipe)
* try: # <<<<<<<<<<<<<<
* transp._open(fileno)
* transp._init_protocol()
*/
}
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
goto __pyx_L11_try_end;
__pyx_L4_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":2226
* transp._init_protocol()
* await waiter
* except: # <<<<<<<<<<<<<<
* transp.close()
* raise
*/
/*except:*/ {
__Pyx_AddTraceback("uvloop.loop.Loop.connect_read_pipe", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_3, &__pyx_t_5) < 0) __PYX_ERR(1, 2226, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GOTREF(__pyx_t_5);
/* "uvloop/loop.pyx":2227
* await waiter
* except:
* transp.close() # <<<<<<<<<<<<<<
* raise
* return transp, proto
*/
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_transp), __pyx_n_s_close); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2227, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_10 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_10 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_10)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_10);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (__pyx_t_10) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2227, __pyx_L6_except_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
} else {
__pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2227, __pyx_L6_except_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":2228
* except:
* transp.close()
* raise # <<<<<<<<<<<<<<
* return transp, proto
*
*/
__Pyx_GIVEREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_3);
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_ErrRestoreWithState(__pyx_t_1, __pyx_t_3, __pyx_t_5);
__pyx_t_1 = 0; __pyx_t_3 = 0; __pyx_t_5 = 0;
__PYX_ERR(1, 2228, __pyx_L6_except_error)
}
__pyx_L6_except_error:;
/* "uvloop/loop.pyx":2222
* transp._add_extra_info('pipe', pipe)
* transp._attach_fileobj(pipe)
* try: # <<<<<<<<<<<<<<
* transp._open(fileno)
* transp._init_protocol()
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9);
goto __pyx_L1_error;
__pyx_L11_try_end:;
}
/* "uvloop/loop.pyx":2229
* transp.close()
* raise
* return transp, proto # <<<<<<<<<<<<<<
*
* async def connect_write_pipe(self, proto_factory, pipe):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2229, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_transp));
__Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_transp));
PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)__pyx_cur_scope->__pyx_v_transp));
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_proto);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_proto);
PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_cur_scope->__pyx_v_proto);
__pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_5 = 0;
goto __pyx_L0;
CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
/* "uvloop/loop.pyx":2205
* **kwargs)
*
* async def connect_read_pipe(self, proto_factory, pipe): # <<<<<<<<<<<<<<
* """Register read pipe in event loop. Set the pipe to non-blocking mode.
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_10);
__Pyx_AddTraceback("connect_read_pipe", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_L0:;
__Pyx_XDECREF(__pyx_r); __pyx_r = 0;
__pyx_generator->resume_label = -1;
__Pyx_Coroutine_clear((PyObject*)__pyx_generator);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_108generator10(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */
/* "uvloop/loop.pyx":2231
* return transp, proto
*
* async def connect_write_pipe(self, proto_factory, pipe): # <<<<<<<<<<<<<<
* """Register write pipe in event loop.
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_107connect_write_pipe(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_106connect_write_pipe[] = "Loop.connect_write_pipe(self, proto_factory, pipe)\nRegister write pipe in event loop.\n\n protocol_factory should instantiate object with BaseProtocol interface.\n Pipe is file-like object already switched to nonblocking.\n Return pair (transport, protocol), where transport support\n WriteTransport interface.";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_107connect_write_pipe(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_proto_factory = 0;
PyObject *__pyx_v_pipe = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("connect_write_pipe (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_proto_factory,&__pyx_n_s_pipe,0};
PyObject* values[2] = {0,0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_proto_factory)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pipe)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("connect_write_pipe", 1, 2, 2, 1); __PYX_ERR(1, 2231, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "connect_write_pipe") < 0)) __PYX_ERR(1, 2231, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) != 2) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
}
__pyx_v_proto_factory = values[0];
__pyx_v_pipe = values[1];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("connect_write_pipe", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2231, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.connect_write_pipe", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_106connect_write_pipe(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_proto_factory, __pyx_v_pipe);
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_106connect_write_pipe(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_proto_factory, PyObject *__pyx_v_pipe) {
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_16_connect_write_pipe *__pyx_cur_scope;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("connect_write_pipe", 0);
__pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_16_connect_write_pipe *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_16_connect_write_pipe(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_16_connect_write_pipe, __pyx_empty_tuple, NULL);
if (unlikely(!__pyx_cur_scope)) {
__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_16_connect_write_pipe *)Py_None);
__Pyx_INCREF(Py_None);
__PYX_ERR(1, 2231, __pyx_L1_error)
} else {
__Pyx_GOTREF(__pyx_cur_scope);
}
__pyx_cur_scope->__pyx_v_self = __pyx_v_self;
__Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__pyx_cur_scope->__pyx_v_proto_factory = __pyx_v_proto_factory;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_proto_factory);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_proto_factory);
__pyx_cur_scope->__pyx_v_pipe = __pyx_v_pipe;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_pipe);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_pipe);
{
__pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_108generator10, (PyObject *) __pyx_cur_scope, __pyx_n_s_connect_write_pipe, __pyx_n_s_Loop_connect_write_pipe, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(1, 2231, __pyx_L1_error)
__Pyx_DECREF(__pyx_cur_scope);
__Pyx_RefNannyFinishContext();
return (PyObject *) gen;
}
/* function exit code */
__pyx_L1_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.connect_write_pipe", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__Pyx_DECREF(((PyObject *)__pyx_cur_scope));
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_108generator10(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */
{
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_16_connect_write_pipe *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_16_connect_write_pipe *)__pyx_generator->closure);
PyObject *__pyx_r = NULL;
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
int __pyx_t_6;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
PyObject *__pyx_t_10 = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("None", 0);
switch (__pyx_generator->resume_label) {
case 0: goto __pyx_L3_first_run;
case 1: goto __pyx_L12_resume_from_yield;
default: /* CPython raises the right error here */
__Pyx_RefNannyFinishContext();
return NULL;
}
__pyx_L3_first_run:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 2231, __pyx_L1_error)
/* "uvloop/loop.pyx":2241
* WriteUnixTransport transp
* # See a comment on os_dup in create_connection
* int fileno = os_dup(pipe.fileno()) # <<<<<<<<<<<<<<
*
* waiter = self._new_future()
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_pipe, __pyx_n_s_fileno); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2241, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (__pyx_t_4) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2241, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
__pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2241, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_INCREF(__pyx_v_6uvloop_4loop_os_dup);
__pyx_t_3 = __pyx_v_6uvloop_4loop_os_dup; __pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (!__pyx_t_4) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2241, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2};
__pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2241, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_t_2};
__pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2241, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
} else
#endif
{
__pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2241, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_2);
__pyx_t_2 = 0;
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2241, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_6 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 2241, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_cur_scope->__pyx_v_fileno = __pyx_t_6;
/* "uvloop/loop.pyx":2243
* int fileno = os_dup(pipe.fileno())
*
* waiter = self._new_future() # <<<<<<<<<<<<<<
* proto = proto_factory()
* transp = WriteUnixTransport.new(self, proto, None, waiter)
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2243, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
__pyx_cur_scope->__pyx_v_waiter = __pyx_t_1;
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":2244
*
* waiter = self._new_future()
* proto = proto_factory() # <<<<<<<<<<<<<<
* transp = WriteUnixTransport.new(self, proto, None, waiter)
* transp._add_extra_info('pipe', pipe)
*/
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_proto_factory);
__pyx_t_3 = __pyx_cur_scope->__pyx_v_proto_factory; __pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (__pyx_t_5) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2244, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2244, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GIVEREF(__pyx_t_1);
__pyx_cur_scope->__pyx_v_proto = __pyx_t_1;
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":2245
* waiter = self._new_future()
* proto = proto_factory()
* transp = WriteUnixTransport.new(self, proto, None, waiter) # <<<<<<<<<<<<<<
* transp._add_extra_info('pipe', pipe)
* transp._attach_fileobj(pipe)
*/
__pyx_t_1 = ((PyObject *)__pyx_f_6uvloop_4loop_18WriteUnixTransport_new(__pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_proto, ((struct __pyx_obj_6uvloop_4loop_Server *)Py_None), __pyx_cur_scope->__pyx_v_waiter)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2245, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_1);
__pyx_cur_scope->__pyx_v_transp = ((struct __pyx_obj_6uvloop_4loop_WriteUnixTransport *)__pyx_t_1);
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":2246
* proto = proto_factory()
* transp = WriteUnixTransport.new(self, proto, None, waiter)
* transp._add_extra_info('pipe', pipe) # <<<<<<<<<<<<<<
* transp._attach_fileobj(pipe)
* try:
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_WriteUnixTransport *)__pyx_cur_scope->__pyx_v_transp->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._add_extra_info(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_cur_scope->__pyx_v_transp), __pyx_n_u_pipe, __pyx_cur_scope->__pyx_v_pipe); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2246, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":2247
* transp = WriteUnixTransport.new(self, proto, None, waiter)
* transp._add_extra_info('pipe', pipe)
* transp._attach_fileobj(pipe) # <<<<<<<<<<<<<<
* try:
* transp._open(fileno)
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_WriteUnixTransport *)__pyx_cur_scope->__pyx_v_transp->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._attach_fileobj(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_transp), __pyx_cur_scope->__pyx_v_pipe); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2247, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":2248
* transp._add_extra_info('pipe', pipe)
* transp._attach_fileobj(pipe)
* try: # <<<<<<<<<<<<<<
* transp._open(fileno)
* transp._init_protocol()
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9);
__Pyx_XGOTREF(__pyx_t_7);
__Pyx_XGOTREF(__pyx_t_8);
__Pyx_XGOTREF(__pyx_t_9);
/*try:*/ {
/* "uvloop/loop.pyx":2249
* transp._attach_fileobj(pipe)
* try:
* transp._open(fileno) # <<<<<<<<<<<<<<
* transp._init_protocol()
* await waiter
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_WriteUnixTransport *)__pyx_cur_scope->__pyx_v_transp->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base.__pyx_base._open(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_transp), __pyx_cur_scope->__pyx_v_fileno); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2249, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":2250
* try:
* transp._open(fileno)
* transp._init_protocol() # <<<<<<<<<<<<<<
* await waiter
* except:
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_WriteUnixTransport *)__pyx_cur_scope->__pyx_v_transp->__pyx_base.__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._init_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_cur_scope->__pyx_v_transp)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2250, __pyx_L4_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":2251
* transp._open(fileno)
* transp._init_protocol()
* await waiter # <<<<<<<<<<<<<<
* except:
* transp.close()
*/
__pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_waiter);
__Pyx_XGOTREF(__pyx_r);
if (likely(__pyx_r)) {
__Pyx_XGIVEREF(__pyx_t_7);
__pyx_cur_scope->__pyx_t_0 = __pyx_t_7;
__Pyx_XGIVEREF(__pyx_t_8);
__pyx_cur_scope->__pyx_t_1 = __pyx_t_8;
__Pyx_XGIVEREF(__pyx_t_9);
__pyx_cur_scope->__pyx_t_2 = __pyx_t_9;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
/* return from generator, yielding value */
__pyx_generator->resume_label = 1;
return __pyx_r;
__pyx_L12_resume_from_yield:;
__pyx_t_7 = __pyx_cur_scope->__pyx_t_0;
__pyx_cur_scope->__pyx_t_0 = 0;
__Pyx_XGOTREF(__pyx_t_7);
__pyx_t_8 = __pyx_cur_scope->__pyx_t_1;
__pyx_cur_scope->__pyx_t_1 = 0;
__Pyx_XGOTREF(__pyx_t_8);
__pyx_t_9 = __pyx_cur_scope->__pyx_t_2;
__pyx_cur_scope->__pyx_t_2 = 0;
__Pyx_XGOTREF(__pyx_t_9);
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 2251, __pyx_L4_error)
} else {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(1, 2251, __pyx_L4_error)
}
}
/* "uvloop/loop.pyx":2248
* transp._add_extra_info('pipe', pipe)
* transp._attach_fileobj(pipe)
* try: # <<<<<<<<<<<<<<
* transp._open(fileno)
* transp._init_protocol()
*/
}
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
goto __pyx_L11_try_end;
__pyx_L4_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":2252
* transp._init_protocol()
* await waiter
* except: # <<<<<<<<<<<<<<
* transp.close()
* raise
*/
/*except:*/ {
__Pyx_AddTraceback("uvloop.loop.Loop.connect_write_pipe", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_3, &__pyx_t_5) < 0) __PYX_ERR(1, 2252, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GOTREF(__pyx_t_5);
/* "uvloop/loop.pyx":2253
* await waiter
* except:
* transp.close() # <<<<<<<<<<<<<<
* raise
* return transp, proto
*/
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_transp), __pyx_n_s_close); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2253, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_10 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_10 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_10)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_10);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (__pyx_t_10) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_10); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2253, __pyx_L6_except_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
} else {
__pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2253, __pyx_L6_except_error)
}
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/loop.pyx":2254
* except:
* transp.close()
* raise # <<<<<<<<<<<<<<
* return transp, proto
*
*/
__Pyx_GIVEREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_3);
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_ErrRestoreWithState(__pyx_t_1, __pyx_t_3, __pyx_t_5);
__pyx_t_1 = 0; __pyx_t_3 = 0; __pyx_t_5 = 0;
__PYX_ERR(1, 2254, __pyx_L6_except_error)
}
__pyx_L6_except_error:;
/* "uvloop/loop.pyx":2248
* transp._add_extra_info('pipe', pipe)
* transp._attach_fileobj(pipe)
* try: # <<<<<<<<<<<<<<
* transp._open(fileno)
* transp._init_protocol()
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9);
goto __pyx_L1_error;
__pyx_L11_try_end:;
}
/* "uvloop/loop.pyx":2255
* transp.close()
* raise
* return transp, proto # <<<<<<<<<<<<<<
*
* def add_signal_handler(self, sig, callback, *args):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2255, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_transp));
__Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_transp));
PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)__pyx_cur_scope->__pyx_v_transp));
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_proto);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_proto);
PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_cur_scope->__pyx_v_proto);
__pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_5 = 0;
goto __pyx_L0;
CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
/* "uvloop/loop.pyx":2231
* return transp, proto
*
* async def connect_write_pipe(self, proto_factory, pipe): # <<<<<<<<<<<<<<
* """Register write pipe in event loop.
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_10);
__Pyx_AddTraceback("connect_write_pipe", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_L0:;
__Pyx_XDECREF(__pyx_r); __pyx_r = 0;
__pyx_generator->resume_label = -1;
__Pyx_Coroutine_clear((PyObject*)__pyx_generator);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":2257
* return transp, proto
*
* def add_signal_handler(self, sig, callback, *args): # <<<<<<<<<<<<<<
* """Add a handler for a signal. UNIX only.
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_110add_signal_handler(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_109add_signal_handler[] = "Loop.add_signal_handler(self, sig, callback, *args)\nAdd a handler for a signal. UNIX only.\n\n Raise ValueError if the signal number is invalid or uncatchable.\n Raise RuntimeError if there is a problem setting up the handler.\n ";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_110add_signal_handler(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_sig = 0;
PyObject *__pyx_v_callback = 0;
PyObject *__pyx_v_args = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("add_signal_handler (wrapper)", 0);
if (PyTuple_GET_SIZE(__pyx_args) > 2) {
__pyx_v_args = PyTuple_GetSlice(__pyx_args, 2, PyTuple_GET_SIZE(__pyx_args));
if (unlikely(!__pyx_v_args)) {
__Pyx_RefNannyFinishContext();
return NULL;
}
__Pyx_GOTREF(__pyx_v_args);
} else {
__pyx_v_args = __pyx_empty_tuple; __Pyx_INCREF(__pyx_empty_tuple);
}
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sig,&__pyx_n_s_callback,0};
PyObject* values[2] = {0,0};
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
default:
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
case 0: break;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_sig)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
case 1:
if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--;
else {
__Pyx_RaiseArgtupleInvalid("add_signal_handler", 0, 2, 2, 1); __PYX_ERR(1, 2257, __pyx_L3_error)
}
}
if (unlikely(kw_args > 0)) {
const Py_ssize_t used_pos_args = (pos_args < 2) ? pos_args : 2;
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, used_pos_args, "add_signal_handler") < 0)) __PYX_ERR(1, 2257, __pyx_L3_error)
}
} else if (PyTuple_GET_SIZE(__pyx_args) < 2) {
goto __pyx_L5_argtuple_error;
} else {
values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
}
__pyx_v_sig = values[0];
__pyx_v_callback = values[1];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("add_signal_handler", 0, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2257, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_DECREF(__pyx_v_args); __pyx_v_args = 0;
__Pyx_AddTraceback("uvloop.loop.Loop.add_signal_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_109add_signal_handler(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_sig, __pyx_v_callback, __pyx_v_args);
/* function exit code */
__Pyx_XDECREF(__pyx_v_args);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_109add_signal_handler(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sig, PyObject *__pyx_v_callback, PyObject *__pyx_v_args) {
struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_h = 0;
PyObject *__pyx_v_exc = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
PyObject *__pyx_t_10 = NULL;
int __pyx_t_11;
int __pyx_t_12;
char const *__pyx_t_13;
PyObject *__pyx_t_14 = NULL;
PyObject *__pyx_t_15 = NULL;
PyObject *__pyx_t_16 = NULL;
PyObject *__pyx_t_17 = NULL;
PyObject *__pyx_t_18 = NULL;
PyObject *__pyx_t_19 = NULL;
PyObject *__pyx_t_20 = NULL;
PyObject *__pyx_t_21 = NULL;
char const *__pyx_t_22;
__Pyx_RefNannySetupContext("add_signal_handler", 0);
/* "uvloop/loop.pyx":2266
* Handle h
*
* if self._signal_handlers is None: # <<<<<<<<<<<<<<
* self._setup_signals()
* if self._signal_handlers is None:
*/
__pyx_t_1 = (__pyx_v_self->_signal_handlers == ((PyObject*)Py_None));
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":2267
*
* if self._signal_handlers is None:
* self._setup_signals() # <<<<<<<<<<<<<<
* if self._signal_handlers is None:
* raise ValueError('set_wakeup_fd only works in main thread')
*/
__pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_self->__pyx_vtab)->_setup_signals(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2267, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":2268
* if self._signal_handlers is None:
* self._setup_signals()
* if self._signal_handlers is None: # <<<<<<<<<<<<<<
* raise ValueError('set_wakeup_fd only works in main thread')
*
*/
__pyx_t_2 = (__pyx_v_self->_signal_handlers == ((PyObject*)Py_None));
__pyx_t_1 = (__pyx_t_2 != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2269
* self._setup_signals()
* if self._signal_handlers is None:
* raise ValueError('set_wakeup_fd only works in main thread') # <<<<<<<<<<<<<<
*
* if (aio_iscoroutine(callback)
*/
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__95, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2269, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 2269, __pyx_L1_error)
/* "uvloop/loop.pyx":2268
* if self._signal_handlers is None:
* self._setup_signals()
* if self._signal_handlers is None: # <<<<<<<<<<<<<<
* raise ValueError('set_wakeup_fd only works in main thread')
*
*/
}
/* "uvloop/loop.pyx":2266
* Handle h
*
* if self._signal_handlers is None: # <<<<<<<<<<<<<<
* self._setup_signals()
* if self._signal_handlers is None:
*/
}
/* "uvloop/loop.pyx":2271
* raise ValueError('set_wakeup_fd only works in main thread')
*
* if (aio_iscoroutine(callback) # <<<<<<<<<<<<<<
* or aio_iscoroutinefunction(callback)):
* raise TypeError("coroutines cannot be used "
*/
__Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_iscoroutine);
__pyx_t_4 = __pyx_v_6uvloop_4loop_aio_iscoroutine; __pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (!__pyx_t_5) {
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_callback); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2271, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_v_callback};
__pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2271, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_v_callback};
__pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2271, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else
#endif
{
__pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2271, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_INCREF(__pyx_v_callback);
__Pyx_GIVEREF(__pyx_v_callback);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_v_callback);
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2271, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 2271, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
if (!__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L6_bool_binop_done;
}
/* "uvloop/loop.pyx":2272
*
* if (aio_iscoroutine(callback)
* or aio_iscoroutinefunction(callback)): # <<<<<<<<<<<<<<
* raise TypeError("coroutines cannot be used "
* "with add_signal_handler()")
*/
__Pyx_INCREF(__pyx_v_6uvloop_4loop_aio_iscoroutinefunction);
__pyx_t_4 = __pyx_v_6uvloop_4loop_aio_iscoroutinefunction; __pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (!__pyx_t_6) {
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_v_callback); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2272, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_callback};
__pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2272, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_v_callback};
__pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2272, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else
#endif
{
__pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2272, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_INCREF(__pyx_v_callback);
__Pyx_GIVEREF(__pyx_v_callback);
PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_callback);
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2272, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 2272, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_1 = __pyx_t_2;
__pyx_L6_bool_binop_done:;
/* "uvloop/loop.pyx":2271
* raise ValueError('set_wakeup_fd only works in main thread')
*
* if (aio_iscoroutine(callback) # <<<<<<<<<<<<<<
* or aio_iscoroutinefunction(callback)):
* raise TypeError("coroutines cannot be used "
*/
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2273
* if (aio_iscoroutine(callback)
* or aio_iscoroutinefunction(callback)):
* raise TypeError("coroutines cannot be used " # <<<<<<<<<<<<<<
* "with add_signal_handler()")
*
*/
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__96, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2273, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 2273, __pyx_L1_error)
/* "uvloop/loop.pyx":2271
* raise ValueError('set_wakeup_fd only works in main thread')
*
* if (aio_iscoroutine(callback) # <<<<<<<<<<<<<<
* or aio_iscoroutinefunction(callback)):
* raise TypeError("coroutines cannot be used "
*/
}
/* "uvloop/loop.pyx":2276
* "with add_signal_handler()")
*
* self._check_signal(sig) # <<<<<<<<<<<<<<
* self._check_closed()
*
*/
__pyx_t_3 = __pyx_f_6uvloop_4loop_4Loop__check_signal(__pyx_v_self, __pyx_v_sig); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2276, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":2277
*
* self._check_signal(sig)
* self._check_closed() # <<<<<<<<<<<<<<
*
* try:
*/
__pyx_t_3 = __pyx_f_6uvloop_4loop_4Loop__check_closed(__pyx_v_self); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2277, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":2279
* self._check_closed()
*
* try: # <<<<<<<<<<<<<<
* # set_wakeup_fd() raises ValueError if this is not the
* # main thread. By calling it early we ensure that an
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9);
__Pyx_XGOTREF(__pyx_t_7);
__Pyx_XGOTREF(__pyx_t_8);
__Pyx_XGOTREF(__pyx_t_9);
/*try:*/ {
/* "uvloop/loop.pyx":2284
* # event loop running in another thread cannot add a signal
* # handler.
* signal_set_wakeup_fd(self._csock.fileno()) # <<<<<<<<<<<<<<
* except (ValueError, OSError) as exc:
* raise RuntimeError(str(exc))
*/
__pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_csock, __pyx_n_s_fileno); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2284, __pyx_L8_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_5, function);
}
}
if (__pyx_t_6) {
__pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2284, __pyx_L8_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
__pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2284, __pyx_L8_error)
}
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_INCREF(__pyx_v_6uvloop_4loop_signal_set_wakeup_fd);
__pyx_t_5 = __pyx_v_6uvloop_4loop_signal_set_wakeup_fd; __pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_5, function);
}
}
if (!__pyx_t_6) {
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2284, __pyx_L8_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_5)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_4};
__pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2284, __pyx_L8_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_4};
__pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2284, __pyx_L8_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
{
__pyx_t_10 = PyTuple_New(1+1); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 2284, __pyx_L8_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_10, 0+1, __pyx_t_4);
__pyx_t_4 = 0;
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2284, __pyx_L8_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
}
}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":2279
* self._check_closed()
*
* try: # <<<<<<<<<<<<<<
* # set_wakeup_fd() raises ValueError if this is not the
* # main thread. By calling it early we ensure that an
*/
}
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
goto __pyx_L15_try_end;
__pyx_L8_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":2285
* # handler.
* signal_set_wakeup_fd(self._csock.fileno())
* except (ValueError, OSError) as exc: # <<<<<<<<<<<<<<
* raise RuntimeError(str(exc))
*
*/
__pyx_t_11 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ValueError) || __Pyx_PyErr_ExceptionMatches(__pyx_builtin_OSError);
if (__pyx_t_11) {
__Pyx_AddTraceback("uvloop.loop.Loop.add_signal_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_3, &__pyx_t_5, &__pyx_t_10) < 0) __PYX_ERR(1, 2285, __pyx_L10_except_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_t_10);
__Pyx_INCREF(__pyx_t_5);
__pyx_v_exc = __pyx_t_5;
/*try:*/ {
/* "uvloop/loop.pyx":2286
* signal_set_wakeup_fd(self._csock.fileno())
* except (ValueError, OSError) as exc:
* raise RuntimeError(str(exc)) # <<<<<<<<<<<<<<
*
* h = new_Handle(self, callback, args or None)
*/
__pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2286, __pyx_L21_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_v_exc);
__Pyx_GIVEREF(__pyx_v_exc);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_exc);
__pyx_t_6 = __Pyx_PyObject_Call(((PyObject *)(&PyUnicode_Type)), __pyx_t_4, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2286, __pyx_L21_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2286, __pyx_L21_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6);
__pyx_t_6 = 0;
__pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2286, __pyx_L21_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_Raise(__pyx_t_6, 0, 0, 0);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__PYX_ERR(1, 2286, __pyx_L21_error)
}
/* "uvloop/loop.pyx":2285
* # handler.
* signal_set_wakeup_fd(self._csock.fileno())
* except (ValueError, OSError) as exc: # <<<<<<<<<<<<<<
* raise RuntimeError(str(exc))
*
*/
/*finally:*/ {
/*exception exit:*/{
__Pyx_PyThreadState_declare
__pyx_L21_error:;
__pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19);
if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16) < 0)) __Pyx_ErrFetch(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16);
__Pyx_XGOTREF(__pyx_t_14);
__Pyx_XGOTREF(__pyx_t_15);
__Pyx_XGOTREF(__pyx_t_16);
__Pyx_XGOTREF(__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_18);
__Pyx_XGOTREF(__pyx_t_19);
__pyx_t_11 = __pyx_lineno; __pyx_t_12 = __pyx_clineno; __pyx_t_13 = __pyx_filename;
{
__Pyx_DECREF(__pyx_v_exc);
__pyx_v_exc = NULL;
}
__Pyx_PyThreadState_assign
if (PY_MAJOR_VERSION >= 3) {
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_XGIVEREF(__pyx_t_19);
__Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19);
}
__Pyx_XGIVEREF(__pyx_t_14);
__Pyx_XGIVEREF(__pyx_t_15);
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_ErrRestore(__pyx_t_14, __pyx_t_15, __pyx_t_16);
__pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0;
__pyx_lineno = __pyx_t_11; __pyx_clineno = __pyx_t_12; __pyx_filename = __pyx_t_13;
goto __pyx_L10_except_error;
}
}
}
goto __pyx_L10_except_error;
__pyx_L10_except_error:;
/* "uvloop/loop.pyx":2279
* self._check_closed()
*
* try: # <<<<<<<<<<<<<<
* # set_wakeup_fd() raises ValueError if this is not the
* # main thread. By calling it early we ensure that an
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9);
goto __pyx_L1_error;
__pyx_L15_try_end:;
}
/* "uvloop/loop.pyx":2288
* raise RuntimeError(str(exc))
*
* h = new_Handle(self, callback, args or None) # <<<<<<<<<<<<<<
* self._signal_handlers[sig] = h
*
*/
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_args); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 2288, __pyx_L1_error)
if (!__pyx_t_1) {
} else {
__Pyx_INCREF(__pyx_v_args);
__pyx_t_10 = __pyx_v_args;
goto __pyx_L27_bool_binop_done;
}
__Pyx_INCREF(Py_None);
__pyx_t_10 = Py_None;
__pyx_L27_bool_binop_done:;
__pyx_t_5 = __pyx_f_6uvloop_4loop_new_Handle(__pyx_v_self, __pyx_v_callback, __pyx_t_10); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2288, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_6uvloop_4loop_Handle))))) __PYX_ERR(1, 2288, __pyx_L1_error)
__pyx_v_h = ((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_t_5);
__pyx_t_5 = 0;
/* "uvloop/loop.pyx":2289
*
* h = new_Handle(self, callback, args or None)
* self._signal_handlers[sig] = h # <<<<<<<<<<<<<<
*
* try:
*/
if (unlikely(__pyx_v_self->_signal_handlers == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
__PYX_ERR(1, 2289, __pyx_L1_error)
}
if (unlikely(PyDict_SetItem(__pyx_v_self->_signal_handlers, __pyx_v_sig, ((PyObject *)__pyx_v_h)) < 0)) __PYX_ERR(1, 2289, __pyx_L1_error)
/* "uvloop/loop.pyx":2291
* self._signal_handlers[sig] = h
*
* try: # <<<<<<<<<<<<<<
* signal_signal(sig, _sighandler_noop)
* except OSError as exc:
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_8, &__pyx_t_7);
__Pyx_XGOTREF(__pyx_t_9);
__Pyx_XGOTREF(__pyx_t_8);
__Pyx_XGOTREF(__pyx_t_7);
/*try:*/ {
/* "uvloop/loop.pyx":2292
*
* try:
* signal_signal(sig, _sighandler_noop) # <<<<<<<<<<<<<<
* except OSError as exc:
* del self._signal_handlers[sig]
*/
__pyx_t_10 = __Pyx_GetModuleGlobalName(__pyx_n_s_sighandler_noop); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 2292, __pyx_L29_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_INCREF(__pyx_v_6uvloop_4loop_signal_signal);
__pyx_t_3 = __pyx_v_6uvloop_4loop_signal_signal; __pyx_t_6 = NULL;
__pyx_t_12 = 0;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
__pyx_t_12 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_v_sig, __pyx_t_10};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2292, __pyx_L29_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_v_sig, __pyx_t_10};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2292, __pyx_L29_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
} else
#endif
{
__pyx_t_4 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2292, __pyx_L29_error)
__Pyx_GOTREF(__pyx_t_4);
if (__pyx_t_6) {
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6); __pyx_t_6 = NULL;
}
__Pyx_INCREF(__pyx_v_sig);
__Pyx_GIVEREF(__pyx_v_sig);
PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_12, __pyx_v_sig);
__Pyx_GIVEREF(__pyx_t_10);
PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_12, __pyx_t_10);
__pyx_t_10 = 0;
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2292, __pyx_L29_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":2291
* self._signal_handlers[sig] = h
*
* try: # <<<<<<<<<<<<<<
* signal_signal(sig, _sighandler_noop)
* except OSError as exc:
*/
}
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0;
goto __pyx_L36_try_end;
__pyx_L29_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":2293
* try:
* signal_signal(sig, _sighandler_noop)
* except OSError as exc: # <<<<<<<<<<<<<<
* del self._signal_handlers[sig]
* if exc.errno == errno_EINVAL:
*/
__pyx_t_12 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_OSError);
if (__pyx_t_12) {
__Pyx_AddTraceback("uvloop.loop.Loop.add_signal_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_3, &__pyx_t_4) < 0) __PYX_ERR(1, 2293, __pyx_L31_except_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GOTREF(__pyx_t_4);
__Pyx_INCREF(__pyx_t_3);
__pyx_v_exc = __pyx_t_3;
/*try:*/ {
/* "uvloop/loop.pyx":2294
* signal_signal(sig, _sighandler_noop)
* except OSError as exc:
* del self._signal_handlers[sig] # <<<<<<<<<<<<<<
* if exc.errno == errno_EINVAL:
* raise RuntimeError('sig {} cannot be caught'.format(sig))
*/
if (unlikely(__pyx_v_self->_signal_handlers == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
__PYX_ERR(1, 2294, __pyx_L42_error)
}
if (unlikely(PyDict_DelItem(__pyx_v_self->_signal_handlers, __pyx_v_sig) < 0)) __PYX_ERR(1, 2294, __pyx_L42_error)
/* "uvloop/loop.pyx":2295
* except OSError as exc:
* del self._signal_handlers[sig]
* if exc.errno == errno_EINVAL: # <<<<<<<<<<<<<<
* raise RuntimeError('sig {} cannot be caught'.format(sig))
* else:
*/
__pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_exc, __pyx_n_s_errno); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 2295, __pyx_L42_error)
__Pyx_GOTREF(__pyx_t_10);
__pyx_t_6 = PyObject_RichCompare(__pyx_t_10, __pyx_v_6uvloop_4loop_errno_EINVAL, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2295, __pyx_L42_error)
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 2295, __pyx_L42_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2296
* del self._signal_handlers[sig]
* if exc.errno == errno_EINVAL:
* raise RuntimeError('sig {} cannot be caught'.format(sig)) # <<<<<<<<<<<<<<
* else:
* raise
*/
__pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_sig_cannot_be_caught, __pyx_n_s_format); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 2296, __pyx_L42_error)
__Pyx_GOTREF(__pyx_t_10);
__pyx_t_20 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_10))) {
__pyx_t_20 = PyMethod_GET_SELF(__pyx_t_10);
if (likely(__pyx_t_20)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_10);
__Pyx_INCREF(__pyx_t_20);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_10, function);
}
}
if (!__pyx_t_20) {
__pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_10, __pyx_v_sig); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2296, __pyx_L42_error)
__Pyx_GOTREF(__pyx_t_6);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_10)) {
PyObject *__pyx_temp[2] = {__pyx_t_20, __pyx_v_sig};
__pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_10, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2296, __pyx_L42_error)
__Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
__Pyx_GOTREF(__pyx_t_6);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_10)) {
PyObject *__pyx_temp[2] = {__pyx_t_20, __pyx_v_sig};
__pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_10, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2296, __pyx_L42_error)
__Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
__Pyx_GOTREF(__pyx_t_6);
} else
#endif
{
__pyx_t_21 = PyTuple_New(1+1); if (unlikely(!__pyx_t_21)) __PYX_ERR(1, 2296, __pyx_L42_error)
__Pyx_GOTREF(__pyx_t_21);
__Pyx_GIVEREF(__pyx_t_20); PyTuple_SET_ITEM(__pyx_t_21, 0, __pyx_t_20); __pyx_t_20 = NULL;
__Pyx_INCREF(__pyx_v_sig);
__Pyx_GIVEREF(__pyx_v_sig);
PyTuple_SET_ITEM(__pyx_t_21, 0+1, __pyx_v_sig);
__pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_10, __pyx_t_21, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2296, __pyx_L42_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0;
}
}
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__pyx_t_10 = PyTuple_New(1); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 2296, __pyx_L42_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_6);
__pyx_t_6 = 0;
__pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_10, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2296, __pyx_L42_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_Raise(__pyx_t_6, 0, 0, 0);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__PYX_ERR(1, 2296, __pyx_L42_error)
/* "uvloop/loop.pyx":2295
* except OSError as exc:
* del self._signal_handlers[sig]
* if exc.errno == errno_EINVAL: # <<<<<<<<<<<<<<
* raise RuntimeError('sig {} cannot be caught'.format(sig))
* else:
*/
}
/* "uvloop/loop.pyx":2298
* raise RuntimeError('sig {} cannot be caught'.format(sig))
* else:
* raise # <<<<<<<<<<<<<<
*
* def remove_signal_handler(self, sig):
*/
/*else*/ {
__Pyx_GIVEREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_3);
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_ErrRestoreWithState(__pyx_t_5, __pyx_t_3, __pyx_t_4);
__pyx_t_5 = 0; __pyx_t_3 = 0; __pyx_t_4 = 0;
__PYX_ERR(1, 2298, __pyx_L42_error)
}
}
/* "uvloop/loop.pyx":2293
* try:
* signal_signal(sig, _sighandler_noop)
* except OSError as exc: # <<<<<<<<<<<<<<
* del self._signal_handlers[sig]
* if exc.errno == errno_EINVAL:
*/
/*finally:*/ {
/*exception exit:*/{
__Pyx_PyThreadState_declare
__pyx_L42_error:;
__pyx_t_19 = 0; __pyx_t_18 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_t_14 = 0;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_20); __pyx_t_20 = 0;
__Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0;
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_16, &__pyx_t_15, &__pyx_t_14);
if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_19, &__pyx_t_18, &__pyx_t_17) < 0)) __Pyx_ErrFetch(&__pyx_t_19, &__pyx_t_18, &__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_19);
__Pyx_XGOTREF(__pyx_t_18);
__Pyx_XGOTREF(__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_16);
__Pyx_XGOTREF(__pyx_t_15);
__Pyx_XGOTREF(__pyx_t_14);
__pyx_t_12 = __pyx_lineno; __pyx_t_11 = __pyx_clineno; __pyx_t_22 = __pyx_filename;
{
__Pyx_DECREF(__pyx_v_exc);
__pyx_v_exc = NULL;
}
__Pyx_PyThreadState_assign
if (PY_MAJOR_VERSION >= 3) {
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_XGIVEREF(__pyx_t_15);
__Pyx_XGIVEREF(__pyx_t_14);
__Pyx_ExceptionReset(__pyx_t_16, __pyx_t_15, __pyx_t_14);
}
__Pyx_XGIVEREF(__pyx_t_19);
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_ErrRestore(__pyx_t_19, __pyx_t_18, __pyx_t_17);
__pyx_t_19 = 0; __pyx_t_18 = 0; __pyx_t_17 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_t_14 = 0;
__pyx_lineno = __pyx_t_12; __pyx_clineno = __pyx_t_11; __pyx_filename = __pyx_t_22;
goto __pyx_L31_except_error;
}
}
}
goto __pyx_L31_except_error;
__pyx_L31_except_error:;
/* "uvloop/loop.pyx":2291
* self._signal_handlers[sig] = h
*
* try: # <<<<<<<<<<<<<<
* signal_signal(sig, _sighandler_noop)
* except OSError as exc:
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_9);
__Pyx_XGIVEREF(__pyx_t_8);
__Pyx_XGIVEREF(__pyx_t_7);
__Pyx_ExceptionReset(__pyx_t_9, __pyx_t_8, __pyx_t_7);
goto __pyx_L1_error;
__pyx_L36_try_end:;
}
/* "uvloop/loop.pyx":2257
* return transp, proto
*
* def add_signal_handler(self, sig, callback, *args): # <<<<<<<<<<<<<<
* """Add a handler for a signal. UNIX only.
*
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_10);
__Pyx_XDECREF(__pyx_t_20);
__Pyx_XDECREF(__pyx_t_21);
__Pyx_AddTraceback("uvloop.loop.Loop.add_signal_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_h);
__Pyx_XDECREF(__pyx_v_exc);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":2300
* raise
*
* def remove_signal_handler(self, sig): # <<<<<<<<<<<<<<
* """Remove a handler for a signal. UNIX only.
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_112remove_signal_handler(PyObject *__pyx_v_self, PyObject *__pyx_v_sig); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_111remove_signal_handler[] = "Loop.remove_signal_handler(self, sig)\nRemove a handler for a signal. UNIX only.\n\n Return True if a signal handler was removed, False if not.\n ";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_112remove_signal_handler(PyObject *__pyx_v_self, PyObject *__pyx_v_sig) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("remove_signal_handler (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_111remove_signal_handler(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_sig));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_111remove_signal_handler(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_sig) {
PyObject *__pyx_v_handler = NULL;
PyObject *__pyx_v_exc = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_t_2;
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
int __pyx_t_7;
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
PyObject *__pyx_t_10 = NULL;
PyObject *__pyx_t_11 = NULL;
PyObject *__pyx_t_12 = NULL;
PyObject *__pyx_t_13 = NULL;
int __pyx_t_14;
char const *__pyx_t_15;
PyObject *__pyx_t_16 = NULL;
PyObject *__pyx_t_17 = NULL;
PyObject *__pyx_t_18 = NULL;
PyObject *__pyx_t_19 = NULL;
PyObject *__pyx_t_20 = NULL;
PyObject *__pyx_t_21 = NULL;
__Pyx_RefNannySetupContext("remove_signal_handler", 0);
/* "uvloop/loop.pyx":2305
* Return True if a signal handler was removed, False if not.
* """
* self._check_signal(sig) # <<<<<<<<<<<<<<
*
* if self._signal_handlers is None:
*/
__pyx_t_1 = __pyx_f_6uvloop_4loop_4Loop__check_signal(__pyx_v_self, __pyx_v_sig); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2305, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":2307
* self._check_signal(sig)
*
* if self._signal_handlers is None: # <<<<<<<<<<<<<<
* return False
*
*/
__pyx_t_2 = (__pyx_v_self->_signal_handlers == ((PyObject*)Py_None));
__pyx_t_3 = (__pyx_t_2 != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":2308
*
* if self._signal_handlers is None:
* return False # <<<<<<<<<<<<<<
*
* try:
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(Py_False);
__pyx_r = Py_False;
goto __pyx_L0;
/* "uvloop/loop.pyx":2307
* self._check_signal(sig)
*
* if self._signal_handlers is None: # <<<<<<<<<<<<<<
* return False
*
*/
}
/* "uvloop/loop.pyx":2310
* return False
*
* try: # <<<<<<<<<<<<<<
* del self._signal_handlers[sig]
* except KeyError:
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6);
__Pyx_XGOTREF(__pyx_t_4);
__Pyx_XGOTREF(__pyx_t_5);
__Pyx_XGOTREF(__pyx_t_6);
/*try:*/ {
/* "uvloop/loop.pyx":2311
*
* try:
* del self._signal_handlers[sig] # <<<<<<<<<<<<<<
* except KeyError:
* return False
*/
if (unlikely(__pyx_v_self->_signal_handlers == Py_None)) {
PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
__PYX_ERR(1, 2311, __pyx_L4_error)
}
if (unlikely(PyDict_DelItem(__pyx_v_self->_signal_handlers, __pyx_v_sig) < 0)) __PYX_ERR(1, 2311, __pyx_L4_error)
/* "uvloop/loop.pyx":2310
* return False
*
* try: # <<<<<<<<<<<<<<
* del self._signal_handlers[sig]
* except KeyError:
*/
}
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
goto __pyx_L11_try_end;
__pyx_L4_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":2312
* try:
* del self._signal_handlers[sig]
* except KeyError: # <<<<<<<<<<<<<<
* return False
*
*/
__pyx_t_7 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_KeyError);
if (__pyx_t_7) {
__Pyx_AddTraceback("uvloop.loop.Loop.remove_signal_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_8, &__pyx_t_9) < 0) __PYX_ERR(1, 2312, __pyx_L6_except_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GOTREF(__pyx_t_8);
__Pyx_GOTREF(__pyx_t_9);
/* "uvloop/loop.pyx":2313
* del self._signal_handlers[sig]
* except KeyError:
* return False # <<<<<<<<<<<<<<
*
* if sig == uv.SIGINT:
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(Py_False);
__pyx_r = Py_False;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
goto __pyx_L7_except_return;
}
goto __pyx_L6_except_error;
__pyx_L6_except_error:;
/* "uvloop/loop.pyx":2310
* return False
*
* try: # <<<<<<<<<<<<<<
* del self._signal_handlers[sig]
* except KeyError:
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
goto __pyx_L1_error;
__pyx_L7_except_return:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6);
goto __pyx_L0;
__pyx_L11_try_end:;
}
/* "uvloop/loop.pyx":2315
* return False
*
* if sig == uv.SIGINT: # <<<<<<<<<<<<<<
* handler = signal_default_int_handler
* else:
*/
__pyx_t_9 = __Pyx_PyInt_From_int(SIGINT); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 2315, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__pyx_t_8 = PyObject_RichCompare(__pyx_v_sig, __pyx_t_9, Py_EQ); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2315, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(1, 2315, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
if (__pyx_t_3) {
/* "uvloop/loop.pyx":2316
*
* if sig == uv.SIGINT:
* handler = signal_default_int_handler # <<<<<<<<<<<<<<
* else:
* handler = signal_SIG_DFL
*/
__Pyx_INCREF(__pyx_v_6uvloop_4loop_signal_default_int_handler);
__pyx_v_handler = __pyx_v_6uvloop_4loop_signal_default_int_handler;
/* "uvloop/loop.pyx":2315
* return False
*
* if sig == uv.SIGINT: # <<<<<<<<<<<<<<
* handler = signal_default_int_handler
* else:
*/
goto __pyx_L14;
}
/* "uvloop/loop.pyx":2318
* handler = signal_default_int_handler
* else:
* handler = signal_SIG_DFL # <<<<<<<<<<<<<<
*
* try:
*/
/*else*/ {
__Pyx_INCREF(__pyx_v_6uvloop_4loop_signal_SIG_DFL);
__pyx_v_handler = __pyx_v_6uvloop_4loop_signal_SIG_DFL;
}
__pyx_L14:;
/* "uvloop/loop.pyx":2320
* handler = signal_SIG_DFL
*
* try: # <<<<<<<<<<<<<<
* signal_signal(sig, handler)
* except OSError as exc:
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_5, &__pyx_t_4);
__Pyx_XGOTREF(__pyx_t_6);
__Pyx_XGOTREF(__pyx_t_5);
__Pyx_XGOTREF(__pyx_t_4);
/*try:*/ {
/* "uvloop/loop.pyx":2321
*
* try:
* signal_signal(sig, handler) # <<<<<<<<<<<<<<
* except OSError as exc:
* if exc.errno == errno_EINVAL:
*/
__Pyx_INCREF(__pyx_v_6uvloop_4loop_signal_signal);
__pyx_t_9 = __pyx_v_6uvloop_4loop_signal_signal; __pyx_t_1 = NULL;
__pyx_t_7 = 0;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_9))) {
__pyx_t_1 = PyMethod_GET_SELF(__pyx_t_9);
if (likely(__pyx_t_1)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_9);
__Pyx_INCREF(__pyx_t_1);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_9, function);
__pyx_t_7 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_9)) {
PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_v_sig, __pyx_v_handler};
__pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2321, __pyx_L15_error)
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_GOTREF(__pyx_t_8);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_9)) {
PyObject *__pyx_temp[3] = {__pyx_t_1, __pyx_v_sig, __pyx_v_handler};
__pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_9, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2321, __pyx_L15_error)
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_GOTREF(__pyx_t_8);
} else
#endif
{
__pyx_t_10 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 2321, __pyx_L15_error)
__Pyx_GOTREF(__pyx_t_10);
if (__pyx_t_1) {
__Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_1); __pyx_t_1 = NULL;
}
__Pyx_INCREF(__pyx_v_sig);
__Pyx_GIVEREF(__pyx_v_sig);
PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_7, __pyx_v_sig);
__Pyx_INCREF(__pyx_v_handler);
__Pyx_GIVEREF(__pyx_v_handler);
PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_7, __pyx_v_handler);
__pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_9, __pyx_t_10, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2321, __pyx_L15_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
}
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
/* "uvloop/loop.pyx":2320
* handler = signal_SIG_DFL
*
* try: # <<<<<<<<<<<<<<
* signal_signal(sig, handler)
* except OSError as exc:
*/
}
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
goto __pyx_L22_try_end;
__pyx_L15_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0;
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
/* "uvloop/loop.pyx":2322
* try:
* signal_signal(sig, handler)
* except OSError as exc: # <<<<<<<<<<<<<<
* if exc.errno == errno_EINVAL:
* raise RuntimeError('sig {} cannot be caught'.format(sig))
*/
__pyx_t_7 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_OSError);
if (__pyx_t_7) {
__Pyx_AddTraceback("uvloop.loop.Loop.remove_signal_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10) < 0) __PYX_ERR(1, 2322, __pyx_L17_except_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_GOTREF(__pyx_t_9);
__Pyx_GOTREF(__pyx_t_10);
__Pyx_INCREF(__pyx_t_9);
__pyx_v_exc = __pyx_t_9;
/*try:*/ {
/* "uvloop/loop.pyx":2323
* signal_signal(sig, handler)
* except OSError as exc:
* if exc.errno == errno_EINVAL: # <<<<<<<<<<<<<<
* raise RuntimeError('sig {} cannot be caught'.format(sig))
* else:
*/
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_exc, __pyx_n_s_errno); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2323, __pyx_L28_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_11 = PyObject_RichCompare(__pyx_t_1, __pyx_v_6uvloop_4loop_errno_EINVAL, Py_EQ); __Pyx_XGOTREF(__pyx_t_11); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 2323, __pyx_L28_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_11); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(1, 2323, __pyx_L28_error)
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
if (__pyx_t_3) {
/* "uvloop/loop.pyx":2324
* except OSError as exc:
* if exc.errno == errno_EINVAL:
* raise RuntimeError('sig {} cannot be caught'.format(sig)) # <<<<<<<<<<<<<<
* else:
* raise
*/
__pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_sig_cannot_be_caught, __pyx_n_s_format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2324, __pyx_L28_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_t_12 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) {
__pyx_t_12 = PyMethod_GET_SELF(__pyx_t_1);
if (likely(__pyx_t_12)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1);
__Pyx_INCREF(__pyx_t_12);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_1, function);
}
}
if (!__pyx_t_12) {
__pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_sig); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 2324, __pyx_L28_error)
__Pyx_GOTREF(__pyx_t_11);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_1)) {
PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_v_sig};
__pyx_t_11 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 2324, __pyx_L28_error)
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_GOTREF(__pyx_t_11);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) {
PyObject *__pyx_temp[2] = {__pyx_t_12, __pyx_v_sig};
__pyx_t_11 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 2324, __pyx_L28_error)
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_GOTREF(__pyx_t_11);
} else
#endif
{
__pyx_t_13 = PyTuple_New(1+1); if (unlikely(!__pyx_t_13)) __PYX_ERR(1, 2324, __pyx_L28_error)
__Pyx_GOTREF(__pyx_t_13);
__Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_13, 0, __pyx_t_12); __pyx_t_12 = NULL;
__Pyx_INCREF(__pyx_v_sig);
__Pyx_GIVEREF(__pyx_v_sig);
PyTuple_SET_ITEM(__pyx_t_13, 0+1, __pyx_v_sig);
__pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_13, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 2324, __pyx_L28_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0;
}
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2324, __pyx_L28_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_GIVEREF(__pyx_t_11);
PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_11);
__pyx_t_11 = 0;
__pyx_t_11 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 2324, __pyx_L28_error)
__Pyx_GOTREF(__pyx_t_11);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_Raise(__pyx_t_11, 0, 0, 0);
__Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0;
__PYX_ERR(1, 2324, __pyx_L28_error)
/* "uvloop/loop.pyx":2323
* signal_signal(sig, handler)
* except OSError as exc:
* if exc.errno == errno_EINVAL: # <<<<<<<<<<<<<<
* raise RuntimeError('sig {} cannot be caught'.format(sig))
* else:
*/
}
/* "uvloop/loop.pyx":2326
* raise RuntimeError('sig {} cannot be caught'.format(sig))
* else:
* raise # <<<<<<<<<<<<<<
*
* return True
*/
/*else*/ {
__Pyx_GIVEREF(__pyx_t_8);
__Pyx_GIVEREF(__pyx_t_9);
__Pyx_XGIVEREF(__pyx_t_10);
__Pyx_ErrRestoreWithState(__pyx_t_8, __pyx_t_9, __pyx_t_10);
__pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0;
__PYX_ERR(1, 2326, __pyx_L28_error)
}
}
/* "uvloop/loop.pyx":2322
* try:
* signal_signal(sig, handler)
* except OSError as exc: # <<<<<<<<<<<<<<
* if exc.errno == errno_EINVAL:
* raise RuntimeError('sig {} cannot be caught'.format(sig))
*/
/*finally:*/ {
/*exception exit:*/{
__Pyx_PyThreadState_declare
__pyx_L28_error:;
__pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0;
__Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
__Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0;
__Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0;
if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_19, &__pyx_t_20, &__pyx_t_21);
if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18) < 0)) __Pyx_ErrFetch(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
__Pyx_XGOTREF(__pyx_t_16);
__Pyx_XGOTREF(__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_18);
__Pyx_XGOTREF(__pyx_t_19);
__Pyx_XGOTREF(__pyx_t_20);
__Pyx_XGOTREF(__pyx_t_21);
__pyx_t_7 = __pyx_lineno; __pyx_t_14 = __pyx_clineno; __pyx_t_15 = __pyx_filename;
{
__Pyx_DECREF(__pyx_v_exc);
__pyx_v_exc = NULL;
}
__Pyx_PyThreadState_assign
if (PY_MAJOR_VERSION >= 3) {
__Pyx_XGIVEREF(__pyx_t_19);
__Pyx_XGIVEREF(__pyx_t_20);
__Pyx_XGIVEREF(__pyx_t_21);
__Pyx_ExceptionReset(__pyx_t_19, __pyx_t_20, __pyx_t_21);
}
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_ErrRestore(__pyx_t_16, __pyx_t_17, __pyx_t_18);
__pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0;
__pyx_lineno = __pyx_t_7; __pyx_clineno = __pyx_t_14; __pyx_filename = __pyx_t_15;
goto __pyx_L17_except_error;
}
}
}
goto __pyx_L17_except_error;
__pyx_L17_except_error:;
/* "uvloop/loop.pyx":2320
* handler = signal_SIG_DFL
*
* try: # <<<<<<<<<<<<<<
* signal_signal(sig, handler)
* except OSError as exc:
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_6);
__Pyx_XGIVEREF(__pyx_t_5);
__Pyx_XGIVEREF(__pyx_t_4);
__Pyx_ExceptionReset(__pyx_t_6, __pyx_t_5, __pyx_t_4);
goto __pyx_L1_error;
__pyx_L22_try_end:;
}
/* "uvloop/loop.pyx":2328
* raise
*
* return True # <<<<<<<<<<<<<<
*
* async def create_datagram_endpoint(self, protocol_factory,
*/
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(Py_True);
__pyx_r = Py_True;
goto __pyx_L0;
/* "uvloop/loop.pyx":2300
* raise
*
* def remove_signal_handler(self, sig): # <<<<<<<<<<<<<<
* """Remove a handler for a signal. UNIX only.
*
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_XDECREF(__pyx_t_9);
__Pyx_XDECREF(__pyx_t_10);
__Pyx_XDECREF(__pyx_t_11);
__Pyx_XDECREF(__pyx_t_12);
__Pyx_XDECREF(__pyx_t_13);
__Pyx_AddTraceback("uvloop.loop.Loop.remove_signal_handler", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XDECREF(__pyx_v_handler);
__Pyx_XDECREF(__pyx_v_exc);
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_115generator11(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */
/* "uvloop/loop.pyx":2330
* return True
*
* async def create_datagram_endpoint(self, protocol_factory, # <<<<<<<<<<<<<<
* local_addr=None, remote_addr=None, *,
* family=0, proto=0, flags=0,
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_114create_datagram_endpoint(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_113create_datagram_endpoint[] = "Loop.create_datagram_endpoint(self, protocol_factory, local_addr=None, remote_addr=None, *, family=0, proto=0, flags=0, reuse_address=None, reuse_port=None, allow_broadcast=None, sock=None)\nA coroutine which creates a datagram endpoint.\n\n This method will try to establish the endpoint in the background.\n When successful, the coroutine returns a (transport, protocol) pair.\n\n protocol_factory must be a callable returning a protocol instance.\n\n socket family AF_INET or socket.AF_INET6 depending on host (or\n family if specified), socket type SOCK_DGRAM.\n\n reuse_address tells the kernel to reuse a local socket in\n TIME_WAIT state, without waiting for its natural timeout to\n expire. If not specified it will automatically be set to True on\n UNIX.\n\n reuse_port tells the kernel to allow this endpoint to be bound to\n the same port as other existing endpoints are bound to, so long as\n they all set this flag when being created. This option is not\n supported on Windows and some UNIX's. If the\n :py:data:`~socket.SO_REUSEPORT` constant is not defined then this\n capability is unsupported.\n\n allow_broadcast tells the kernel to allow this endpoint to send\n messages to the broadcast address.\n\n sock can optionally be specified in order to use a preexisting\n socket object.\n ";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_114create_datagram_endpoint(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
PyObject *__pyx_v_protocol_factory = 0;
PyObject *__pyx_v_local_addr = 0;
PyObject *__pyx_v_remote_addr = 0;
PyObject *__pyx_v_family = 0;
PyObject *__pyx_v_proto = 0;
PyObject *__pyx_v_flags = 0;
PyObject *__pyx_v_reuse_address = 0;
PyObject *__pyx_v_reuse_port = 0;
PyObject *__pyx_v_allow_broadcast = 0;
PyObject *__pyx_v_sock = 0;
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("create_datagram_endpoint (wrapper)", 0);
{
static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_protocol_factory,&__pyx_n_s_local_addr,&__pyx_n_s_remote_addr,&__pyx_n_s_family,&__pyx_n_s_proto,&__pyx_n_s_flags,&__pyx_n_s_reuse_address,&__pyx_n_s_reuse_port,&__pyx_n_s_allow_broadcast,&__pyx_n_s_sock,0};
PyObject* values[10] = {0,0,0,0,0,0,0,0,0,0};
/* "uvloop/loop.pyx":2331
*
* async def create_datagram_endpoint(self, protocol_factory,
* local_addr=None, remote_addr=None, *, # <<<<<<<<<<<<<<
* family=0, proto=0, flags=0,
* reuse_address=None, reuse_port=None,
*/
values[1] = ((PyObject *)Py_None);
values[2] = ((PyObject *)Py_None);
values[3] = ((PyObject *)__pyx_int_0);
values[4] = ((PyObject *)__pyx_int_0);
values[5] = ((PyObject *)__pyx_int_0);
/* "uvloop/loop.pyx":2333
* local_addr=None, remote_addr=None, *,
* family=0, proto=0, flags=0,
* reuse_address=None, reuse_port=None, # <<<<<<<<<<<<<<
* allow_broadcast=None, sock=None):
* """A coroutine which creates a datagram endpoint.
*/
values[6] = ((PyObject *)Py_None);
values[7] = ((PyObject *)Py_None);
/* "uvloop/loop.pyx":2334
* family=0, proto=0, flags=0,
* reuse_address=None, reuse_port=None,
* allow_broadcast=None, sock=None): # <<<<<<<<<<<<<<
* """A coroutine which creates a datagram endpoint.
*
*/
values[8] = ((PyObject *)Py_None);
values[9] = ((PyObject *)Py_None);
if (unlikely(__pyx_kwds)) {
Py_ssize_t kw_args;
const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
switch (pos_args) {
case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
case 0: break;
default: goto __pyx_L5_argtuple_error;
}
kw_args = PyDict_Size(__pyx_kwds);
switch (pos_args) {
case 0:
if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_protocol_factory)) != 0)) kw_args--;
else goto __pyx_L5_argtuple_error;
case 1:
if (kw_args > 0) {
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_local_addr);
if (value) { values[1] = value; kw_args--; }
}
case 2:
if (kw_args > 0) {
PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_remote_addr);
if (value) { values[2] = value; kw_args--; }
}
}
if (kw_args > 0 && likely(kw_args <= 7)) {
Py_ssize_t index;
for (index = 3; index < 10 && kw_args > 0; index++) {
PyObject* value = PyDict_GetItem(__pyx_kwds, *__pyx_pyargnames[index]);
if (value) { values[index] = value; kw_args--; }
}
}
if (unlikely(kw_args > 0)) {
if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "create_datagram_endpoint") < 0)) __PYX_ERR(1, 2330, __pyx_L3_error)
}
} else {
switch (PyTuple_GET_SIZE(__pyx_args)) {
case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
break;
default: goto __pyx_L5_argtuple_error;
}
}
__pyx_v_protocol_factory = values[0];
__pyx_v_local_addr = values[1];
__pyx_v_remote_addr = values[2];
__pyx_v_family = values[3];
__pyx_v_proto = values[4];
__pyx_v_flags = values[5];
__pyx_v_reuse_address = values[6];
__pyx_v_reuse_port = values[7];
__pyx_v_allow_broadcast = values[8];
__pyx_v_sock = values[9];
}
goto __pyx_L4_argument_unpacking_done;
__pyx_L5_argtuple_error:;
__Pyx_RaiseArgtupleInvalid("create_datagram_endpoint", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 2330, __pyx_L3_error)
__pyx_L3_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.create_datagram_endpoint", __pyx_clineno, __pyx_lineno, __pyx_filename);
__Pyx_RefNannyFinishContext();
return NULL;
__pyx_L4_argument_unpacking_done:;
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_113create_datagram_endpoint(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), __pyx_v_protocol_factory, __pyx_v_local_addr, __pyx_v_remote_addr, __pyx_v_family, __pyx_v_proto, __pyx_v_flags, __pyx_v_reuse_address, __pyx_v_reuse_port, __pyx_v_allow_broadcast, __pyx_v_sock);
/* "uvloop/loop.pyx":2330
* return True
*
* async def create_datagram_endpoint(self, protocol_factory, # <<<<<<<<<<<<<<
* local_addr=None, remote_addr=None, *,
* family=0, proto=0, flags=0,
*/
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_24create_datagram_endpoint_2generator19(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */
/* "uvloop/loop.pyx":2381
* allow_broadcast=allow_broadcast)
* problems = ', '.join(
* '{}={}'.format(k, v) for k, v in opts.items() if v) # <<<<<<<<<<<<<<
* raise ValueError(
* 'socket modifier keyword arguments can not be used '
*/
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_24create_datagram_endpoint_genexpr(PyObject *__pyx_self) {
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_18_genexpr *__pyx_cur_scope;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("genexpr", 0);
__pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_18_genexpr *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_18_genexpr(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_18_genexpr, __pyx_empty_tuple, NULL);
if (unlikely(!__pyx_cur_scope)) {
__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_18_genexpr *)Py_None);
__Pyx_INCREF(Py_None);
__PYX_ERR(1, 2381, __pyx_L1_error)
} else {
__Pyx_GOTREF(__pyx_cur_scope);
}
__pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_create_datagram_endpoint *) __pyx_self;
__Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_outer_scope));
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope);
{
__pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_24create_datagram_endpoint_2generator19, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_create_datagram_endpoint_locals, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(1, 2381, __pyx_L1_error)
__Pyx_DECREF(__pyx_cur_scope);
__Pyx_RefNannyFinishContext();
return (PyObject *) gen;
}
/* function exit code */
__pyx_L1_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.create_datagram_endpoint.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__Pyx_DECREF(((PyObject *)__pyx_cur_scope));
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_24create_datagram_endpoint_2generator19(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */
{
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_18_genexpr *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_18_genexpr *)__pyx_generator->closure);
PyObject *__pyx_r = NULL;
PyObject *__pyx_t_1 = NULL;
Py_ssize_t __pyx_t_2;
Py_ssize_t __pyx_t_3;
int __pyx_t_4;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
int __pyx_t_7;
int __pyx_t_8;
PyObject *__pyx_t_9 = NULL;
PyObject *__pyx_t_10 = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("None", 0);
switch (__pyx_generator->resume_label) {
case 0: goto __pyx_L3_first_run;
default: /* CPython raises the right error here */
__Pyx_RefNannyFinishContext();
return NULL;
}
__pyx_L3_first_run:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 2381, __pyx_L1_error)
__pyx_r = PyList_New(0); if (unlikely(!__pyx_r)) __PYX_ERR(1, 2381, __pyx_L1_error)
__Pyx_GOTREF(__pyx_r);
__pyx_t_2 = 0;
if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_opts)) { __Pyx_RaiseClosureNameError("opts"); __PYX_ERR(1, 2381, __pyx_L1_error) }
if (unlikely(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_opts == Py_None)) {
PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "items");
__PYX_ERR(1, 2381, __pyx_L1_error)
}
__pyx_t_5 = __Pyx_dict_iterator(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_opts, 1, __pyx_n_s_items, (&__pyx_t_3), (&__pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2381, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_1);
__pyx_t_1 = __pyx_t_5;
__pyx_t_5 = 0;
while (1) {
__pyx_t_7 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_3, &__pyx_t_2, &__pyx_t_5, &__pyx_t_6, NULL, __pyx_t_4);
if (unlikely(__pyx_t_7 == 0)) break;
if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(1, 2381, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_t_6);
__Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_k);
__Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_k, __pyx_t_5);
__Pyx_GIVEREF(__pyx_t_5);
__pyx_t_5 = 0;
__Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_v);
__Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_v, __pyx_t_6);
__Pyx_GIVEREF(__pyx_t_6);
__pyx_t_6 = 0;
__pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_v); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(1, 2381, __pyx_L1_error)
if (__pyx_t_8) {
__pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u__97, __pyx_n_s_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2381, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_9 = NULL;
__pyx_t_7 = 0;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
__pyx_t_9 = PyMethod_GET_SELF(__pyx_t_5);
if (likely(__pyx_t_9)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
__Pyx_INCREF(__pyx_t_9);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_5, function);
__pyx_t_7 = 1;
}
}
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_5)) {
PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_cur_scope->__pyx_v_k, __pyx_cur_scope->__pyx_v_v};
__pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2381, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_GOTREF(__pyx_t_6);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_cur_scope->__pyx_v_k, __pyx_cur_scope->__pyx_v_v};
__pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2381, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_GOTREF(__pyx_t_6);
} else
#endif
{
__pyx_t_10 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 2381, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_10);
if (__pyx_t_9) {
__Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); __pyx_t_9 = NULL;
}
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_k);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_k);
PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_7, __pyx_cur_scope->__pyx_v_k);
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_v);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_v);
PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_7, __pyx_cur_scope->__pyx_v_v);
__pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_10, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2381, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
if (unlikely(__Pyx_ListComp_Append(__pyx_r, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 2381, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
}
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_r); __pyx_r = 0;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_9);
__Pyx_XDECREF(__pyx_t_10);
__Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__pyx_generator->resume_label = -1;
__Pyx_Coroutine_clear((PyObject*)__pyx_generator);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":2330
* return True
*
* async def create_datagram_endpoint(self, protocol_factory, # <<<<<<<<<<<<<<
* local_addr=None, remote_addr=None, *,
* family=0, proto=0, flags=0,
*/
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_113create_datagram_endpoint(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_protocol_factory, PyObject *__pyx_v_local_addr, PyObject *__pyx_v_remote_addr, PyObject *__pyx_v_family, PyObject *__pyx_v_proto, PyObject *__pyx_v_flags, PyObject *__pyx_v_reuse_address, PyObject *__pyx_v_reuse_port, PyObject *__pyx_v_allow_broadcast, PyObject *__pyx_v_sock) {
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_create_datagram_endpoint *__pyx_cur_scope;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("create_datagram_endpoint", 0);
__pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_create_datagram_endpoint *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_17_create_datagram_endpoint(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_17_create_datagram_endpoint, __pyx_empty_tuple, NULL);
if (unlikely(!__pyx_cur_scope)) {
__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_create_datagram_endpoint *)Py_None);
__Pyx_INCREF(Py_None);
__PYX_ERR(1, 2330, __pyx_L1_error)
} else {
__Pyx_GOTREF(__pyx_cur_scope);
}
__pyx_cur_scope->__pyx_v_self = __pyx_v_self;
__Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__pyx_cur_scope->__pyx_v_protocol_factory = __pyx_v_protocol_factory;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol_factory);
__pyx_cur_scope->__pyx_v_local_addr = __pyx_v_local_addr;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_local_addr);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_local_addr);
__pyx_cur_scope->__pyx_v_remote_addr = __pyx_v_remote_addr;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_remote_addr);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_remote_addr);
__pyx_cur_scope->__pyx_v_family = __pyx_v_family;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_family);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_family);
__pyx_cur_scope->__pyx_v_proto = __pyx_v_proto;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_proto);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_proto);
__pyx_cur_scope->__pyx_v_flags = __pyx_v_flags;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_flags);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_flags);
__pyx_cur_scope->__pyx_v_reuse_address = __pyx_v_reuse_address;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_reuse_address);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_reuse_address);
__pyx_cur_scope->__pyx_v_reuse_port = __pyx_v_reuse_port;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_reuse_port);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_reuse_port);
__pyx_cur_scope->__pyx_v_allow_broadcast = __pyx_v_allow_broadcast;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_allow_broadcast);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_allow_broadcast);
__pyx_cur_scope->__pyx_v_sock = __pyx_v_sock;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
{
__pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_115generator11, (PyObject *) __pyx_cur_scope, __pyx_n_s_create_datagram_endpoint, __pyx_n_s_Loop_create_datagram_endpoint, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(1, 2330, __pyx_L1_error)
__Pyx_DECREF(__pyx_cur_scope);
__Pyx_RefNannyFinishContext();
return (PyObject *) gen;
}
/* function exit code */
__pyx_L1_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.create_datagram_endpoint", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__Pyx_DECREF(((PyObject *)__pyx_cur_scope));
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_115generator11(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */
{
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_create_datagram_endpoint *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_17_create_datagram_endpoint *)__pyx_generator->closure);
PyObject *__pyx_r = NULL;
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
int __pyx_t_7;
PyObject *__pyx_t_8 = NULL;
int __pyx_t_9;
int __pyx_t_10;
int __pyx_t_11;
Py_ssize_t __pyx_t_12;
int __pyx_t_13;
struct addrinfo *__pyx_t_14;
unsigned int __pyx_t_15;
PyObject *__pyx_t_16 = NULL;
PyObject *__pyx_t_17 = NULL;
PyObject *__pyx_t_18 = NULL;
int __pyx_t_19;
char const *__pyx_t_20;
PyObject *__pyx_t_21 = NULL;
PyObject *__pyx_t_22 = NULL;
PyObject *__pyx_t_23 = NULL;
PyObject *__pyx_t_24 = NULL;
PyObject *__pyx_t_25 = NULL;
PyObject *__pyx_t_26 = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("None", 0);
switch (__pyx_generator->resume_label) {
case 0: goto __pyx_L3_first_run;
case 1: goto __pyx_L24_resume_from_yield;
case 2: goto __pyx_L31_resume_from_yield;
case 3: goto __pyx_L67_resume_from_yield;
default: /* CPython raises the right error here */
__Pyx_RefNannyFinishContext();
return NULL;
}
__pyx_L3_first_run:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 2330, __pyx_L1_error)
/* "uvloop/loop.pyx":2364
* """
* cdef:
* UDPTransport udp = None # <<<<<<<<<<<<<<
* system.addrinfo * lai
* system.addrinfo * rai
*/
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__pyx_cur_scope->__pyx_v_udp = ((struct __pyx_obj_6uvloop_4loop_UDPTransport *)Py_None);
/* "uvloop/loop.pyx":2368
* system.addrinfo * rai
*
* if sock is not None: # <<<<<<<<<<<<<<
* if not _is_sock_dgram(sock.type):
* raise ValueError(
*/
__pyx_t_1 = (__pyx_cur_scope->__pyx_v_sock != Py_None);
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":2369
*
* if sock is not None:
* if not _is_sock_dgram(sock.type): # <<<<<<<<<<<<<<
* raise ValueError(
* 'A UDP Socket was expected, got {!r}'.format(sock))
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_type); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2369, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = __pyx_f_6uvloop_4loop__is_sock_dgram(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2369, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 2369, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_1 = ((!__pyx_t_2) != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2371
* if not _is_sock_dgram(sock.type):
* raise ValueError(
* 'A UDP Socket was expected, got {!r}'.format(sock)) # <<<<<<<<<<<<<<
* if (local_addr or remote_addr or
* family or proto or flags or
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_A_UDP_Socket_was_expected_got_r, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2371, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (!__pyx_t_5) {
__pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_cur_scope->__pyx_v_sock); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2371, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_cur_scope->__pyx_v_sock};
__pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2371, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_4);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_cur_scope->__pyx_v_sock};
__pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2371, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_4);
} else
#endif
{
__pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2371, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_sock);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_sock);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_cur_scope->__pyx_v_sock);
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2371, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":2370
* if sock is not None:
* if not _is_sock_dgram(sock.type):
* raise ValueError( # <<<<<<<<<<<<<<
* 'A UDP Socket was expected, got {!r}'.format(sock))
* if (local_addr or remote_addr or
*/
__pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2370, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
__pyx_t_4 = 0;
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2370, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__PYX_ERR(1, 2370, __pyx_L1_error)
/* "uvloop/loop.pyx":2369
*
* if sock is not None:
* if not _is_sock_dgram(sock.type): # <<<<<<<<<<<<<<
* raise ValueError(
* 'A UDP Socket was expected, got {!r}'.format(sock))
*/
}
/* "uvloop/loop.pyx":2372
* raise ValueError(
* 'A UDP Socket was expected, got {!r}'.format(sock))
* if (local_addr or remote_addr or # <<<<<<<<<<<<<<
* family or proto or flags or
* reuse_address or reuse_port or allow_broadcast):
*/
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_local_addr); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 2372, __pyx_L1_error)
if (!__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L7_bool_binop_done;
}
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_remote_addr); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 2372, __pyx_L1_error)
if (!__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L7_bool_binop_done;
}
/* "uvloop/loop.pyx":2373
* 'A UDP Socket was expected, got {!r}'.format(sock))
* if (local_addr or remote_addr or
* family or proto or flags or # <<<<<<<<<<<<<<
* reuse_address or reuse_port or allow_broadcast):
* # show the problematic kwargs in exception msg
*/
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_family); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 2373, __pyx_L1_error)
if (!__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L7_bool_binop_done;
}
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_proto); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 2373, __pyx_L1_error)
if (!__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L7_bool_binop_done;
}
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_flags); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 2373, __pyx_L1_error)
if (!__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L7_bool_binop_done;
}
/* "uvloop/loop.pyx":2374
* if (local_addr or remote_addr or
* family or proto or flags or
* reuse_address or reuse_port or allow_broadcast): # <<<<<<<<<<<<<<
* # show the problematic kwargs in exception msg
* opts = dict(local_addr=local_addr, remote_addr=remote_addr,
*/
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_reuse_address); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 2374, __pyx_L1_error)
if (!__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L7_bool_binop_done;
}
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_reuse_port); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 2374, __pyx_L1_error)
if (!__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L7_bool_binop_done;
}
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_allow_broadcast); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 2374, __pyx_L1_error)
__pyx_t_1 = __pyx_t_2;
__pyx_L7_bool_binop_done:;
/* "uvloop/loop.pyx":2372
* raise ValueError(
* 'A UDP Socket was expected, got {!r}'.format(sock))
* if (local_addr or remote_addr or # <<<<<<<<<<<<<<
* family or proto or flags or
* reuse_address or reuse_port or allow_broadcast):
*/
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2376
* reuse_address or reuse_port or allow_broadcast):
* # show the problematic kwargs in exception msg
* opts = dict(local_addr=local_addr, remote_addr=remote_addr, # <<<<<<<<<<<<<<
* family=family, proto=proto, flags=flags,
* reuse_address=reuse_address, reuse_port=reuse_port,
*/
__pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2376, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_local_addr, __pyx_cur_scope->__pyx_v_local_addr) < 0) __PYX_ERR(1, 2376, __pyx_L1_error)
if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_remote_addr, __pyx_cur_scope->__pyx_v_remote_addr) < 0) __PYX_ERR(1, 2376, __pyx_L1_error)
/* "uvloop/loop.pyx":2377
* # show the problematic kwargs in exception msg
* opts = dict(local_addr=local_addr, remote_addr=remote_addr,
* family=family, proto=proto, flags=flags, # <<<<<<<<<<<<<<
* reuse_address=reuse_address, reuse_port=reuse_port,
* allow_broadcast=allow_broadcast)
*/
if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_family, __pyx_cur_scope->__pyx_v_family) < 0) __PYX_ERR(1, 2376, __pyx_L1_error)
if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_proto, __pyx_cur_scope->__pyx_v_proto) < 0) __PYX_ERR(1, 2376, __pyx_L1_error)
if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_flags, __pyx_cur_scope->__pyx_v_flags) < 0) __PYX_ERR(1, 2376, __pyx_L1_error)
/* "uvloop/loop.pyx":2378
* opts = dict(local_addr=local_addr, remote_addr=remote_addr,
* family=family, proto=proto, flags=flags,
* reuse_address=reuse_address, reuse_port=reuse_port, # <<<<<<<<<<<<<<
* allow_broadcast=allow_broadcast)
* problems = ', '.join(
*/
if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_reuse_address, __pyx_cur_scope->__pyx_v_reuse_address) < 0) __PYX_ERR(1, 2376, __pyx_L1_error)
if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_reuse_port, __pyx_cur_scope->__pyx_v_reuse_port) < 0) __PYX_ERR(1, 2376, __pyx_L1_error)
/* "uvloop/loop.pyx":2379
* family=family, proto=proto, flags=flags,
* reuse_address=reuse_address, reuse_port=reuse_port,
* allow_broadcast=allow_broadcast) # <<<<<<<<<<<<<<
* problems = ', '.join(
* '{}={}'.format(k, v) for k, v in opts.items() if v)
*/
if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_allow_broadcast, __pyx_cur_scope->__pyx_v_allow_broadcast) < 0) __PYX_ERR(1, 2376, __pyx_L1_error)
__Pyx_GIVEREF(__pyx_t_4);
__pyx_cur_scope->__pyx_v_opts = ((PyObject*)__pyx_t_4);
__pyx_t_4 = 0;
/* "uvloop/loop.pyx":2381
* allow_broadcast=allow_broadcast)
* problems = ', '.join(
* '{}={}'.format(k, v) for k, v in opts.items() if v) # <<<<<<<<<<<<<<
* raise ValueError(
* 'socket modifier keyword arguments can not be used '
*/
__pyx_t_4 = __pyx_pf_6uvloop_4loop_4Loop_24create_datagram_endpoint_genexpr(((PyObject*)__pyx_cur_scope)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2381, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
/* "uvloop/loop.pyx":2380
* reuse_address=reuse_address, reuse_port=reuse_port,
* allow_broadcast=allow_broadcast)
* problems = ', '.join( # <<<<<<<<<<<<<<
* '{}={}'.format(k, v) for k, v in opts.items() if v)
* raise ValueError(
*/
__pyx_t_3 = __Pyx_Generator_Next(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2380, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_4 = PyUnicode_Join(__pyx_kp_u__64, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2380, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GIVEREF(__pyx_t_4);
__pyx_cur_scope->__pyx_v_problems = ((PyObject*)__pyx_t_4);
__pyx_t_4 = 0;
/* "uvloop/loop.pyx":2384
* raise ValueError(
* 'socket modifier keyword arguments can not be used '
* 'when sock is specified. ({})'.format(problems)) # <<<<<<<<<<<<<<
* sock.setblocking(False)
* udp = UDPTransport.__new__(UDPTransport)
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_socket_modifier_keyword_argument, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2384, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (!__pyx_t_6) {
__pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_cur_scope->__pyx_v_problems); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2384, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_cur_scope->__pyx_v_problems};
__pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2384, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_4);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_cur_scope->__pyx_v_problems};
__pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2384, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_4);
} else
#endif
{
__pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2384, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_problems);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_problems);
PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_cur_scope->__pyx_v_problems);
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2384, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":2382
* problems = ', '.join(
* '{}={}'.format(k, v) for k, v in opts.items() if v)
* raise ValueError( # <<<<<<<<<<<<<<
* 'socket modifier keyword arguments can not be used '
* 'when sock is specified. ({})'.format(problems))
*/
__pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2382, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4);
__pyx_t_4 = 0;
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2382, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_Raise(__pyx_t_4, 0, 0, 0);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__PYX_ERR(1, 2382, __pyx_L1_error)
/* "uvloop/loop.pyx":2372
* raise ValueError(
* 'A UDP Socket was expected, got {!r}'.format(sock))
* if (local_addr or remote_addr or # <<<<<<<<<<<<<<
* family or proto or flags or
* reuse_address or reuse_port or allow_broadcast):
*/
}
/* "uvloop/loop.pyx":2385
* 'socket modifier keyword arguments can not be used '
* 'when sock is specified. ({})'.format(problems))
* sock.setblocking(False) # <<<<<<<<<<<<<<
* udp = UDPTransport.__new__(UDPTransport)
* udp._init(self, uv.AF_UNSPEC)
*/
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_setblocking); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2385, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__98, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2385, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":2386
* 'when sock is specified. ({})'.format(problems))
* sock.setblocking(False)
* udp = UDPTransport.__new__(UDPTransport) # <<<<<<<<<<<<<<
* udp._init(self, uv.AF_UNSPEC)
* udp.open(sock.family, os_dup(sock.fileno()))
*/
__pyx_t_3 = __pyx_tp_new_6uvloop_4loop_UDPTransport(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_UDPTransport), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2386, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
if (!(likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_6uvloop_4loop_UDPTransport)))) __PYX_ERR(1, 2386, __pyx_L1_error)
__Pyx_GOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_udp));
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_udp, ((struct __pyx_obj_6uvloop_4loop_UDPTransport *)__pyx_t_3));
__Pyx_GIVEREF(__pyx_t_3);
__pyx_t_3 = 0;
/* "uvloop/loop.pyx":2387
* sock.setblocking(False)
* udp = UDPTransport.__new__(UDPTransport)
* udp._init(self, uv.AF_UNSPEC) # <<<<<<<<<<<<<<
* udp.open(sock.family, os_dup(sock.fileno()))
* udp._attach_fileobj(sock)
*/
__pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->_init(__pyx_cur_scope->__pyx_v_udp, __pyx_cur_scope->__pyx_v_self, AF_UNSPEC); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2387, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":2388
* udp = UDPTransport.__new__(UDPTransport)
* udp._init(self, uv.AF_UNSPEC)
* udp.open(sock.family, os_dup(sock.fileno())) # <<<<<<<<<<<<<<
* udp._attach_fileobj(sock)
* else:
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_family); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2388, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 2388, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_sock, __pyx_n_s_fileno); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2388, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_5, function);
}
}
if (__pyx_t_6) {
__pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2388, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else {
__pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2388, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_INCREF(__pyx_v_6uvloop_4loop_os_dup);
__pyx_t_5 = __pyx_v_6uvloop_4loop_os_dup; __pyx_t_6 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) {
__pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5);
if (likely(__pyx_t_6)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5);
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_5, function);
}
}
if (!__pyx_t_6) {
__pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2388, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_3);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_5)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_4};
__pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2388, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) {
PyObject *__pyx_temp[2] = {__pyx_t_6, __pyx_t_4};
__pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2388, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
{
__pyx_t_8 = PyTuple_New(1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2388, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL;
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_8, 0+1, __pyx_t_4);
__pyx_t_4 = 0;
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2388, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
}
}
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 2388, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->open(__pyx_cur_scope->__pyx_v_udp, __pyx_t_7, __pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2388, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":2389
* udp._init(self, uv.AF_UNSPEC)
* udp.open(sock.family, os_dup(sock.fileno()))
* udp._attach_fileobj(sock) # <<<<<<<<<<<<<<
* else:
* reuse_address = bool(reuse_address)
*/
__pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._attach_fileobj(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_udp), __pyx_cur_scope->__pyx_v_sock); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2389, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":2368
* system.addrinfo * rai
*
* if sock is not None: # <<<<<<<<<<<<<<
* if not _is_sock_dgram(sock.type):
* raise ValueError(
*/
goto __pyx_L4;
}
/* "uvloop/loop.pyx":2391
* udp._attach_fileobj(sock)
* else:
* reuse_address = bool(reuse_address) # <<<<<<<<<<<<<<
* reuse_port = bool(reuse_port)
* if reuse_port and not has_SO_REUSEPORT:
*/
/*else*/ {
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_reuse_address); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 2391, __pyx_L1_error)
__pyx_t_3 = __Pyx_PyBool_FromLong((!(!__pyx_t_1))); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2391, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_reuse_address);
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_reuse_address, __pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
__pyx_t_3 = 0;
/* "uvloop/loop.pyx":2392
* else:
* reuse_address = bool(reuse_address)
* reuse_port = bool(reuse_port) # <<<<<<<<<<<<<<
* if reuse_port and not has_SO_REUSEPORT:
* raise ValueError(
*/
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_reuse_port); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 2392, __pyx_L1_error)
__pyx_t_3 = __Pyx_PyBool_FromLong((!(!__pyx_t_1))); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2392, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_reuse_port);
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_reuse_port, __pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
__pyx_t_3 = 0;
/* "uvloop/loop.pyx":2393
* reuse_address = bool(reuse_address)
* reuse_port = bool(reuse_port)
* if reuse_port and not has_SO_REUSEPORT: # <<<<<<<<<<<<<<
* raise ValueError(
* 'reuse_port not supported by socket module')
*/
__pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_reuse_port); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 2393, __pyx_L1_error)
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L16_bool_binop_done;
}
__pyx_t_2 = ((!(__pyx_v_6uvloop_4loop_has_SO_REUSEPORT != 0)) != 0);
__pyx_t_1 = __pyx_t_2;
__pyx_L16_bool_binop_done:;
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2394
* reuse_port = bool(reuse_port)
* if reuse_port and not has_SO_REUSEPORT:
* raise ValueError( # <<<<<<<<<<<<<<
* 'reuse_port not supported by socket module')
*
*/
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__99, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2394, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 2394, __pyx_L1_error)
/* "uvloop/loop.pyx":2393
* reuse_address = bool(reuse_address)
* reuse_port = bool(reuse_port)
* if reuse_port and not has_SO_REUSEPORT: # <<<<<<<<<<<<<<
* raise ValueError(
* 'reuse_port not supported by socket module')
*/
}
/* "uvloop/loop.pyx":2397
* 'reuse_port not supported by socket module')
*
* lads = None # <<<<<<<<<<<<<<
* if local_addr is not None:
* if (not isinstance(local_addr, (tuple, list)) or
*/
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__pyx_cur_scope->__pyx_v_lads = Py_None;
/* "uvloop/loop.pyx":2398
*
* lads = None
* if local_addr is not None: # <<<<<<<<<<<<<<
* if (not isinstance(local_addr, (tuple, list)) or
* len(local_addr) != 2):
*/
__pyx_t_1 = (__pyx_cur_scope->__pyx_v_local_addr != Py_None);
__pyx_t_2 = (__pyx_t_1 != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":2399
* lads = None
* if local_addr is not None:
* if (not isinstance(local_addr, (tuple, list)) or # <<<<<<<<<<<<<<
* len(local_addr) != 2):
* raise TypeError(
*/
__pyx_t_10 = PyTuple_Check(__pyx_cur_scope->__pyx_v_local_addr);
__pyx_t_11 = (__pyx_t_10 != 0);
if (!__pyx_t_11) {
} else {
__pyx_t_1 = __pyx_t_11;
goto __pyx_L22_bool_binop_done;
}
__pyx_t_11 = PyList_Check(__pyx_cur_scope->__pyx_v_local_addr);
__pyx_t_10 = (__pyx_t_11 != 0);
__pyx_t_1 = __pyx_t_10;
__pyx_L22_bool_binop_done:;
__pyx_t_10 = ((!(__pyx_t_1 != 0)) != 0);
if (!__pyx_t_10) {
} else {
__pyx_t_2 = __pyx_t_10;
goto __pyx_L20_bool_binop_done;
}
/* "uvloop/loop.pyx":2400
* if local_addr is not None:
* if (not isinstance(local_addr, (tuple, list)) or
* len(local_addr) != 2): # <<<<<<<<<<<<<<
* raise TypeError(
* 'local_addr must be a tuple of (host, port)')
*/
__pyx_t_12 = PyObject_Length(__pyx_cur_scope->__pyx_v_local_addr); if (unlikely(__pyx_t_12 == -1)) __PYX_ERR(1, 2400, __pyx_L1_error)
__pyx_t_10 = ((__pyx_t_12 != 2) != 0);
__pyx_t_2 = __pyx_t_10;
__pyx_L20_bool_binop_done:;
/* "uvloop/loop.pyx":2399
* lads = None
* if local_addr is not None:
* if (not isinstance(local_addr, (tuple, list)) or # <<<<<<<<<<<<<<
* len(local_addr) != 2):
* raise TypeError(
*/
if (__pyx_t_2) {
/* "uvloop/loop.pyx":2401
* if (not isinstance(local_addr, (tuple, list)) or
* len(local_addr) != 2):
* raise TypeError( # <<<<<<<<<<<<<<
* 'local_addr must be a tuple of (host, port)')
* lads = await self._getaddrinfo(
*/
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__100, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2401, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 2401, __pyx_L1_error)
/* "uvloop/loop.pyx":2399
* lads = None
* if local_addr is not None:
* if (not isinstance(local_addr, (tuple, list)) or # <<<<<<<<<<<<<<
* len(local_addr) != 2):
* raise TypeError(
*/
}
/* "uvloop/loop.pyx":2404
* 'local_addr must be a tuple of (host, port)')
* lads = await self._getaddrinfo(
* local_addr[0], local_addr[1], # <<<<<<<<<<<<<<
* family, uv.SOCK_DGRAM, proto, flags,
* 0)
*/
__pyx_t_3 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_local_addr, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2404, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_5 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_local_addr, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2404, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
/* "uvloop/loop.pyx":2405
* lads = await self._getaddrinfo(
* local_addr[0], local_addr[1],
* family, uv.SOCK_DGRAM, proto, flags, # <<<<<<<<<<<<<<
* 0)
*
*/
__pyx_t_9 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_family); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 2405, __pyx_L1_error)
__pyx_t_7 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_proto); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 2405, __pyx_L1_error)
__pyx_t_13 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_flags); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 2405, __pyx_L1_error)
/* "uvloop/loop.pyx":2403
* raise TypeError(
* 'local_addr must be a tuple of (host, port)')
* lads = await self._getaddrinfo( # <<<<<<<<<<<<<<
* local_addr[0], local_addr[1],
* family, uv.SOCK_DGRAM, proto, flags,
*/
__pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_getaddrinfo(__pyx_cur_scope->__pyx_v_self, __pyx_t_3, __pyx_t_5, __pyx_t_9, SOCK_DGRAM, __pyx_t_7, __pyx_t_13, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2403, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_8);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XGOTREF(__pyx_r);
if (likely(__pyx_r)) {
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
/* return from generator, yielding value */
__pyx_generator->resume_label = 1;
return __pyx_r;
__pyx_L24_resume_from_yield:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 2403, __pyx_L1_error)
__pyx_t_8 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_8);
} else {
__pyx_t_8 = NULL;
if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_8) < 0) __PYX_ERR(1, 2403, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
}
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_lads);
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_lads, __pyx_t_8);
__Pyx_GIVEREF(__pyx_t_8);
__pyx_t_8 = 0;
/* "uvloop/loop.pyx":2398
*
* lads = None
* if local_addr is not None: # <<<<<<<<<<<<<<
* if (not isinstance(local_addr, (tuple, list)) or
* len(local_addr) != 2):
*/
}
/* "uvloop/loop.pyx":2408
* 0)
*
* rads = None # <<<<<<<<<<<<<<
* if remote_addr is not None:
* if (not isinstance(remote_addr, (tuple, list)) or
*/
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__pyx_cur_scope->__pyx_v_rads = Py_None;
/* "uvloop/loop.pyx":2409
*
* rads = None
* if remote_addr is not None: # <<<<<<<<<<<<<<
* if (not isinstance(remote_addr, (tuple, list)) or
* len(remote_addr) != 2):
*/
__pyx_t_2 = (__pyx_cur_scope->__pyx_v_remote_addr != Py_None);
__pyx_t_10 = (__pyx_t_2 != 0);
if (__pyx_t_10) {
/* "uvloop/loop.pyx":2410
* rads = None
* if remote_addr is not None:
* if (not isinstance(remote_addr, (tuple, list)) or # <<<<<<<<<<<<<<
* len(remote_addr) != 2):
* raise TypeError(
*/
__pyx_t_1 = PyTuple_Check(__pyx_cur_scope->__pyx_v_remote_addr);
__pyx_t_11 = (__pyx_t_1 != 0);
if (!__pyx_t_11) {
} else {
__pyx_t_2 = __pyx_t_11;
goto __pyx_L29_bool_binop_done;
}
__pyx_t_11 = PyList_Check(__pyx_cur_scope->__pyx_v_remote_addr);
__pyx_t_1 = (__pyx_t_11 != 0);
__pyx_t_2 = __pyx_t_1;
__pyx_L29_bool_binop_done:;
__pyx_t_1 = ((!(__pyx_t_2 != 0)) != 0);
if (!__pyx_t_1) {
} else {
__pyx_t_10 = __pyx_t_1;
goto __pyx_L27_bool_binop_done;
}
/* "uvloop/loop.pyx":2411
* if remote_addr is not None:
* if (not isinstance(remote_addr, (tuple, list)) or
* len(remote_addr) != 2): # <<<<<<<<<<<<<<
* raise TypeError(
* 'remote_addr must be a tuple of (host, port)')
*/
__pyx_t_12 = PyObject_Length(__pyx_cur_scope->__pyx_v_remote_addr); if (unlikely(__pyx_t_12 == -1)) __PYX_ERR(1, 2411, __pyx_L1_error)
__pyx_t_1 = ((__pyx_t_12 != 2) != 0);
__pyx_t_10 = __pyx_t_1;
__pyx_L27_bool_binop_done:;
/* "uvloop/loop.pyx":2410
* rads = None
* if remote_addr is not None:
* if (not isinstance(remote_addr, (tuple, list)) or # <<<<<<<<<<<<<<
* len(remote_addr) != 2):
* raise TypeError(
*/
if (__pyx_t_10) {
/* "uvloop/loop.pyx":2412
* if (not isinstance(remote_addr, (tuple, list)) or
* len(remote_addr) != 2):
* raise TypeError( # <<<<<<<<<<<<<<
* 'remote_addr must be a tuple of (host, port)')
* rads = await self._getaddrinfo(
*/
__pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__101, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2412, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_Raise(__pyx_t_8, 0, 0, 0);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__PYX_ERR(1, 2412, __pyx_L1_error)
/* "uvloop/loop.pyx":2410
* rads = None
* if remote_addr is not None:
* if (not isinstance(remote_addr, (tuple, list)) or # <<<<<<<<<<<<<<
* len(remote_addr) != 2):
* raise TypeError(
*/
}
/* "uvloop/loop.pyx":2415
* 'remote_addr must be a tuple of (host, port)')
* rads = await self._getaddrinfo(
* remote_addr[0], remote_addr[1], # <<<<<<<<<<<<<<
* family, uv.SOCK_DGRAM, proto, flags,
* 0)
*/
__pyx_t_8 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_remote_addr, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2415, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__pyx_t_5 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_remote_addr, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2415, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
/* "uvloop/loop.pyx":2416
* rads = await self._getaddrinfo(
* remote_addr[0], remote_addr[1],
* family, uv.SOCK_DGRAM, proto, flags, # <<<<<<<<<<<<<<
* 0)
*
*/
__pyx_t_13 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_family); if (unlikely((__pyx_t_13 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 2416, __pyx_L1_error)
__pyx_t_7 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_proto); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 2416, __pyx_L1_error)
__pyx_t_9 = __Pyx_PyInt_As_int(__pyx_cur_scope->__pyx_v_flags); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 2416, __pyx_L1_error)
/* "uvloop/loop.pyx":2414
* raise TypeError(
* 'remote_addr must be a tuple of (host, port)')
* rads = await self._getaddrinfo( # <<<<<<<<<<<<<<
* remote_addr[0], remote_addr[1],
* family, uv.SOCK_DGRAM, proto, flags,
*/
__pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_getaddrinfo(__pyx_cur_scope->__pyx_v_self, __pyx_t_8, __pyx_t_5, __pyx_t_13, SOCK_DGRAM, __pyx_t_7, __pyx_t_9, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2414, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XGOTREF(__pyx_r);
if (likely(__pyx_r)) {
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
/* return from generator, yielding value */
__pyx_generator->resume_label = 2;
return __pyx_r;
__pyx_L31_resume_from_yield:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 2414, __pyx_L1_error)
__pyx_t_3 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_3);
} else {
__pyx_t_3 = NULL;
if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_3) < 0) __PYX_ERR(1, 2414, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
}
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_rads);
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_rads, __pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
__pyx_t_3 = 0;
/* "uvloop/loop.pyx":2409
*
* rads = None
* if remote_addr is not None: # <<<<<<<<<<<<<<
* if (not isinstance(remote_addr, (tuple, list)) or
* len(remote_addr) != 2):
*/
}
/* "uvloop/loop.pyx":2419
* 0)
*
* excs = [] # <<<<<<<<<<<<<<
* if lads is None:
* if rads is not None:
*/
__pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2419, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
__pyx_cur_scope->__pyx_v_excs = ((PyObject*)__pyx_t_3);
__pyx_t_3 = 0;
/* "uvloop/loop.pyx":2420
*
* excs = []
* if lads is None: # <<<<<<<<<<<<<<
* if rads is not None:
* udp = UDPTransport.__new__(UDPTransport)
*/
__pyx_t_10 = (__pyx_cur_scope->__pyx_v_lads == Py_None);
__pyx_t_1 = (__pyx_t_10 != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2421
* excs = []
* if lads is None:
* if rads is not None: # <<<<<<<<<<<<<<
* udp = UDPTransport.__new__(UDPTransport)
* rai = (rads).data
*/
__pyx_t_1 = (__pyx_cur_scope->__pyx_v_rads != Py_None);
__pyx_t_10 = (__pyx_t_1 != 0);
if (__pyx_t_10) {
/* "uvloop/loop.pyx":2422
* if lads is None:
* if rads is not None:
* udp = UDPTransport.__new__(UDPTransport) # <<<<<<<<<<<<<<
* rai = (rads).data
* udp._init(self, rai.ai_family)
*/
__pyx_t_3 = __pyx_tp_new_6uvloop_4loop_UDPTransport(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_UDPTransport), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2422, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
if (!(likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_6uvloop_4loop_UDPTransport)))) __PYX_ERR(1, 2422, __pyx_L1_error)
__Pyx_GOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_udp));
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_udp, ((struct __pyx_obj_6uvloop_4loop_UDPTransport *)__pyx_t_3));
__Pyx_GIVEREF(__pyx_t_3);
__pyx_t_3 = 0;
/* "uvloop/loop.pyx":2423
* if rads is not None:
* udp = UDPTransport.__new__(UDPTransport)
* rai = (rads).data # <<<<<<<<<<<<<<
* udp._init(self, rai.ai_family)
* udp._set_remote_address(rai.ai_addr, rai.ai_addrlen)
*/
__pyx_t_14 = ((struct __pyx_obj_6uvloop_4loop_AddrInfo *)__pyx_cur_scope->__pyx_v_rads)->data;
__pyx_cur_scope->__pyx_v_rai = __pyx_t_14;
/* "uvloop/loop.pyx":2424
* udp = UDPTransport.__new__(UDPTransport)
* rai = (rads).data
* udp._init(self, rai.ai_family) # <<<<<<<<<<<<<<
* udp._set_remote_address(rai.ai_addr, rai.ai_addrlen)
* else:
*/
__pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->_init(__pyx_cur_scope->__pyx_v_udp, __pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_rai->ai_family); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2424, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":2425
* rai = (rads).data
* udp._init(self, rai.ai_family)
* udp._set_remote_address(rai.ai_addr, rai.ai_addrlen) # <<<<<<<<<<<<<<
* else:
* if family not in (uv.AF_INET, uv.AF_INET6):
*/
__pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->_set_remote_address(__pyx_cur_scope->__pyx_v_udp, __pyx_cur_scope->__pyx_v_rai->ai_addr, __pyx_cur_scope->__pyx_v_rai->ai_addrlen); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2425, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":2421
* excs = []
* if lads is None:
* if rads is not None: # <<<<<<<<<<<<<<
* udp = UDPTransport.__new__(UDPTransport)
* rai = (rads).data
*/
goto __pyx_L33;
}
/* "uvloop/loop.pyx":2427
* udp._set_remote_address(rai.ai_addr, rai.ai_addrlen)
* else:
* if family not in (uv.AF_INET, uv.AF_INET6): # <<<<<<<<<<<<<<
* raise ValueError('unexpected address family')
* udp = UDPTransport.__new__(UDPTransport)
*/
/*else*/ {
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_family);
__pyx_t_3 = __pyx_cur_scope->__pyx_v_family;
__pyx_t_5 = __Pyx_PyInt_From_int(AF_INET); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2427, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_8 = PyObject_RichCompare(__pyx_t_3, __pyx_t_5, Py_NE); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2427, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 2427, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
if (__pyx_t_1) {
} else {
__pyx_t_10 = __pyx_t_1;
goto __pyx_L35_bool_binop_done;
}
__pyx_t_8 = __Pyx_PyInt_From_int(AF_INET6); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2427, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__pyx_t_5 = PyObject_RichCompare(__pyx_t_3, __pyx_t_8, Py_NE); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2427, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 2427, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_10 = __pyx_t_1;
__pyx_L35_bool_binop_done:;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_1 = (__pyx_t_10 != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2428
* else:
* if family not in (uv.AF_INET, uv.AF_INET6):
* raise ValueError('unexpected address family') # <<<<<<<<<<<<<<
* udp = UDPTransport.__new__(UDPTransport)
* udp._init(self, family)
*/
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__102, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2428, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_Raise(__pyx_t_3, 0, 0, 0);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__PYX_ERR(1, 2428, __pyx_L1_error)
/* "uvloop/loop.pyx":2427
* udp._set_remote_address(rai.ai_addr, rai.ai_addrlen)
* else:
* if family not in (uv.AF_INET, uv.AF_INET6): # <<<<<<<<<<<<<<
* raise ValueError('unexpected address family')
* udp = UDPTransport.__new__(UDPTransport)
*/
}
/* "uvloop/loop.pyx":2429
* if family not in (uv.AF_INET, uv.AF_INET6):
* raise ValueError('unexpected address family')
* udp = UDPTransport.__new__(UDPTransport) # <<<<<<<<<<<<<<
* udp._init(self, family)
*
*/
__pyx_t_3 = __pyx_tp_new_6uvloop_4loop_UDPTransport(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_UDPTransport), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2429, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
if (!(likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_6uvloop_4loop_UDPTransport)))) __PYX_ERR(1, 2429, __pyx_L1_error)
__Pyx_GOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_udp));
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_udp, ((struct __pyx_obj_6uvloop_4loop_UDPTransport *)__pyx_t_3));
__Pyx_GIVEREF(__pyx_t_3);
__pyx_t_3 = 0;
/* "uvloop/loop.pyx":2430
* raise ValueError('unexpected address family')
* udp = UDPTransport.__new__(UDPTransport)
* udp._init(self, family) # <<<<<<<<<<<<<<
*
* if reuse_port:
*/
__pyx_t_15 = __Pyx_PyInt_As_unsigned_int(__pyx_cur_scope->__pyx_v_family); if (unlikely((__pyx_t_15 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(1, 2430, __pyx_L1_error)
__pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->_init(__pyx_cur_scope->__pyx_v_udp, __pyx_cur_scope->__pyx_v_self, __pyx_t_15); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2430, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
}
__pyx_L33:;
/* "uvloop/loop.pyx":2432
* udp._init(self, family)
*
* if reuse_port: # <<<<<<<<<<<<<<
* self._sock_set_reuseport(udp._fileno())
*
*/
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_reuse_port); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 2432, __pyx_L1_error)
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2433
*
* if reuse_port:
* self._sock_set_reuseport(udp._fileno()) # <<<<<<<<<<<<<<
*
* socket = udp._get_socket()
*/
__pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._fileno(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_udp)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2433, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 2433, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_sock_set_reuseport(__pyx_cur_scope->__pyx_v_self, __pyx_t_9); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2433, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":2432
* udp._init(self, family)
*
* if reuse_port: # <<<<<<<<<<<<<<
* self._sock_set_reuseport(udp._fileno())
*
*/
}
/* "uvloop/loop.pyx":2435
* self._sock_set_reuseport(udp._fileno())
*
* socket = udp._get_socket() # <<<<<<<<<<<<<<
* socket.bind(('0.0.0.0', 0))
* else:
*/
__pyx_t_3 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._get_socket(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_udp)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2435, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
__pyx_cur_scope->__pyx_v_socket = __pyx_t_3;
__pyx_t_3 = 0;
/* "uvloop/loop.pyx":2436
*
* socket = udp._get_socket()
* socket.bind(('0.0.0.0', 0)) # <<<<<<<<<<<<<<
* else:
* lai = (lads).data
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_socket, __pyx_n_s_bind); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2436, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__104, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2436, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":2420
*
* excs = []
* if lads is None: # <<<<<<<<<<<<<<
* if rads is not None:
* udp = UDPTransport.__new__(UDPTransport)
*/
goto __pyx_L32;
}
/* "uvloop/loop.pyx":2438
* socket.bind(('0.0.0.0', 0))
* else:
* lai = (lads).data # <<<<<<<<<<<<<<
* while lai is not NULL:
* try:
*/
/*else*/ {
__pyx_t_14 = ((struct __pyx_obj_6uvloop_4loop_AddrInfo *)__pyx_cur_scope->__pyx_v_lads)->data;
__pyx_cur_scope->__pyx_v_lai = __pyx_t_14;
/* "uvloop/loop.pyx":2439
* else:
* lai = (lads).data
* while lai is not NULL: # <<<<<<<<<<<<<<
* try:
* udp = UDPTransport.__new__(UDPTransport)
*/
while (1) {
__pyx_t_1 = ((__pyx_cur_scope->__pyx_v_lai != NULL) != 0);
if (!__pyx_t_1) break;
/* "uvloop/loop.pyx":2440
* lai = (lads).data
* while lai is not NULL:
* try: # <<<<<<<<<<<<<<
* udp = UDPTransport.__new__(UDPTransport)
* udp._init(self, lai.ai_family)
*/
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18);
__Pyx_XGOTREF(__pyx_t_16);
__Pyx_XGOTREF(__pyx_t_17);
__Pyx_XGOTREF(__pyx_t_18);
/*try:*/ {
/* "uvloop/loop.pyx":2441
* while lai is not NULL:
* try:
* udp = UDPTransport.__new__(UDPTransport) # <<<<<<<<<<<<<<
* udp._init(self, lai.ai_family)
* if reuse_port:
*/
__pyx_t_5 = __pyx_tp_new_6uvloop_4loop_UDPTransport(((PyTypeObject *)__pyx_ptype_6uvloop_4loop_UDPTransport), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2441, __pyx_L40_error)
__Pyx_GOTREF(__pyx_t_5);
if (!(likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_6uvloop_4loop_UDPTransport)))) __PYX_ERR(1, 2441, __pyx_L40_error)
__Pyx_GOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_udp));
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_udp, ((struct __pyx_obj_6uvloop_4loop_UDPTransport *)__pyx_t_5));
__Pyx_GIVEREF(__pyx_t_5);
__pyx_t_5 = 0;
/* "uvloop/loop.pyx":2442
* try:
* udp = UDPTransport.__new__(UDPTransport)
* udp._init(self, lai.ai_family) # <<<<<<<<<<<<<<
* if reuse_port:
* self._sock_set_reuseport(udp._fileno())
*/
__pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->_init(__pyx_cur_scope->__pyx_v_udp, __pyx_cur_scope->__pyx_v_self, __pyx_cur_scope->__pyx_v_lai->ai_family); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2442, __pyx_L40_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":2443
* udp = UDPTransport.__new__(UDPTransport)
* udp._init(self, lai.ai_family)
* if reuse_port: # <<<<<<<<<<<<<<
* self._sock_set_reuseport(udp._fileno())
* udp._bind(lai.ai_addr, reuse_address)
*/
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_reuse_port); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 2443, __pyx_L40_error)
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2444
* udp._init(self, lai.ai_family)
* if reuse_port:
* self._sock_set_reuseport(udp._fileno()) # <<<<<<<<<<<<<<
* udp._bind(lai.ai_addr, reuse_address)
* except Exception as ex:
*/
__pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._fileno(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_udp)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2444, __pyx_L40_error)
__Pyx_GOTREF(__pyx_t_5);
__pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 2444, __pyx_L40_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_cur_scope->__pyx_v_self->__pyx_vtab)->_sock_set_reuseport(__pyx_cur_scope->__pyx_v_self, __pyx_t_9); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2444, __pyx_L40_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":2443
* udp = UDPTransport.__new__(UDPTransport)
* udp._init(self, lai.ai_family)
* if reuse_port: # <<<<<<<<<<<<<<
* self._sock_set_reuseport(udp._fileno())
* udp._bind(lai.ai_addr, reuse_address)
*/
}
/* "uvloop/loop.pyx":2445
* if reuse_port:
* self._sock_set_reuseport(udp._fileno())
* udp._bind(lai.ai_addr, reuse_address) # <<<<<<<<<<<<<<
* except Exception as ex:
* lai = lai.ai_next
*/
__pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_reuse_address); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 2445, __pyx_L40_error)
__pyx_t_5 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->_bind(__pyx_cur_scope->__pyx_v_udp, __pyx_cur_scope->__pyx_v_lai->ai_addr, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2445, __pyx_L40_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":2440
* lai = (lads).data
* while lai is not NULL:
* try: # <<<<<<<<<<<<<<
* udp = UDPTransport.__new__(UDPTransport)
* udp._init(self, lai.ai_family)
*/
}
/* "uvloop/loop.pyx":2451
* continue
* else:
* break # <<<<<<<<<<<<<<
* else:
* ctx = None
*/
/*else:*/ {
goto __pyx_L45_try_break;
}
__pyx_L40_error:;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":2446
* self._sock_set_reuseport(udp._fileno())
* udp._bind(lai.ai_addr, reuse_address)
* except Exception as ex: # <<<<<<<<<<<<<<
* lai = lai.ai_next
* excs.append(ex)
*/
__pyx_t_9 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0])));
if (__pyx_t_9) {
__Pyx_AddTraceback("uvloop.loop.Loop.create_datagram_endpoint", __pyx_clineno, __pyx_lineno, __pyx_filename);
if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_3, &__pyx_t_8) < 0) __PYX_ERR(1, 2446, __pyx_L42_except_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GOTREF(__pyx_t_8);
__Pyx_INCREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_3);
__pyx_cur_scope->__pyx_v_ex = __pyx_t_3;
/*try:*/ {
/* "uvloop/loop.pyx":2447
* udp._bind(lai.ai_addr, reuse_address)
* except Exception as ex:
* lai = lai.ai_next # <<<<<<<<<<<<<<
* excs.append(ex)
* continue
*/
__pyx_t_14 = __pyx_cur_scope->__pyx_v_lai->ai_next;
__pyx_cur_scope->__pyx_v_lai = __pyx_t_14;
/* "uvloop/loop.pyx":2448
* except Exception as ex:
* lai = lai.ai_next
* excs.append(ex) # <<<<<<<<<<<<<<
* continue
* else:
*/
__pyx_t_19 = __Pyx_PyList_Append(__pyx_cur_scope->__pyx_v_excs, __pyx_cur_scope->__pyx_v_ex); if (unlikely(__pyx_t_19 == -1)) __PYX_ERR(1, 2448, __pyx_L54_error)
/* "uvloop/loop.pyx":2449
* lai = lai.ai_next
* excs.append(ex)
* continue # <<<<<<<<<<<<<<
* else:
* break
*/
goto __pyx_L51_continue;
}
/* "uvloop/loop.pyx":2446
* self._sock_set_reuseport(udp._fileno())
* udp._bind(lai.ai_addr, reuse_address)
* except Exception as ex: # <<<<<<<<<<<<<<
* lai = lai.ai_next
* excs.append(ex)
*/
/*finally:*/ {
/*exception exit:*/{
__Pyx_PyThreadState_declare
__pyx_L54_error:;
__pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; __pyx_t_24 = 0; __pyx_t_25 = 0; __pyx_t_26 = 0;
__Pyx_PyThreadState_assign
__Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_24, &__pyx_t_25, &__pyx_t_26);
if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_21, &__pyx_t_22, &__pyx_t_23) < 0)) __Pyx_ErrFetch(&__pyx_t_21, &__pyx_t_22, &__pyx_t_23);
__Pyx_XGOTREF(__pyx_t_21);
__Pyx_XGOTREF(__pyx_t_22);
__Pyx_XGOTREF(__pyx_t_23);
__Pyx_XGOTREF(__pyx_t_24);
__Pyx_XGOTREF(__pyx_t_25);
__Pyx_XGOTREF(__pyx_t_26);
__pyx_t_9 = __pyx_lineno; __pyx_t_7 = __pyx_clineno; __pyx_t_20 = __pyx_filename;
{
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_ex);
__Pyx_DECREF(__pyx_cur_scope->__pyx_v_ex);
__pyx_cur_scope->__pyx_v_ex = NULL;
}
__Pyx_PyThreadState_assign
if (PY_MAJOR_VERSION >= 3) {
__Pyx_XGIVEREF(__pyx_t_24);
__Pyx_XGIVEREF(__pyx_t_25);
__Pyx_XGIVEREF(__pyx_t_26);
__Pyx_ExceptionReset(__pyx_t_24, __pyx_t_25, __pyx_t_26);
}
__Pyx_XGIVEREF(__pyx_t_21);
__Pyx_XGIVEREF(__pyx_t_22);
__Pyx_XGIVEREF(__pyx_t_23);
__Pyx_ErrRestore(__pyx_t_21, __pyx_t_22, __pyx_t_23);
__pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; __pyx_t_24 = 0; __pyx_t_25 = 0; __pyx_t_26 = 0;
__pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_7; __pyx_filename = __pyx_t_20;
goto __pyx_L42_except_error;
}
__pyx_L51_continue: {
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_ex);
__Pyx_DECREF(__pyx_cur_scope->__pyx_v_ex);
__pyx_cur_scope->__pyx_v_ex = NULL;
goto __pyx_L50_except_continue;
}
}
__pyx_L50_except_continue:;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
goto __pyx_L46_try_continue;
}
goto __pyx_L42_except_error;
__pyx_L42_except_error:;
/* "uvloop/loop.pyx":2440
* lai = (lads).data
* while lai is not NULL:
* try: # <<<<<<<<<<<<<<
* udp = UDPTransport.__new__(UDPTransport)
* udp._init(self, lai.ai_family)
*/
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18);
goto __pyx_L1_error;
__pyx_L45_try_break:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18);
goto __pyx_L39_break;
__pyx_L46_try_continue:;
__Pyx_PyThreadState_assign
__Pyx_XGIVEREF(__pyx_t_16);
__Pyx_XGIVEREF(__pyx_t_17);
__Pyx_XGIVEREF(__pyx_t_18);
__Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18);
goto __pyx_L38_continue;
}
__pyx_L38_continue:;
}
/* "uvloop/loop.pyx":2453
* break
* else:
* ctx = None # <<<<<<<<<<<<<<
* if len(excs):
* ctx = excs[0]
*/
/*else*/ {
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__pyx_cur_scope->__pyx_v_ctx = Py_None;
/* "uvloop/loop.pyx":2454
* else:
* ctx = None
* if len(excs): # <<<<<<<<<<<<<<
* ctx = excs[0]
* raise OSError('could not bind to local_addr {}'.format(
*/
__pyx_t_12 = PyList_GET_SIZE(__pyx_cur_scope->__pyx_v_excs); if (unlikely(__pyx_t_12 == -1)) __PYX_ERR(1, 2454, __pyx_L1_error)
__pyx_t_1 = (__pyx_t_12 != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2455
* ctx = None
* if len(excs):
* ctx = excs[0] # <<<<<<<<<<<<<<
* raise OSError('could not bind to local_addr {}'.format(
* local_addr)) from ctx
*/
__pyx_t_8 = __Pyx_GetItemInt_List(__pyx_cur_scope->__pyx_v_excs, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2455, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_ctx);
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_ctx, __pyx_t_8);
__Pyx_GIVEREF(__pyx_t_8);
__pyx_t_8 = 0;
/* "uvloop/loop.pyx":2454
* else:
* ctx = None
* if len(excs): # <<<<<<<<<<<<<<
* ctx = excs[0]
* raise OSError('could not bind to local_addr {}'.format(
*/
}
/* "uvloop/loop.pyx":2456
* if len(excs):
* ctx = excs[0]
* raise OSError('could not bind to local_addr {}'.format( # <<<<<<<<<<<<<<
* local_addr)) from ctx
*
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_could_not_bind_to_local_addr, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2456, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
/* "uvloop/loop.pyx":2457
* ctx = excs[0]
* raise OSError('could not bind to local_addr {}'.format(
* local_addr)) from ctx # <<<<<<<<<<<<<<
*
* if rads is not None:
*/
__pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (!__pyx_t_5) {
__pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_cur_scope->__pyx_v_local_addr); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2456, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_cur_scope->__pyx_v_local_addr};
__pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2456, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_8);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_cur_scope->__pyx_v_local_addr};
__pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2456, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_8);
} else
#endif
{
__pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2456, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_local_addr);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_local_addr);
PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_cur_scope->__pyx_v_local_addr);
__pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_4, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2456, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":2456
* if len(excs):
* ctx = excs[0]
* raise OSError('could not bind to local_addr {}'.format( # <<<<<<<<<<<<<<
* local_addr)) from ctx
*
*/
__pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2456, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_8);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_8);
__pyx_t_8 = 0;
__pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2456, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":2457
* ctx = excs[0]
* raise OSError('could not bind to local_addr {}'.format(
* local_addr)) from ctx # <<<<<<<<<<<<<<
*
* if rads is not None:
*/
__Pyx_Raise(__pyx_t_8, 0, 0, __pyx_cur_scope->__pyx_v_ctx);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__PYX_ERR(1, 2456, __pyx_L1_error)
}
__pyx_L39_break:;
/* "uvloop/loop.pyx":2459
* local_addr)) from ctx
*
* if rads is not None: # <<<<<<<<<<<<<<
* rai = (rads).data
* sock = udp._get_socket()
*/
__pyx_t_1 = (__pyx_cur_scope->__pyx_v_rads != Py_None);
__pyx_t_10 = (__pyx_t_1 != 0);
if (__pyx_t_10) {
/* "uvloop/loop.pyx":2460
*
* if rads is not None:
* rai = (rads).data # <<<<<<<<<<<<<<
* sock = udp._get_socket()
* while rai is not NULL:
*/
__pyx_t_14 = ((struct __pyx_obj_6uvloop_4loop_AddrInfo *)__pyx_cur_scope->__pyx_v_rads)->data;
__pyx_cur_scope->__pyx_v_rai = __pyx_t_14;
/* "uvloop/loop.pyx":2461
* if rads is not None:
* rai = (rads).data
* sock = udp._get_socket() # <<<<<<<<<<<<<<
* while rai is not NULL:
* if rai.ai_family != lai.ai_family:
*/
__pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base.__pyx_base._get_socket(((struct __pyx_obj_6uvloop_4loop_UVSocketHandle *)__pyx_cur_scope->__pyx_v_udp)); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2461, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_GOTREF(__pyx_cur_scope->__pyx_v_sock);
__Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_sock, __pyx_t_8);
__Pyx_GIVEREF(__pyx_t_8);
__pyx_t_8 = 0;
/* "uvloop/loop.pyx":2462
* rai = (rads).data
* sock = udp._get_socket()
* while rai is not NULL: # <<<<<<<<<<<<<<
* if rai.ai_family != lai.ai_family:
* rai = rai.ai_next
*/
while (1) {
__pyx_t_10 = ((__pyx_cur_scope->__pyx_v_rai != NULL) != 0);
if (!__pyx_t_10) break;
/* "uvloop/loop.pyx":2463
* sock = udp._get_socket()
* while rai is not NULL:
* if rai.ai_family != lai.ai_family: # <<<<<<<<<<<<<<
* rai = rai.ai_next
* continue
*/
__pyx_t_10 = ((__pyx_cur_scope->__pyx_v_rai->ai_family != __pyx_cur_scope->__pyx_v_lai->ai_family) != 0);
if (__pyx_t_10) {
/* "uvloop/loop.pyx":2464
* while rai is not NULL:
* if rai.ai_family != lai.ai_family:
* rai = rai.ai_next # <<<<<<<<<<<<<<
* continue
* if rai.ai_protocol != lai.ai_protocol:
*/
__pyx_t_14 = __pyx_cur_scope->__pyx_v_rai->ai_next;
__pyx_cur_scope->__pyx_v_rai = __pyx_t_14;
/* "uvloop/loop.pyx":2465
* if rai.ai_family != lai.ai_family:
* rai = rai.ai_next
* continue # <<<<<<<<<<<<<<
* if rai.ai_protocol != lai.ai_protocol:
* rai = rai.ai_next
*/
goto __pyx_L62_continue;
/* "uvloop/loop.pyx":2463
* sock = udp._get_socket()
* while rai is not NULL:
* if rai.ai_family != lai.ai_family: # <<<<<<<<<<<<<<
* rai = rai.ai_next
* continue
*/
}
/* "uvloop/loop.pyx":2466
* rai = rai.ai_next
* continue
* if rai.ai_protocol != lai.ai_protocol: # <<<<<<<<<<<<<<
* rai = rai.ai_next
* continue
*/
__pyx_t_10 = ((__pyx_cur_scope->__pyx_v_rai->ai_protocol != __pyx_cur_scope->__pyx_v_lai->ai_protocol) != 0);
if (__pyx_t_10) {
/* "uvloop/loop.pyx":2467
* continue
* if rai.ai_protocol != lai.ai_protocol:
* rai = rai.ai_next # <<<<<<<<<<<<<<
* continue
* udp._set_remote_address(rai.ai_addr, rai.ai_addrlen)
*/
__pyx_t_14 = __pyx_cur_scope->__pyx_v_rai->ai_next;
__pyx_cur_scope->__pyx_v_rai = __pyx_t_14;
/* "uvloop/loop.pyx":2468
* if rai.ai_protocol != lai.ai_protocol:
* rai = rai.ai_next
* continue # <<<<<<<<<<<<<<
* udp._set_remote_address(rai.ai_addr, rai.ai_addrlen)
* break
*/
goto __pyx_L62_continue;
/* "uvloop/loop.pyx":2466
* rai = rai.ai_next
* continue
* if rai.ai_protocol != lai.ai_protocol: # <<<<<<<<<<<<<<
* rai = rai.ai_next
* continue
*/
}
/* "uvloop/loop.pyx":2469
* rai = rai.ai_next
* continue
* udp._set_remote_address(rai.ai_addr, rai.ai_addrlen) # <<<<<<<<<<<<<<
* break
* else:
*/
__pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->_set_remote_address(__pyx_cur_scope->__pyx_v_udp, __pyx_cur_scope->__pyx_v_rai->ai_addr, __pyx_cur_scope->__pyx_v_rai->ai_addrlen); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2469, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
/* "uvloop/loop.pyx":2470
* continue
* udp._set_remote_address(rai.ai_addr, rai.ai_addrlen)
* break # <<<<<<<<<<<<<<
* else:
* raise OSError(
*/
goto __pyx_L63_break;
__pyx_L62_continue:;
}
/* "uvloop/loop.pyx":2472
* break
* else:
* raise OSError( # <<<<<<<<<<<<<<
* 'could not bind to remote_addr {}'.format(
* remote_addr))
*/
/*else*/ {
/* "uvloop/loop.pyx":2473
* else:
* raise OSError(
* 'could not bind to remote_addr {}'.format( # <<<<<<<<<<<<<<
* remote_addr))
*
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_could_not_bind_to_remote_addr, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2473, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
/* "uvloop/loop.pyx":2474
* raise OSError(
* 'could not bind to remote_addr {}'.format(
* remote_addr)) # <<<<<<<<<<<<<<
*
* udp._set_remote_address(rai.ai_addr, rai.ai_addrlen)
*/
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (!__pyx_t_4) {
__pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_cur_scope->__pyx_v_remote_addr); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2473, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_cur_scope->__pyx_v_remote_addr};
__pyx_t_8 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2473, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_8);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_cur_scope->__pyx_v_remote_addr};
__pyx_t_8 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2473, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_8);
} else
#endif
{
__pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2473, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_remote_addr);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_remote_addr);
PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_cur_scope->__pyx_v_remote_addr);
__pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2473, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":2472
* break
* else:
* raise OSError( # <<<<<<<<<<<<<<
* 'could not bind to remote_addr {}'.format(
* remote_addr))
*/
__pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2472, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_8);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_8);
__pyx_t_8 = 0;
__pyx_t_8 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2472, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_Raise(__pyx_t_8, 0, 0, 0);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__PYX_ERR(1, 2472, __pyx_L1_error)
}
__pyx_L63_break:;
/* "uvloop/loop.pyx":2476
* remote_addr))
*
* udp._set_remote_address(rai.ai_addr, rai.ai_addrlen) # <<<<<<<<<<<<<<
*
* if allow_broadcast:
*/
__pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->_set_remote_address(__pyx_cur_scope->__pyx_v_udp, __pyx_cur_scope->__pyx_v_rai->ai_addr, __pyx_cur_scope->__pyx_v_rai->ai_addrlen); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2476, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
/* "uvloop/loop.pyx":2459
* local_addr)) from ctx
*
* if rads is not None: # <<<<<<<<<<<<<<
* rai = (rads).data
* sock = udp._get_socket()
*/
}
}
__pyx_L32:;
}
__pyx_L4:;
/* "uvloop/loop.pyx":2478
* udp._set_remote_address(rai.ai_addr, rai.ai_addrlen)
*
* if allow_broadcast: # <<<<<<<<<<<<<<
* udp._set_broadcast(1)
*
*/
__pyx_t_10 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_allow_broadcast); if (unlikely(__pyx_t_10 < 0)) __PYX_ERR(1, 2478, __pyx_L1_error)
if (__pyx_t_10) {
/* "uvloop/loop.pyx":2479
*
* if allow_broadcast:
* udp._set_broadcast(1) # <<<<<<<<<<<<<<
*
* protocol = protocol_factory()
*/
__pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->_set_broadcast(__pyx_cur_scope->__pyx_v_udp, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2479, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
/* "uvloop/loop.pyx":2478
* udp._set_remote_address(rai.ai_addr, rai.ai_addrlen)
*
* if allow_broadcast: # <<<<<<<<<<<<<<
* udp._set_broadcast(1)
*
*/
}
/* "uvloop/loop.pyx":2481
* udp._set_broadcast(1)
*
* protocol = protocol_factory() # <<<<<<<<<<<<<<
* waiter = self._new_future()
* assert udp is not None
*/
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol_factory);
__pyx_t_3 = __pyx_cur_scope->__pyx_v_protocol_factory; __pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (__pyx_t_5) {
__pyx_t_8 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2481, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
} else {
__pyx_t_8 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2481, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GIVEREF(__pyx_t_8);
__pyx_cur_scope->__pyx_v_protocol = __pyx_t_8;
__pyx_t_8 = 0;
/* "uvloop/loop.pyx":2482
*
* protocol = protocol_factory()
* waiter = self._new_future() # <<<<<<<<<<<<<<
* assert udp is not None
* udp._set_protocol(protocol)
*/
__pyx_t_8 = __pyx_f_6uvloop_4loop_4Loop__new_future(__pyx_cur_scope->__pyx_v_self); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2482, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_GIVEREF(__pyx_t_8);
__pyx_cur_scope->__pyx_v_waiter = __pyx_t_8;
__pyx_t_8 = 0;
/* "uvloop/loop.pyx":2483
* protocol = protocol_factory()
* waiter = self._new_future()
* assert udp is not None # <<<<<<<<<<<<<<
* udp._set_protocol(protocol)
* udp._set_waiter(waiter)
*/
#ifndef CYTHON_WITHOUT_ASSERTIONS
if (unlikely(!Py_OptimizeFlag)) {
__pyx_t_10 = (((PyObject *)__pyx_cur_scope->__pyx_v_udp) != Py_None);
if (unlikely(!(__pyx_t_10 != 0))) {
PyErr_SetNone(PyExc_AssertionError);
__PYX_ERR(1, 2483, __pyx_L1_error)
}
}
#endif
/* "uvloop/loop.pyx":2484
* waiter = self._new_future()
* assert udp is not None
* udp._set_protocol(protocol) # <<<<<<<<<<<<<<
* udp._set_waiter(waiter)
* udp._init_protocol()
*/
__pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._set_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_cur_scope->__pyx_v_udp), __pyx_cur_scope->__pyx_v_protocol); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2484, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
/* "uvloop/loop.pyx":2485
* assert udp is not None
* udp._set_protocol(protocol)
* udp._set_waiter(waiter) # <<<<<<<<<<<<<<
* udp._init_protocol()
*
*/
__pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._set_waiter(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_cur_scope->__pyx_v_udp), __pyx_cur_scope->__pyx_v_waiter); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2485, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
/* "uvloop/loop.pyx":2486
* udp._set_protocol(protocol)
* udp._set_waiter(waiter)
* udp._init_protocol() # <<<<<<<<<<<<<<
*
* await waiter
*/
__pyx_t_8 = ((struct __pyx_vtabstruct_6uvloop_4loop_UDPTransport *)__pyx_cur_scope->__pyx_v_udp->__pyx_base.__pyx_base.__pyx_base.__pyx_vtab)->__pyx_base._init_protocol(((struct __pyx_obj_6uvloop_4loop_UVBaseTransport *)__pyx_cur_scope->__pyx_v_udp)); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2486, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
/* "uvloop/loop.pyx":2488
* udp._init_protocol()
*
* await waiter # <<<<<<<<<<<<<<
* return udp, protocol
*
*/
__pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_waiter);
__Pyx_XGOTREF(__pyx_r);
if (likely(__pyx_r)) {
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
/* return from generator, yielding value */
__pyx_generator->resume_label = 3;
return __pyx_r;
__pyx_L67_resume_from_yield:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 2488, __pyx_L1_error)
} else {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(1, 2488, __pyx_L1_error)
}
}
/* "uvloop/loop.pyx":2489
*
* await waiter
* return udp, protocol # <<<<<<<<<<<<<<
*
* def _asyncgen_finalizer_hook(self, agen):
*/
__Pyx_XDECREF(__pyx_r);
__pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2489, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_udp));
__Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_udp));
PyTuple_SET_ITEM(__pyx_t_8, 0, ((PyObject *)__pyx_cur_scope->__pyx_v_udp));
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_protocol);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_protocol);
PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_cur_scope->__pyx_v_protocol);
__pyx_r = NULL; __Pyx_ReturnWithStopIteration(__pyx_t_8);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__pyx_t_8 = 0;
goto __pyx_L0;
CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
/* "uvloop/loop.pyx":2330
* return True
*
* async def create_datagram_endpoint(self, protocol_factory, # <<<<<<<<<<<<<<
* local_addr=None, remote_addr=None, *,
* family=0, proto=0, flags=0,
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_AddTraceback("create_datagram_endpoint", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_L0:;
__Pyx_XDECREF(__pyx_r); __pyx_r = 0;
__pyx_generator->resume_label = -1;
__Pyx_Coroutine_clear((PyObject*)__pyx_generator);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":2491
* return udp, protocol
*
* def _asyncgen_finalizer_hook(self, agen): # <<<<<<<<<<<<<<
* self._asyncgens.discard(agen)
* if not self.is_closed():
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_117_asyncgen_finalizer_hook(PyObject *__pyx_v_self, PyObject *__pyx_v_agen); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_116_asyncgen_finalizer_hook[] = "Loop._asyncgen_finalizer_hook(self, agen)";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_117_asyncgen_finalizer_hook(PyObject *__pyx_v_self, PyObject *__pyx_v_agen) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("_asyncgen_finalizer_hook (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_116_asyncgen_finalizer_hook(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_agen));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_116_asyncgen_finalizer_hook(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_agen) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
int __pyx_t_5;
int __pyx_t_6;
PyObject *__pyx_t_7 = NULL;
__Pyx_RefNannySetupContext("_asyncgen_finalizer_hook", 0);
/* "uvloop/loop.pyx":2492
*
* def _asyncgen_finalizer_hook(self, agen):
* self._asyncgens.discard(agen) # <<<<<<<<<<<<<<
* if not self.is_closed():
* self.create_task(agen.aclose())
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_asyncgens, __pyx_n_s_discard); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2492, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (!__pyx_t_3) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_agen); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2492, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_agen};
__pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2492, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_agen};
__pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2492, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else
#endif
{
__pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2492, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_INCREF(__pyx_v_agen);
__Pyx_GIVEREF(__pyx_v_agen);
PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_agen);
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2492, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":2493
* def _asyncgen_finalizer_hook(self, agen):
* self._asyncgens.discard(agen)
* if not self.is_closed(): # <<<<<<<<<<<<<<
* self.create_task(agen.aclose())
* # Wake up the loop if the finalizer was called from
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_is_closed); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2493, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (__pyx_t_4) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2493, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
__pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2493, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(1, 2493, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__pyx_t_6 = ((!__pyx_t_5) != 0);
if (__pyx_t_6) {
/* "uvloop/loop.pyx":2494
* self._asyncgens.discard(agen)
* if not self.is_closed():
* self.create_task(agen.aclose()) # <<<<<<<<<<<<<<
* # Wake up the loop if the finalizer was called from
* # a different thread.
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_create_task); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2494, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_agen, __pyx_n_s_aclose); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2494, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_7 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_7)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_7);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (__pyx_t_7) {
__pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2494, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else {
__pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2494, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (!__pyx_t_3) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2494, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4};
__pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2494, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4};
__pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2494, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
{
__pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2494, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_4);
__pyx_t_4 = 0;
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2494, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":2497
* # Wake up the loop if the finalizer was called from
* # a different thread.
* self.handler_async.send() # <<<<<<<<<<<<<<
*
* def _asyncgen_firstiter_hook(self, agen):
*/
__pyx_t_1 = ((struct __pyx_vtabstruct_6uvloop_4loop_UVAsync *)__pyx_v_self->handler_async->__pyx_base.__pyx_vtab)->send(__pyx_v_self->handler_async); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2497, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
/* "uvloop/loop.pyx":2493
* def _asyncgen_finalizer_hook(self, agen):
* self._asyncgens.discard(agen)
* if not self.is_closed(): # <<<<<<<<<<<<<<
* self.create_task(agen.aclose())
* # Wake up the loop if the finalizer was called from
*/
}
/* "uvloop/loop.pyx":2491
* return udp, protocol
*
* def _asyncgen_finalizer_hook(self, agen): # <<<<<<<<<<<<<<
* self._asyncgens.discard(agen)
* if not self.is_closed():
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_AddTraceback("uvloop.loop.Loop._asyncgen_finalizer_hook", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":2499
* self.handler_async.send()
*
* def _asyncgen_firstiter_hook(self, agen): # <<<<<<<<<<<<<<
* if self._asyncgens_shutdown_called:
* warnings_warn(
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_119_asyncgen_firstiter_hook(PyObject *__pyx_v_self, PyObject *__pyx_v_agen); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_118_asyncgen_firstiter_hook[] = "Loop._asyncgen_firstiter_hook(self, agen)";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_119_asyncgen_firstiter_hook(PyObject *__pyx_v_self, PyObject *__pyx_v_agen) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("_asyncgen_firstiter_hook (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_118_asyncgen_firstiter_hook(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_agen));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_118_asyncgen_firstiter_hook(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_agen) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
__Pyx_RefNannySetupContext("_asyncgen_firstiter_hook", 0);
/* "uvloop/loop.pyx":2500
*
* def _asyncgen_firstiter_hook(self, agen):
* if self._asyncgens_shutdown_called: # <<<<<<<<<<<<<<
* warnings_warn(
* "asynchronous generator {!r} was scheduled after "
*/
__pyx_t_1 = (__pyx_v_self->_asyncgens_shutdown_called != 0);
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2503
* warnings_warn(
* "asynchronous generator {!r} was scheduled after "
* "loop.shutdown_asyncgens() call".format(agen), # <<<<<<<<<<<<<<
* ResourceWarning, source=self)
*
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_asynchronous_generator_r_was_sch, __pyx_n_s_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2503, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) {
__pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3);
if (likely(__pyx_t_4)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3);
__Pyx_INCREF(__pyx_t_4);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_3, function);
}
}
if (!__pyx_t_4) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_agen); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2503, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_agen};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2503, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) {
PyObject *__pyx_temp[2] = {__pyx_t_4, __pyx_v_agen};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2503, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else
#endif
{
__pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2503, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL;
__Pyx_INCREF(__pyx_v_agen);
__Pyx_GIVEREF(__pyx_v_agen);
PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_v_agen);
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2503, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
}
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
/* "uvloop/loop.pyx":2501
* def _asyncgen_firstiter_hook(self, agen):
* if self._asyncgens_shutdown_called:
* warnings_warn( # <<<<<<<<<<<<<<
* "asynchronous generator {!r} was scheduled after "
* "loop.shutdown_asyncgens() call".format(agen),
*/
__pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 2501, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_GIVEREF(__pyx_t_2);
PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2);
__Pyx_INCREF(__pyx_builtin_ResourceWarning);
__Pyx_GIVEREF(__pyx_builtin_ResourceWarning);
PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_builtin_ResourceWarning);
__pyx_t_2 = 0;
/* "uvloop/loop.pyx":2504
* "asynchronous generator {!r} was scheduled after "
* "loop.shutdown_asyncgens() call".format(agen),
* ResourceWarning, source=self) # <<<<<<<<<<<<<<
*
* self._asyncgens.add(agen)
*/
__pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2504, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_source, ((PyObject *)__pyx_v_self)) < 0) __PYX_ERR(1, 2504, __pyx_L1_error)
/* "uvloop/loop.pyx":2501
* def _asyncgen_firstiter_hook(self, agen):
* if self._asyncgens_shutdown_called:
* warnings_warn( # <<<<<<<<<<<<<<
* "asynchronous generator {!r} was scheduled after "
* "loop.shutdown_asyncgens() call".format(agen),
*/
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_v_6uvloop_4loop_warnings_warn, __pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2501, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":2500
*
* def _asyncgen_firstiter_hook(self, agen):
* if self._asyncgens_shutdown_called: # <<<<<<<<<<<<<<
* warnings_warn(
* "asynchronous generator {!r} was scheduled after "
*/
}
/* "uvloop/loop.pyx":2506
* ResourceWarning, source=self)
*
* self._asyncgens.add(agen) # <<<<<<<<<<<<<<
*
* async def shutdown_asyncgens(self):
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_self->_asyncgens, __pyx_n_s_add); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 2506, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (!__pyx_t_3) {
__pyx_t_5 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v_agen); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2506, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_agen};
__pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2506, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_v_agen};
__pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2506, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_5);
} else
#endif
{
__pyx_t_4 = PyTuple_New(1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2506, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_INCREF(__pyx_v_agen);
__Pyx_GIVEREF(__pyx_v_agen);
PyTuple_SET_ITEM(__pyx_t_4, 0+1, __pyx_v_agen);
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 2506, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
}
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
/* "uvloop/loop.pyx":2499
* self.handler_async.send()
*
* def _asyncgen_firstiter_hook(self, agen): # <<<<<<<<<<<<<<
* if self._asyncgens_shutdown_called:
* warnings_warn(
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("uvloop.loop.Loop._asyncgen_firstiter_hook", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_122generator12(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */
/* "uvloop/loop.pyx":2508
* self._asyncgens.add(agen)
*
* async def shutdown_asyncgens(self): # <<<<<<<<<<<<<<
* """Shutdown all active asynchronous generators."""
* self._asyncgens_shutdown_called = True
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_121shutdown_asyncgens(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/
static char __pyx_doc_6uvloop_4loop_4Loop_120shutdown_asyncgens[] = "Loop.shutdown_asyncgens(self)\nShutdown all active asynchronous generators.";
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_121shutdown_asyncgens(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("shutdown_asyncgens (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_120shutdown_asyncgens(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_120shutdown_asyncgens(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_19_shutdown_asyncgens *__pyx_cur_scope;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("shutdown_asyncgens", 0);
__pyx_cur_scope = (struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_19_shutdown_asyncgens *)__pyx_tp_new_6uvloop_4loop___pyx_scope_struct_19_shutdown_asyncgens(__pyx_ptype_6uvloop_4loop___pyx_scope_struct_19_shutdown_asyncgens, __pyx_empty_tuple, NULL);
if (unlikely(!__pyx_cur_scope)) {
__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_19_shutdown_asyncgens *)Py_None);
__Pyx_INCREF(Py_None);
__PYX_ERR(1, 2508, __pyx_L1_error)
} else {
__Pyx_GOTREF(__pyx_cur_scope);
}
__pyx_cur_scope->__pyx_v_self = __pyx_v_self;
__Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
__Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_self);
{
__pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_6uvloop_4loop_4Loop_122generator12, (PyObject *) __pyx_cur_scope, __pyx_n_s_shutdown_asyncgens, __pyx_n_s_Loop_shutdown_asyncgens, __pyx_n_s_uvloop_loop); if (unlikely(!gen)) __PYX_ERR(1, 2508, __pyx_L1_error)
__Pyx_DECREF(__pyx_cur_scope);
__Pyx_RefNannyFinishContext();
return (PyObject *) gen;
}
/* function exit code */
__pyx_L1_error:;
__Pyx_AddTraceback("uvloop.loop.Loop.shutdown_asyncgens", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__Pyx_DECREF(((PyObject *)__pyx_cur_scope));
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_gb_6uvloop_4loop_4Loop_122generator12(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */
{
struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_19_shutdown_asyncgens *__pyx_cur_scope = ((struct __pyx_obj_6uvloop_4loop___pyx_scope_struct_19_shutdown_asyncgens *)__pyx_generator->closure);
PyObject *__pyx_r = NULL;
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
PyObject *__pyx_t_4 = NULL;
Py_ssize_t __pyx_t_5;
PyObject *__pyx_t_6 = NULL;
PyObject *__pyx_t_7 = NULL;
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
PyObject *(*__pyx_t_10)(PyObject *);
PyObject *(*__pyx_t_11)(PyObject *);
PyObject *__pyx_t_12 = NULL;
PyObject *__pyx_t_13 = NULL;
PyObject *__pyx_t_14 = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("None", 0);
switch (__pyx_generator->resume_label) {
case 0: goto __pyx_L3_first_run;
case 1: goto __pyx_L13_resume_from_yield;
default: /* CPython raises the right error here */
__Pyx_RefNannyFinishContext();
return NULL;
}
__pyx_L3_first_run:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 2508, __pyx_L1_error)
/* "uvloop/loop.pyx":2510
* async def shutdown_asyncgens(self):
* """Shutdown all active asynchronous generators."""
* self._asyncgens_shutdown_called = True # <<<<<<<<<<<<<<
*
* if self._asyncgens is None or not len(self._asyncgens):
*/
__pyx_cur_scope->__pyx_v_self->_asyncgens_shutdown_called = 1;
/* "uvloop/loop.pyx":2512
* self._asyncgens_shutdown_called = True
*
* if self._asyncgens is None or not len(self._asyncgens): # <<<<<<<<<<<<<<
* # If Python version is <3.6 or we don't have any asynchronous
* # generators alive.
*/
__pyx_t_2 = (__pyx_cur_scope->__pyx_v_self->_asyncgens == Py_None);
__pyx_t_3 = (__pyx_t_2 != 0);
if (!__pyx_t_3) {
} else {
__pyx_t_1 = __pyx_t_3;
goto __pyx_L5_bool_binop_done;
}
__pyx_t_4 = __pyx_cur_scope->__pyx_v_self->_asyncgens;
__Pyx_INCREF(__pyx_t_4);
__pyx_t_5 = PyObject_Length(__pyx_t_4); if (unlikely(__pyx_t_5 == -1)) __PYX_ERR(1, 2512, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_3 = ((!(__pyx_t_5 != 0)) != 0);
__pyx_t_1 = __pyx_t_3;
__pyx_L5_bool_binop_done:;
if (__pyx_t_1) {
/* "uvloop/loop.pyx":2515
* # If Python version is <3.6 or we don't have any asynchronous
* # generators alive.
* return # <<<<<<<<<<<<<<
*
* closing_agens = list(self._asyncgens)
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = NULL;
goto __pyx_L0;
/* "uvloop/loop.pyx":2512
* self._asyncgens_shutdown_called = True
*
* if self._asyncgens is None or not len(self._asyncgens): # <<<<<<<<<<<<<<
* # If Python version is <3.6 or we don't have any asynchronous
* # generators alive.
*/
}
/* "uvloop/loop.pyx":2517
* return
*
* closing_agens = list(self._asyncgens) # <<<<<<<<<<<<<<
* self._asyncgens.clear()
*
*/
__pyx_t_4 = PySequence_List(__pyx_cur_scope->__pyx_v_self->_asyncgens); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2517, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_GIVEREF(__pyx_t_4);
__pyx_cur_scope->__pyx_v_closing_agens = ((PyObject*)__pyx_t_4);
__pyx_t_4 = 0;
/* "uvloop/loop.pyx":2518
*
* closing_agens = list(self._asyncgens)
* self._asyncgens.clear() # <<<<<<<<<<<<<<
*
* shutdown_coro = aio_gather(
*/
__pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_self->_asyncgens, __pyx_n_s_clear); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2518, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_7 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) {
__pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6);
if (likely(__pyx_t_7)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6);
__Pyx_INCREF(__pyx_t_7);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_6, function);
}
}
if (__pyx_t_7) {
__pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2518, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
} else {
__pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2518, __pyx_L1_error)
}
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":2520
* self._asyncgens.clear()
*
* shutdown_coro = aio_gather( # <<<<<<<<<<<<<<
* *[ag.aclose() for ag in closing_agens],
* return_exceptions=True,
*/
{ /* enter inner scope */
PyObject *__pyx_8genexpr4__pyx_v_ag = NULL;
/* "uvloop/loop.pyx":2521
*
* shutdown_coro = aio_gather(
* *[ag.aclose() for ag in closing_agens], # <<<<<<<<<<<<<<
* return_exceptions=True,
* loop=self)
*/
__pyx_t_4 = PyList_New(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2521, __pyx_L9_error)
__Pyx_GOTREF(__pyx_t_4);
__pyx_t_6 = __pyx_cur_scope->__pyx_v_closing_agens; __Pyx_INCREF(__pyx_t_6); __pyx_t_5 = 0;
for (;;) {
if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_6)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_7 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 2521, __pyx_L9_error)
#else
__pyx_t_7 = PySequence_ITEM(__pyx_t_6, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2521, __pyx_L9_error)
__Pyx_GOTREF(__pyx_t_7);
#endif
__Pyx_XDECREF_SET(__pyx_8genexpr4__pyx_v_ag, __pyx_t_7);
__pyx_t_7 = 0;
__pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_8genexpr4__pyx_v_ag, __pyx_n_s_aclose); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2521, __pyx_L9_error)
__Pyx_GOTREF(__pyx_t_8);
__pyx_t_9 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) {
__pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8);
if (likely(__pyx_t_9)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
__Pyx_INCREF(__pyx_t_9);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_8, function);
}
}
if (__pyx_t_9) {
__pyx_t_7 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2521, __pyx_L9_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
} else {
__pyx_t_7 = __Pyx_PyObject_CallNoArg(__pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2521, __pyx_L9_error)
}
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
if (unlikely(__Pyx_ListComp_Append(__pyx_t_4, (PyObject*)__pyx_t_7))) __PYX_ERR(1, 2521, __pyx_L9_error)
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
}
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_XDECREF(__pyx_8genexpr4__pyx_v_ag);
goto __pyx_L12_exit_scope;
__pyx_L9_error:;
__Pyx_XDECREF(__pyx_8genexpr4__pyx_v_ag);
goto __pyx_L1_error;
__pyx_L12_exit_scope:;
} /* exit inner scope */
/* "uvloop/loop.pyx":2520
* self._asyncgens.clear()
*
* shutdown_coro = aio_gather( # <<<<<<<<<<<<<<
* *[ag.aclose() for ag in closing_agens],
* return_exceptions=True,
*/
__pyx_t_6 = PySequence_Tuple(__pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2520, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":2522
* shutdown_coro = aio_gather(
* *[ag.aclose() for ag in closing_agens],
* return_exceptions=True, # <<<<<<<<<<<<<<
* loop=self)
*
*/
__pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2522, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_return_exceptions, Py_True) < 0) __PYX_ERR(1, 2522, __pyx_L1_error)
/* "uvloop/loop.pyx":2523
* *[ag.aclose() for ag in closing_agens],
* return_exceptions=True,
* loop=self) # <<<<<<<<<<<<<<
*
* results = await shutdown_coro
*/
if (PyDict_SetItem(__pyx_t_4, __pyx_n_s_loop, ((PyObject *)__pyx_cur_scope->__pyx_v_self)) < 0) __PYX_ERR(1, 2522, __pyx_L1_error)
/* "uvloop/loop.pyx":2520
* self._asyncgens.clear()
*
* shutdown_coro = aio_gather( # <<<<<<<<<<<<<<
* *[ag.aclose() for ag in closing_agens],
* return_exceptions=True,
*/
__pyx_t_7 = __Pyx_PyObject_Call(__pyx_v_6uvloop_4loop_aio_gather, __pyx_t_6, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2520, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GIVEREF(__pyx_t_7);
__pyx_cur_scope->__pyx_v_shutdown_coro = __pyx_t_7;
__pyx_t_7 = 0;
/* "uvloop/loop.pyx":2525
* loop=self)
*
* results = await shutdown_coro # <<<<<<<<<<<<<<
* for result, agen in zip(results, closing_agens):
* if isinstance(result, Exception):
*/
__pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_cur_scope->__pyx_v_shutdown_coro);
__Pyx_XGOTREF(__pyx_r);
if (likely(__pyx_r)) {
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
/* return from generator, yielding value */
__pyx_generator->resume_label = 1;
return __pyx_r;
__pyx_L13_resume_from_yield:;
if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 2525, __pyx_L1_error)
__pyx_t_7 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_7);
} else {
__pyx_t_7 = NULL;
if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_7) < 0) __PYX_ERR(1, 2525, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
}
__Pyx_GIVEREF(__pyx_t_7);
__pyx_cur_scope->__pyx_v_results = __pyx_t_7;
__pyx_t_7 = 0;
/* "uvloop/loop.pyx":2526
*
* results = await shutdown_coro
* for result, agen in zip(results, closing_agens): # <<<<<<<<<<<<<<
* if isinstance(result, Exception):
* self.call_exception_handler({
*/
__pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2526, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_results);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_results);
PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_cur_scope->__pyx_v_results);
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_closing_agens);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_closing_agens);
PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_cur_scope->__pyx_v_closing_agens);
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_zip, __pyx_t_7, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2526, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
if (likely(PyList_CheckExact(__pyx_t_4)) || PyTuple_CheckExact(__pyx_t_4)) {
__pyx_t_7 = __pyx_t_4; __Pyx_INCREF(__pyx_t_7); __pyx_t_5 = 0;
__pyx_t_10 = NULL;
} else {
__pyx_t_5 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 2526, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_7);
__pyx_t_10 = Py_TYPE(__pyx_t_7)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 2526, __pyx_L1_error)
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
for (;;) {
if (likely(!__pyx_t_10)) {
if (likely(PyList_CheckExact(__pyx_t_7))) {
if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_7)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_4 = PyList_GET_ITEM(__pyx_t_7, __pyx_t_5); __Pyx_INCREF(__pyx_t_4); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 2526, __pyx_L1_error)
#else
__pyx_t_4 = PySequence_ITEM(__pyx_t_7, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2526, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
} else {
if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_7)) break;
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
__pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_5); __Pyx_INCREF(__pyx_t_4); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 2526, __pyx_L1_error)
#else
__pyx_t_4 = PySequence_ITEM(__pyx_t_7, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2526, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
#endif
}
} else {
__pyx_t_4 = __pyx_t_10(__pyx_t_7);
if (unlikely(!__pyx_t_4)) {
PyObject* exc_type = PyErr_Occurred();
if (exc_type) {
if (likely(exc_type == PyExc_StopIteration || PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear();
else __PYX_ERR(1, 2526, __pyx_L1_error)
}
break;
}
__Pyx_GOTREF(__pyx_t_4);
}
if ((likely(PyTuple_CheckExact(__pyx_t_4))) || (PyList_CheckExact(__pyx_t_4))) {
PyObject* sequence = __pyx_t_4;
#if !CYTHON_COMPILING_IN_PYPY
Py_ssize_t size = Py_SIZE(sequence);
#else
Py_ssize_t size = PySequence_Size(sequence);
#endif
if (unlikely(size != 2)) {
if (size > 2) __Pyx_RaiseTooManyValuesError(2);
else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size);
__PYX_ERR(1, 2526, __pyx_L1_error)
}
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
if (likely(PyTuple_CheckExact(sequence))) {
__pyx_t_6 = PyTuple_GET_ITEM(sequence, 0);
__pyx_t_8 = PyTuple_GET_ITEM(sequence, 1);
} else {
__pyx_t_6 = PyList_GET_ITEM(sequence, 0);
__pyx_t_8 = PyList_GET_ITEM(sequence, 1);
}
__Pyx_INCREF(__pyx_t_6);
__Pyx_INCREF(__pyx_t_8);
#else
__pyx_t_6 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2526, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_8 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2526, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
#endif
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else {
Py_ssize_t index = -1;
__pyx_t_9 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 2526, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__pyx_t_11 = Py_TYPE(__pyx_t_9)->tp_iternext;
index = 0; __pyx_t_6 = __pyx_t_11(__pyx_t_9); if (unlikely(!__pyx_t_6)) goto __pyx_L16_unpacking_failed;
__Pyx_GOTREF(__pyx_t_6);
index = 1; __pyx_t_8 = __pyx_t_11(__pyx_t_9); if (unlikely(!__pyx_t_8)) goto __pyx_L16_unpacking_failed;
__Pyx_GOTREF(__pyx_t_8);
if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_9), 2) < 0) __PYX_ERR(1, 2526, __pyx_L1_error)
__pyx_t_11 = NULL;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
goto __pyx_L17_unpacking_done;
__pyx_L16_unpacking_failed:;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__pyx_t_11 = NULL;
if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index);
__PYX_ERR(1, 2526, __pyx_L1_error)
__pyx_L17_unpacking_done:;
}
__Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_result);
__Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_result, __pyx_t_6);
__Pyx_GIVEREF(__pyx_t_6);
__pyx_t_6 = 0;
__Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_agen);
__Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_agen, __pyx_t_8);
__Pyx_GIVEREF(__pyx_t_8);
__pyx_t_8 = 0;
/* "uvloop/loop.pyx":2527
* results = await shutdown_coro
* for result, agen in zip(results, closing_agens):
* if isinstance(result, Exception): # <<<<<<<<<<<<<<
* self.call_exception_handler({
* 'message': 'an error occurred during closing of '
*/
__pyx_t_1 = __Pyx_PyException_Check(__pyx_cur_scope->__pyx_v_result);
__pyx_t_3 = (__pyx_t_1 != 0);
if (__pyx_t_3) {
/* "uvloop/loop.pyx":2528
* for result, agen in zip(results, closing_agens):
* if isinstance(result, Exception):
* self.call_exception_handler({ # <<<<<<<<<<<<<<
* 'message': 'an error occurred during closing of '
* 'asynchronous generator {!r}'.format(agen),
*/
__pyx_t_8 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_cur_scope->__pyx_v_self), __pyx_n_s_call_exception_handler); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 2528, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_8);
/* "uvloop/loop.pyx":2529
* if isinstance(result, Exception):
* self.call_exception_handler({
* 'message': 'an error occurred during closing of ' # <<<<<<<<<<<<<<
* 'asynchronous generator {!r}'.format(agen),
* 'exception': result,
*/
__pyx_t_6 = PyDict_New(); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 2529, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
/* "uvloop/loop.pyx":2530
* self.call_exception_handler({
* 'message': 'an error occurred during closing of '
* 'asynchronous generator {!r}'.format(agen), # <<<<<<<<<<<<<<
* 'exception': result,
* 'asyncgen': agen
*/
__pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_an_error_occurred_during_closing, __pyx_n_s_format); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 2530, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__pyx_t_13 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_12))) {
__pyx_t_13 = PyMethod_GET_SELF(__pyx_t_12);
if (likely(__pyx_t_13)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_12);
__Pyx_INCREF(__pyx_t_13);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_12, function);
}
}
if (!__pyx_t_13) {
__pyx_t_9 = __Pyx_PyObject_CallOneArg(__pyx_t_12, __pyx_cur_scope->__pyx_v_agen); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 2530, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_12)) {
PyObject *__pyx_temp[2] = {__pyx_t_13, __pyx_cur_scope->__pyx_v_agen};
__pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_12, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 2530, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
__Pyx_GOTREF(__pyx_t_9);
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_12)) {
PyObject *__pyx_temp[2] = {__pyx_t_13, __pyx_cur_scope->__pyx_v_agen};
__pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_12, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 2530, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0;
__Pyx_GOTREF(__pyx_t_9);
} else
#endif
{
__pyx_t_14 = PyTuple_New(1+1); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 2530, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_14);
__Pyx_GIVEREF(__pyx_t_13); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_13); __pyx_t_13 = NULL;
__Pyx_INCREF(__pyx_cur_scope->__pyx_v_agen);
__Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_agen);
PyTuple_SET_ITEM(__pyx_t_14, 0+1, __pyx_cur_scope->__pyx_v_agen);
__pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_12, __pyx_t_14, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 2530, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0;
}
}
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_message, __pyx_t_9) < 0) __PYX_ERR(1, 2529, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
/* "uvloop/loop.pyx":2531
* 'message': 'an error occurred during closing of '
* 'asynchronous generator {!r}'.format(agen),
* 'exception': result, # <<<<<<<<<<<<<<
* 'asyncgen': agen
* })
*/
if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_exception, __pyx_cur_scope->__pyx_v_result) < 0) __PYX_ERR(1, 2529, __pyx_L1_error)
/* "uvloop/loop.pyx":2533
* 'exception': result,
* 'asyncgen': agen
* }) # <<<<<<<<<<<<<<
*
*
*/
if (PyDict_SetItem(__pyx_t_6, __pyx_n_u_asyncgen, __pyx_cur_scope->__pyx_v_agen) < 0) __PYX_ERR(1, 2529, __pyx_L1_error)
__pyx_t_9 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) {
__pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8);
if (likely(__pyx_t_9)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
__Pyx_INCREF(__pyx_t_9);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_8, function);
}
}
if (!__pyx_t_9) {
__pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2528, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_GOTREF(__pyx_t_4);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_8)) {
PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_t_6};
__pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2528, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) {
PyObject *__pyx_temp[2] = {__pyx_t_9, __pyx_t_6};
__pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2528, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
} else
#endif
{
__pyx_t_12 = PyTuple_New(1+1); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 2528, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_12);
__Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_9); __pyx_t_9 = NULL;
__Pyx_GIVEREF(__pyx_t_6);
PyTuple_SET_ITEM(__pyx_t_12, 0+1, __pyx_t_6);
__pyx_t_6 = 0;
__pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_12, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 2528, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0;
}
}
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
/* "uvloop/loop.pyx":2527
* results = await shutdown_coro
* for result, agen in zip(results, closing_agens):
* if isinstance(result, Exception): # <<<<<<<<<<<<<<
* self.call_exception_handler({
* 'message': 'an error occurred during closing of '
*/
}
/* "uvloop/loop.pyx":2526
*
* results = await shutdown_coro
* for result, agen in zip(results, closing_agens): # <<<<<<<<<<<<<<
* if isinstance(result, Exception):
* self.call_exception_handler({
*/
}
__Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0;
CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope);
/* "uvloop/loop.pyx":2508
* self._asyncgens.add(agen)
*
* async def shutdown_asyncgens(self): # <<<<<<<<<<<<<<
* """Shutdown all active asynchronous generators."""
* self._asyncgens_shutdown_called = True
*/
/* function exit code */
PyErr_SetNone(PyExc_StopIteration);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_XDECREF(__pyx_t_7);
__Pyx_XDECREF(__pyx_t_8);
__Pyx_XDECREF(__pyx_t_9);
__Pyx_XDECREF(__pyx_t_12);
__Pyx_XDECREF(__pyx_t_13);
__Pyx_XDECREF(__pyx_t_14);
__Pyx_AddTraceback("shutdown_asyncgens", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_L0:;
__Pyx_XDECREF(__pyx_r); __pyx_r = 0;
__pyx_generator->resume_label = -1;
__Pyx_Coroutine_clear((PyObject*)__pyx_generator);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":38
* bint _coroutine_wrapper_set
*
* public slow_callback_duration # <<<<<<<<<<<<<<
*
* readonly bint _closed
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_22slow_callback_duration_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_22slow_callback_duration_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_22slow_callback_duration___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_22slow_callback_duration___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v_self->slow_callback_duration);
__pyx_r = __pyx_v_self->slow_callback_duration;
goto __pyx_L0;
/* function exit code */
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* Python wrapper */
static int __pyx_pw_6uvloop_4loop_4Loop_22slow_callback_duration_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/
static int __pyx_pw_6uvloop_4loop_4Loop_22slow_callback_duration_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) {
int __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__set__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_22slow_callback_duration_2__set__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self), ((PyObject *)__pyx_v_value));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static int __pyx_pf_6uvloop_4loop_4Loop_22slow_callback_duration_2__set__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self, PyObject *__pyx_v_value) {
int __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__set__", 0);
__Pyx_INCREF(__pyx_v_value);
__Pyx_GIVEREF(__pyx_v_value);
__Pyx_GOTREF(__pyx_v_self->slow_callback_duration);
__Pyx_DECREF(__pyx_v_self->slow_callback_duration);
__pyx_v_self->slow_callback_duration = __pyx_v_value;
/* function exit code */
__pyx_r = 0;
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* Python wrapper */
static int __pyx_pw_6uvloop_4loop_4Loop_22slow_callback_duration_5__del__(PyObject *__pyx_v_self); /*proto*/
static int __pyx_pw_6uvloop_4loop_4Loop_22slow_callback_duration_5__del__(PyObject *__pyx_v_self) {
int __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__del__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_22slow_callback_duration_4__del__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static int __pyx_pf_6uvloop_4loop_4Loop_22slow_callback_duration_4__del__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
int __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__del__", 0);
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__Pyx_GOTREF(__pyx_v_self->slow_callback_duration);
__Pyx_DECREF(__pyx_v_self->slow_callback_duration);
__pyx_v_self->slow_callback_duration = Py_None;
/* function exit code */
__pyx_r = 0;
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":40
* public slow_callback_duration
*
* readonly bint _closed # <<<<<<<<<<<<<<
* bint _debug
* bint _running
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_7_closed_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_7_closed_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_7_closed___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_7_closed___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_closed); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 40, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._closed.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":81
*
* # DEBUG fields
* readonly bint _debug_cc # True when compiled with DEBUG. # <<<<<<<<<<<<<<
* # Only for unittests.
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_9_debug_cc_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_9_debug_cc_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_9_debug_cc___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_9_debug_cc___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->_debug_cc); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 81, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._debug_cc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":84
* # Only for unittests.
*
* readonly object _debug_handles_total # <<<<<<<<<<<<<<
* readonly object _debug_handles_closed
* readonly object _debug_handles_current
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_20_debug_handles_total_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_20_debug_handles_total_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_20_debug_handles_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_20_debug_handles_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v_self->_debug_handles_total);
__pyx_r = __pyx_v_self->_debug_handles_total;
goto __pyx_L0;
/* function exit code */
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":85
*
* readonly object _debug_handles_total
* readonly object _debug_handles_closed # <<<<<<<<<<<<<<
* readonly object _debug_handles_current
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_21_debug_handles_closed_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_21_debug_handles_closed_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_21_debug_handles_closed___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_21_debug_handles_closed___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v_self->_debug_handles_closed);
__pyx_r = __pyx_v_self->_debug_handles_closed;
goto __pyx_L0;
/* function exit code */
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":86
* readonly object _debug_handles_total
* readonly object _debug_handles_closed
* readonly object _debug_handles_current # <<<<<<<<<<<<<<
*
* readonly uint64_t _debug_uv_handles_total
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_22_debug_handles_current_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_22_debug_handles_current_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_22_debug_handles_current___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_22_debug_handles_current___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__Pyx_INCREF(__pyx_v_self->_debug_handles_current);
__pyx_r = __pyx_v_self->_debug_handles_current;
goto __pyx_L0;
/* function exit code */
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":88
* readonly object _debug_handles_current
*
* readonly uint64_t _debug_uv_handles_total # <<<<<<<<<<<<<<
* readonly uint64_t _debug_uv_handles_freed
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_23_debug_uv_handles_total_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_23_debug_uv_handles_total_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_23_debug_uv_handles_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_23_debug_uv_handles_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_uv_handles_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 88, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._debug_uv_handles_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":89
*
* readonly uint64_t _debug_uv_handles_total
* readonly uint64_t _debug_uv_handles_freed # <<<<<<<<<<<<<<
*
* readonly uint64_t _debug_cb_handles_total
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_23_debug_uv_handles_freed_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_23_debug_uv_handles_freed_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_23_debug_uv_handles_freed___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_23_debug_uv_handles_freed___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_uv_handles_freed); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 89, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._debug_uv_handles_freed.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":91
* readonly uint64_t _debug_uv_handles_freed
*
* readonly uint64_t _debug_cb_handles_total # <<<<<<<<<<<<<<
* readonly uint64_t _debug_cb_handles_count
* readonly uint64_t _debug_cb_timer_handles_total
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_23_debug_cb_handles_total_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_23_debug_cb_handles_total_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_23_debug_cb_handles_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_23_debug_cb_handles_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_cb_handles_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 91, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._debug_cb_handles_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":92
*
* readonly uint64_t _debug_cb_handles_total
* readonly uint64_t _debug_cb_handles_count # <<<<<<<<<<<<<<
* readonly uint64_t _debug_cb_timer_handles_total
* readonly uint64_t _debug_cb_timer_handles_count
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_23_debug_cb_handles_count_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_23_debug_cb_handles_count_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_23_debug_cb_handles_count___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_23_debug_cb_handles_count___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_cb_handles_count); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 92, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._debug_cb_handles_count.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":93
* readonly uint64_t _debug_cb_handles_total
* readonly uint64_t _debug_cb_handles_count
* readonly uint64_t _debug_cb_timer_handles_total # <<<<<<<<<<<<<<
* readonly uint64_t _debug_cb_timer_handles_count
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_29_debug_cb_timer_handles_total_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_29_debug_cb_timer_handles_total_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_29_debug_cb_timer_handles_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_29_debug_cb_timer_handles_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_cb_timer_handles_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 93, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._debug_cb_timer_handles_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":94
* readonly uint64_t _debug_cb_handles_count
* readonly uint64_t _debug_cb_timer_handles_total
* readonly uint64_t _debug_cb_timer_handles_count # <<<<<<<<<<<<<<
*
* readonly uint64_t _debug_stream_shutdown_errors_total
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_29_debug_cb_timer_handles_count_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_29_debug_cb_timer_handles_count_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_29_debug_cb_timer_handles_count___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_29_debug_cb_timer_handles_count___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_cb_timer_handles_count); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 94, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._debug_cb_timer_handles_count.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":96
* readonly uint64_t _debug_cb_timer_handles_count
*
* readonly uint64_t _debug_stream_shutdown_errors_total # <<<<<<<<<<<<<<
* readonly uint64_t _debug_stream_listen_errors_total
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_35_debug_stream_shutdown_errors_total_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_35_debug_stream_shutdown_errors_total_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_35_debug_stream_shutdown_errors_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_35_debug_stream_shutdown_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_shutdown_errors_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 96, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._debug_stream_shutdown_errors_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":97
*
* readonly uint64_t _debug_stream_shutdown_errors_total
* readonly uint64_t _debug_stream_listen_errors_total # <<<<<<<<<<<<<<
*
* readonly uint64_t _debug_stream_read_cb_total
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_33_debug_stream_listen_errors_total_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_33_debug_stream_listen_errors_total_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_33_debug_stream_listen_errors_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_33_debug_stream_listen_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_listen_errors_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 97, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._debug_stream_listen_errors_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":99
* readonly uint64_t _debug_stream_listen_errors_total
*
* readonly uint64_t _debug_stream_read_cb_total # <<<<<<<<<<<<<<
* readonly uint64_t _debug_stream_read_cb_errors_total
* readonly uint64_t _debug_stream_read_eof_total
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_27_debug_stream_read_cb_total_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_27_debug_stream_read_cb_total_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_27_debug_stream_read_cb_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_27_debug_stream_read_cb_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_read_cb_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 99, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._debug_stream_read_cb_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":100
*
* readonly uint64_t _debug_stream_read_cb_total
* readonly uint64_t _debug_stream_read_cb_errors_total # <<<<<<<<<<<<<<
* readonly uint64_t _debug_stream_read_eof_total
* readonly uint64_t _debug_stream_read_eof_cb_errors_total
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_34_debug_stream_read_cb_errors_total_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_34_debug_stream_read_cb_errors_total_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_34_debug_stream_read_cb_errors_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_34_debug_stream_read_cb_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_read_cb_errors_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 100, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._debug_stream_read_cb_errors_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":101
* readonly uint64_t _debug_stream_read_cb_total
* readonly uint64_t _debug_stream_read_cb_errors_total
* readonly uint64_t _debug_stream_read_eof_total # <<<<<<<<<<<<<<
* readonly uint64_t _debug_stream_read_eof_cb_errors_total
* readonly uint64_t _debug_stream_read_errors_total
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_28_debug_stream_read_eof_total_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_28_debug_stream_read_eof_total_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_28_debug_stream_read_eof_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_28_debug_stream_read_eof_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_read_eof_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 101, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._debug_stream_read_eof_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":102
* readonly uint64_t _debug_stream_read_cb_errors_total
* readonly uint64_t _debug_stream_read_eof_total
* readonly uint64_t _debug_stream_read_eof_cb_errors_total # <<<<<<<<<<<<<<
* readonly uint64_t _debug_stream_read_errors_total
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_38_debug_stream_read_eof_cb_errors_total_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_38_debug_stream_read_eof_cb_errors_total_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_38_debug_stream_read_eof_cb_errors_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_38_debug_stream_read_eof_cb_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_read_eof_cb_errors_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 102, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._debug_stream_read_eof_cb_errors_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":103
* readonly uint64_t _debug_stream_read_eof_total
* readonly uint64_t _debug_stream_read_eof_cb_errors_total
* readonly uint64_t _debug_stream_read_errors_total # <<<<<<<<<<<<<<
*
* readonly uint64_t _debug_stream_write_tries
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_31_debug_stream_read_errors_total_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_31_debug_stream_read_errors_total_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_31_debug_stream_read_errors_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_31_debug_stream_read_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_read_errors_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 103, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._debug_stream_read_errors_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":105
* readonly uint64_t _debug_stream_read_errors_total
*
* readonly uint64_t _debug_stream_write_tries # <<<<<<<<<<<<<<
* readonly uint64_t _debug_stream_write_errors_total
* readonly uint64_t _debug_stream_write_ctx_total
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_25_debug_stream_write_tries_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_25_debug_stream_write_tries_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_25_debug_stream_write_tries___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_25_debug_stream_write_tries___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_write_tries); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 105, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._debug_stream_write_tries.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":106
*
* readonly uint64_t _debug_stream_write_tries
* readonly uint64_t _debug_stream_write_errors_total # <<<<<<<<<<<<<<
* readonly uint64_t _debug_stream_write_ctx_total
* readonly uint64_t _debug_stream_write_ctx_cnt
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_32_debug_stream_write_errors_total_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_32_debug_stream_write_errors_total_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_32_debug_stream_write_errors_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_32_debug_stream_write_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_write_errors_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 106, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._debug_stream_write_errors_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":107
* readonly uint64_t _debug_stream_write_tries
* readonly uint64_t _debug_stream_write_errors_total
* readonly uint64_t _debug_stream_write_ctx_total # <<<<<<<<<<<<<<
* readonly uint64_t _debug_stream_write_ctx_cnt
* readonly uint64_t _debug_stream_write_cb_errors_total
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_29_debug_stream_write_ctx_total_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_29_debug_stream_write_ctx_total_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_29_debug_stream_write_ctx_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_29_debug_stream_write_ctx_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_write_ctx_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 107, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._debug_stream_write_ctx_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":108
* readonly uint64_t _debug_stream_write_errors_total
* readonly uint64_t _debug_stream_write_ctx_total
* readonly uint64_t _debug_stream_write_ctx_cnt # <<<<<<<<<<<<<<
* readonly uint64_t _debug_stream_write_cb_errors_total
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_27_debug_stream_write_ctx_cnt_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_27_debug_stream_write_ctx_cnt_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_27_debug_stream_write_ctx_cnt___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_27_debug_stream_write_ctx_cnt___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_write_ctx_cnt); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 108, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._debug_stream_write_ctx_cnt.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":109
* readonly uint64_t _debug_stream_write_ctx_total
* readonly uint64_t _debug_stream_write_ctx_cnt
* readonly uint64_t _debug_stream_write_cb_errors_total # <<<<<<<<<<<<<<
*
* readonly uint64_t _poll_read_events_total
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_35_debug_stream_write_cb_errors_total_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_35_debug_stream_write_cb_errors_total_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_35_debug_stream_write_cb_errors_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_35_debug_stream_write_cb_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_stream_write_cb_errors_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 109, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._debug_stream_write_cb_errors_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":111
* readonly uint64_t _debug_stream_write_cb_errors_total
*
* readonly uint64_t _poll_read_events_total # <<<<<<<<<<<<<<
* readonly uint64_t _poll_read_cb_errors_total
* readonly uint64_t _poll_write_events_total
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_23_poll_read_events_total_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_23_poll_read_events_total_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_23_poll_read_events_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_23_poll_read_events_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_poll_read_events_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 111, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._poll_read_events_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":112
*
* readonly uint64_t _poll_read_events_total
* readonly uint64_t _poll_read_cb_errors_total # <<<<<<<<<<<<<<
* readonly uint64_t _poll_write_events_total
* readonly uint64_t _poll_write_cb_errors_total
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_26_poll_read_cb_errors_total_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_26_poll_read_cb_errors_total_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_26_poll_read_cb_errors_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_26_poll_read_cb_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_poll_read_cb_errors_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 112, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._poll_read_cb_errors_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":113
* readonly uint64_t _poll_read_events_total
* readonly uint64_t _poll_read_cb_errors_total
* readonly uint64_t _poll_write_events_total # <<<<<<<<<<<<<<
* readonly uint64_t _poll_write_cb_errors_total
*
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_24_poll_write_events_total_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_24_poll_write_events_total_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_24_poll_write_events_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_24_poll_write_events_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_poll_write_events_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 113, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._poll_write_events_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":114
* readonly uint64_t _poll_read_cb_errors_total
* readonly uint64_t _poll_write_events_total
* readonly uint64_t _poll_write_cb_errors_total # <<<<<<<<<<<<<<
*
* readonly uint64_t _sock_try_write_total
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_27_poll_write_cb_errors_total_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_27_poll_write_cb_errors_total_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_27_poll_write_cb_errors_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_27_poll_write_cb_errors_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_poll_write_cb_errors_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 114, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._poll_write_cb_errors_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":116
* readonly uint64_t _poll_write_cb_errors_total
*
* readonly uint64_t _sock_try_write_total # <<<<<<<<<<<<<<
*
* readonly uint64_t _debug_exception_handler_cnt
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_21_sock_try_write_total_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_21_sock_try_write_total_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_21_sock_try_write_total___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_21_sock_try_write_total___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_sock_try_write_total); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 116, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._sock_try_write_total.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pxd":118
* readonly uint64_t _sock_try_write_total
*
* readonly uint64_t _debug_exception_handler_cnt # <<<<<<<<<<<<<<
*
* cdef _init_debug_fields(self)
*/
/* Python wrapper */
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_28_debug_exception_handler_cnt_1__get__(PyObject *__pyx_v_self); /*proto*/
static PyObject *__pyx_pw_6uvloop_4loop_4Loop_28_debug_exception_handler_cnt_1__get__(PyObject *__pyx_v_self) {
PyObject *__pyx_r = 0;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__get__ (wrapper)", 0);
__pyx_r = __pyx_pf_6uvloop_4loop_4Loop_28_debug_exception_handler_cnt___get__(((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static PyObject *__pyx_pf_6uvloop_4loop_4Loop_28_debug_exception_handler_cnt___get__(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_self) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
__Pyx_RefNannySetupContext("__get__", 0);
__Pyx_XDECREF(__pyx_r);
__pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->_debug_exception_handler_cnt); if (unlikely(!__pyx_t_1)) __PYX_ERR(7, 118, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_r = __pyx_t_1;
__pyx_t_1 = 0;
goto __pyx_L0;
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_AddTraceback("uvloop.loop.Loop._debug_exception_handler_cnt.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = NULL;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/loop.pyx":2536
*
*
* cdef void __loop_alloc_buffer(uv.uv_handle_t* uvhandle, # <<<<<<<<<<<<<<
* size_t suggested_size,
* uv.uv_buf_t* buf) with gil:
*/
static void __pyx_f_6uvloop_4loop___loop_alloc_buffer(uv_handle_t *__pyx_v_uvhandle, CYTHON_UNUSED size_t __pyx_v_suggested_size, uv_buf_t *__pyx_v_buf) {
struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop = 0;
PyObject *__pyx_v_exc = NULL;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
int __pyx_t_2;
char *__pyx_t_3;
#ifdef WITH_THREAD
PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
#endif
__Pyx_RefNannySetupContext("__loop_alloc_buffer", 0);
/* "uvloop/loop.pyx":2540
* uv.uv_buf_t* buf) with gil:
* cdef:
* Loop loop = (uvhandle.data)._loop # <<<<<<<<<<<<<<
*
* if loop._recv_buffer_in_use == 1:
*/
__pyx_t_1 = ((PyObject *)((struct __pyx_obj_6uvloop_4loop_UVHandle *)__pyx_v_uvhandle->data)->_loop);
__Pyx_INCREF(__pyx_t_1);
__pyx_v_loop = ((struct __pyx_obj_6uvloop_4loop_Loop *)__pyx_t_1);
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":2542
* Loop loop = (uvhandle.data)._loop
*
* if loop._recv_buffer_in_use == 1: # <<<<<<<<<<<<<<
* buf.len = 0
* exc = RuntimeError('concurrent allocations')
*/
__pyx_t_2 = ((__pyx_v_loop->_recv_buffer_in_use == 1) != 0);
if (__pyx_t_2) {
/* "uvloop/loop.pyx":2543
*
* if loop._recv_buffer_in_use == 1:
* buf.len = 0 # <<<<<<<<<<<<<<
* exc = RuntimeError('concurrent allocations')
* loop._handle_exception(exc)
*/
__pyx_v_buf->len = 0;
/* "uvloop/loop.pyx":2544
* if loop._recv_buffer_in_use == 1:
* buf.len = 0
* exc = RuntimeError('concurrent allocations') # <<<<<<<<<<<<<<
* loop._handle_exception(exc)
* return
*/
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__105, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 2544, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__pyx_v_exc = __pyx_t_1;
__pyx_t_1 = 0;
/* "uvloop/loop.pyx":2545
* buf.len = 0
* exc = RuntimeError('concurrent allocations')
* loop._handle_exception(exc) # <<<<<<<<<<<<<<
* return
*
*/
((struct __pyx_vtabstruct_6uvloop_4loop_Loop *)__pyx_v_loop->__pyx_vtab)->_handle_exception(__pyx_v_loop, __pyx_v_exc);
/* "uvloop/loop.pyx":2546
* exc = RuntimeError('concurrent allocations')
* loop._handle_exception(exc)
* return # <<<<<<<<<<<<<<
*
* loop._recv_buffer_in_use = 1
*/
goto __pyx_L0;
/* "uvloop/loop.pyx":2542
* Loop loop = (uvhandle.data)._loop
*
* if loop._recv_buffer_in_use == 1: # <<<<<<<<<<<<<<
* buf.len = 0
* exc = RuntimeError('concurrent allocations')
*/
}
/* "uvloop/loop.pyx":2548
* return
*
* loop._recv_buffer_in_use = 1 # <<<<<<<<<<<<<<
* buf.base = loop._recv_buffer
* buf.len = sizeof(loop._recv_buffer)
*/
__pyx_v_loop->_recv_buffer_in_use = 1;
/* "uvloop/loop.pyx":2549
*
* loop._recv_buffer_in_use = 1
* buf.base = loop._recv_buffer # <<<<<<<<<<<<<<
* buf.len = sizeof(loop._recv_buffer)
*
*/
__pyx_t_3 = __pyx_v_loop->_recv_buffer;
__pyx_v_buf->base = __pyx_t_3;
/* "uvloop/loop.pyx":2550
* loop._recv_buffer_in_use = 1
* buf.base = loop._recv_buffer
* buf.len = sizeof(loop._recv_buffer) # <<<<<<<<<<<<<<
*
*
*/
__pyx_v_buf->len = (sizeof(__pyx_v_loop->_recv_buffer));
/* "uvloop/loop.pyx":2536
*
*
* cdef void __loop_alloc_buffer(uv.uv_handle_t* uvhandle, # <<<<<<<<<<<<<<
* size_t suggested_size,
* uv.uv_buf_t* buf) with gil:
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_WriteUnraisable("uvloop.loop.__loop_alloc_buffer", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
__pyx_L0:;
__Pyx_XDECREF((PyObject *)__pyx_v_loop);
__Pyx_XDECREF(__pyx_v_exc);
__Pyx_RefNannyFinishContext();
#ifdef WITH_THREAD
PyGILState_Release(__pyx_gilstate_save);
#endif
}
/* "uvloop/loop.pyx":2553
*
*
* cdef inline void __loop_free_buffer(Loop loop): # <<<<<<<<<<<<<<
* loop._recv_buffer_in_use = 0
*
*/
static CYTHON_INLINE void __pyx_f_6uvloop_4loop___loop_free_buffer(struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop) {
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__loop_free_buffer", 0);
/* "uvloop/loop.pyx":2554
*
* cdef inline void __loop_free_buffer(Loop loop):
* loop._recv_buffer_in_use = 0 # <<<<<<<<<<<<<<
*
*
*/
__pyx_v_loop->_recv_buffer_in_use = 0;
/* "uvloop/loop.pyx":2553
*
*
* cdef inline void __loop_free_buffer(Loop loop): # <<<<<<<<<<<<<<
* loop._recv_buffer_in_use = 0
*
*/
/* function exit code */
__Pyx_RefNannyFinishContext();
}
/* "uvloop/cbhandles.pyx":4
* @cython.freelist(DEFAULT_FREELIST_SIZE)
* cdef class Handle:
* def __cinit__(self): # <<<<<<<<<<<<<<
* self.cancelled = 0
* self.cb_type = 0
*/
/* Python wrapper */
static int __pyx_pw_6uvloop_4loop_6Handle_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_6uvloop_4loop_6Handle_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
int __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0);
if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
__Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1;
__pyx_r = __pyx_pf_6uvloop_4loop_6Handle___cinit__(((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static int __pyx_pf_6uvloop_4loop_6Handle___cinit__(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self) {
int __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__cinit__", 0);
/* "uvloop/cbhandles.pyx":5
* cdef class Handle:
* def __cinit__(self):
* self.cancelled = 0 # <<<<<<<<<<<<<<
* self.cb_type = 0
* self._source_traceback = None
*/
__pyx_v_self->cancelled = 0;
/* "uvloop/cbhandles.pyx":6
* def __cinit__(self):
* self.cancelled = 0
* self.cb_type = 0 # <<<<<<<<<<<<<<
* self._source_traceback = None
*
*/
__pyx_v_self->cb_type = 0;
/* "uvloop/cbhandles.pyx":7
* self.cancelled = 0
* self.cb_type = 0
* self._source_traceback = None # <<<<<<<<<<<<<<
*
* cdef inline _set_loop(self, Loop loop):
*/
__Pyx_INCREF(Py_None);
__Pyx_GIVEREF(Py_None);
__Pyx_GOTREF(__pyx_v_self->_source_traceback);
__Pyx_DECREF(__pyx_v_self->_source_traceback);
__pyx_v_self->_source_traceback = Py_None;
/* "uvloop/cbhandles.pyx":4
* @cython.freelist(DEFAULT_FREELIST_SIZE)
* cdef class Handle:
* def __cinit__(self): # <<<<<<<<<<<<<<
* self.cancelled = 0
* self.cb_type = 0
*/
/* function exit code */
__pyx_r = 0;
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/cbhandles.pyx":9
* self._source_traceback = None
*
* cdef inline _set_loop(self, Loop loop): # <<<<<<<<<<<<<<
* self.loop = loop
* if UVLOOP_DEBUG:
*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6Handle__set_loop(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self, struct __pyx_obj_6uvloop_4loop_Loop *__pyx_v_loop) {
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
__Pyx_RefNannySetupContext("_set_loop", 0);
/* "uvloop/cbhandles.pyx":10
*
* cdef inline _set_loop(self, Loop loop):
* self.loop = loop # <<<<<<<<<<<<<<
* if UVLOOP_DEBUG:
* loop._debug_cb_handles_total += 1
*/
__Pyx_INCREF(((PyObject *)__pyx_v_loop));
__Pyx_GIVEREF(((PyObject *)__pyx_v_loop));
__Pyx_GOTREF(__pyx_v_self->loop);
__Pyx_DECREF(((PyObject *)__pyx_v_self->loop));
__pyx_v_self->loop = __pyx_v_loop;
/* "uvloop/cbhandles.pyx":11
* cdef inline _set_loop(self, Loop loop):
* self.loop = loop
* if UVLOOP_DEBUG: # <<<<<<<<<<<<<<
* loop._debug_cb_handles_total += 1
* loop._debug_cb_handles_count += 1
*/
__pyx_t_1 = (UVLOOP_DEBUG != 0);
if (__pyx_t_1) {
/* "uvloop/cbhandles.pyx":12
* self.loop = loop
* if UVLOOP_DEBUG:
* loop._debug_cb_handles_total += 1 # <<<<<<<<<<<<<<
* loop._debug_cb_handles_count += 1
* if loop._debug:
*/
__pyx_v_loop->_debug_cb_handles_total = (__pyx_v_loop->_debug_cb_handles_total + 1);
/* "uvloop/cbhandles.pyx":13
* if UVLOOP_DEBUG:
* loop._debug_cb_handles_total += 1
* loop._debug_cb_handles_count += 1 # <<<<<<<<<<<<<<
* if loop._debug:
* self._source_traceback = tb_extract_stack(sys_getframe(0))
*/
__pyx_v_loop->_debug_cb_handles_count = (__pyx_v_loop->_debug_cb_handles_count + 1);
/* "uvloop/cbhandles.pyx":11
* cdef inline _set_loop(self, Loop loop):
* self.loop = loop
* if UVLOOP_DEBUG: # <<<<<<<<<<<<<<
* loop._debug_cb_handles_total += 1
* loop._debug_cb_handles_count += 1
*/
}
/* "uvloop/cbhandles.pyx":14
* loop._debug_cb_handles_total += 1
* loop._debug_cb_handles_count += 1
* if loop._debug: # <<<<<<<<<<<<<<
* self._source_traceback = tb_extract_stack(sys_getframe(0))
*
*/
__pyx_t_1 = (__pyx_v_loop->_debug != 0);
if (__pyx_t_1) {
/* "uvloop/cbhandles.pyx":15
* loop._debug_cb_handles_count += 1
* if loop._debug:
* self._source_traceback = tb_extract_stack(sys_getframe(0)) # <<<<<<<<<<<<<<
*
* def __dealloc__(self):
*/
__pyx_t_3 = __Pyx_PyObject_Call(__pyx_v_6uvloop_4loop_sys_getframe, __pyx_tuple__106, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 15, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__Pyx_INCREF(__pyx_v_6uvloop_4loop_tb_extract_stack);
__pyx_t_4 = __pyx_v_6uvloop_4loop_tb_extract_stack; __pyx_t_5 = NULL;
if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) {
__pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4);
if (likely(__pyx_t_5)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4);
__Pyx_INCREF(__pyx_t_5);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_4, function);
}
}
if (!__pyx_t_5) {
__pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 15, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_2);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
__pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 15, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) {
PyObject *__pyx_temp[2] = {__pyx_t_5, __pyx_t_3};
__pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 15, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0;
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
} else
#endif
{
__pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) __PYX_ERR(8, 15, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL;
__Pyx_GIVEREF(__pyx_t_3);
PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3);
__pyx_t_3 = 0;
__pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 15, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
}
}
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GIVEREF(__pyx_t_2);
__Pyx_GOTREF(__pyx_v_self->_source_traceback);
__Pyx_DECREF(__pyx_v_self->_source_traceback);
__pyx_v_self->_source_traceback = __pyx_t_2;
__pyx_t_2 = 0;
/* "uvloop/cbhandles.pyx":14
* loop._debug_cb_handles_total += 1
* loop._debug_cb_handles_count += 1
* if loop._debug: # <<<<<<<<<<<<<<
* self._source_traceback = tb_extract_stack(sys_getframe(0))
*
*/
}
/* "uvloop/cbhandles.pyx":9
* self._source_traceback = None
*
* cdef inline _set_loop(self, Loop loop): # <<<<<<<<<<<<<<
* self.loop = loop
* if UVLOOP_DEBUG:
*/
/* function exit code */
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_XDECREF(__pyx_t_6);
__Pyx_AddTraceback("uvloop.loop.Handle._set_loop", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = 0;
__pyx_L0:;
__Pyx_XGIVEREF(__pyx_r);
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/cbhandles.pyx":17
* self._source_traceback = tb_extract_stack(sys_getframe(0))
*
* def __dealloc__(self): # <<<<<<<<<<<<<<
* if UVLOOP_DEBUG and self.loop is not None:
* self.loop._debug_cb_handles_count -= 1
*/
/* Python wrapper */
static void __pyx_pw_6uvloop_4loop_6Handle_3__dealloc__(PyObject *__pyx_v_self); /*proto*/
static void __pyx_pw_6uvloop_4loop_6Handle_3__dealloc__(PyObject *__pyx_v_self) {
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0);
__pyx_pf_6uvloop_4loop_6Handle_2__dealloc__(((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
}
static void __pyx_pf_6uvloop_4loop_6Handle_2__dealloc__(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self) {
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
int __pyx_t_3;
struct __pyx_obj_6uvloop_4loop_Loop *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
__Pyx_RefNannySetupContext("__dealloc__", 0);
/* "uvloop/cbhandles.pyx":18
*
* def __dealloc__(self):
* if UVLOOP_DEBUG and self.loop is not None: # <<<<<<<<<<<<<<
* self.loop._debug_cb_handles_count -= 1
* if self.loop is None:
*/
__pyx_t_2 = (UVLOOP_DEBUG != 0);
if (__pyx_t_2) {
} else {
__pyx_t_1 = __pyx_t_2;
goto __pyx_L4_bool_binop_done;
}
__pyx_t_2 = (((PyObject *)__pyx_v_self->loop) != Py_None);
__pyx_t_3 = (__pyx_t_2 != 0);
__pyx_t_1 = __pyx_t_3;
__pyx_L4_bool_binop_done:;
if (__pyx_t_1) {
/* "uvloop/cbhandles.pyx":19
* def __dealloc__(self):
* if UVLOOP_DEBUG and self.loop is not None:
* self.loop._debug_cb_handles_count -= 1 # <<<<<<<<<<<<<<
* if self.loop is None:
* raise RuntimeError('Handle.loop is None in Handle.__dealloc__')
*/
__Pyx_INCREF(((PyObject *)__pyx_v_self->loop));
__pyx_t_4 = __pyx_v_self->loop;
__pyx_t_4->_debug_cb_handles_count = (__pyx_t_4->_debug_cb_handles_count - 1);
__Pyx_DECREF(((PyObject *)__pyx_t_4)); __pyx_t_4 = 0;
/* "uvloop/cbhandles.pyx":18
*
* def __dealloc__(self):
* if UVLOOP_DEBUG and self.loop is not None: # <<<<<<<<<<<<<<
* self.loop._debug_cb_handles_count -= 1
* if self.loop is None:
*/
}
/* "uvloop/cbhandles.pyx":20
* if UVLOOP_DEBUG and self.loop is not None:
* self.loop._debug_cb_handles_count -= 1
* if self.loop is None: # <<<<<<<<<<<<<<
* raise RuntimeError('Handle.loop is None in Handle.__dealloc__')
*
*/
__pyx_t_1 = (((PyObject *)__pyx_v_self->loop) == Py_None);
__pyx_t_3 = (__pyx_t_1 != 0);
if (__pyx_t_3) {
/* "uvloop/cbhandles.pyx":21
* self.loop._debug_cb_handles_count -= 1
* if self.loop is None:
* raise RuntimeError('Handle.loop is None in Handle.__dealloc__') # <<<<<<<<<<<<<<
*
* def __init__(self):
*/
__pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__107, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(8, 21, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_Raise(__pyx_t_5, 0, 0, 0);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
__PYX_ERR(8, 21, __pyx_L1_error)
/* "uvloop/cbhandles.pyx":20
* if UVLOOP_DEBUG and self.loop is not None:
* self.loop._debug_cb_handles_count -= 1
* if self.loop is None: # <<<<<<<<<<<<<<
* raise RuntimeError('Handle.loop is None in Handle.__dealloc__')
*
*/
}
/* "uvloop/cbhandles.pyx":17
* self._source_traceback = tb_extract_stack(sys_getframe(0))
*
* def __dealloc__(self): # <<<<<<<<<<<<<<
* if UVLOOP_DEBUG and self.loop is not None:
* self.loop._debug_cb_handles_count -= 1
*/
/* function exit code */
goto __pyx_L0;
__pyx_L1_error:;
__Pyx_XDECREF(((PyObject *)__pyx_t_4));
__Pyx_XDECREF(__pyx_t_5);
__Pyx_WriteUnraisable("uvloop.loop.Handle.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0);
__pyx_L0:;
__Pyx_RefNannyFinishContext();
}
/* "uvloop/cbhandles.pyx":23
* raise RuntimeError('Handle.loop is None in Handle.__dealloc__')
*
* def __init__(self): # <<<<<<<<<<<<<<
* raise TypeError(
* '{} is not supposed to be instantiated from Python'.format(
*/
/* Python wrapper */
static int __pyx_pw_6uvloop_4loop_6Handle_5__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static int __pyx_pw_6uvloop_4loop_6Handle_5__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
int __pyx_r;
__Pyx_RefNannyDeclarations
__Pyx_RefNannySetupContext("__init__ (wrapper)", 0);
if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) {
__Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;}
if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1;
__pyx_r = __pyx_pf_6uvloop_4loop_6Handle_4__init__(((struct __pyx_obj_6uvloop_4loop_Handle *)__pyx_v_self));
/* function exit code */
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
static int __pyx_pf_6uvloop_4loop_6Handle_4__init__(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self) {
int __pyx_r;
__Pyx_RefNannyDeclarations
PyObject *__pyx_t_1 = NULL;
PyObject *__pyx_t_2 = NULL;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
__Pyx_RefNannySetupContext("__init__", 0);
/* "uvloop/cbhandles.pyx":25
* def __init__(self):
* raise TypeError(
* '{} is not supposed to be instantiated from Python'.format( # <<<<<<<<<<<<<<
* self.__class__.__name__))
*
*/
__pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_kp_u_is_not_supposed_to_be_instantia, __pyx_n_s_format); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 25, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
/* "uvloop/cbhandles.pyx":26
* raise TypeError(
* '{} is not supposed to be instantiated from Python'.format(
* self.__class__.__name__)) # <<<<<<<<<<<<<<
*
* cdef inline _run(self):
*/
__pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_class); if (unlikely(!__pyx_t_3)) __PYX_ERR(8, 26, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_3);
__pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(8, 26, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_4);
__Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;
__pyx_t_3 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) {
__pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2);
if (likely(__pyx_t_3)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2);
__Pyx_INCREF(__pyx_t_3);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_2, function);
}
}
if (!__pyx_t_3) {
__pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 25, __pyx_L1_error)
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
__Pyx_GOTREF(__pyx_t_1);
} else {
#if CYTHON_FAST_PYCALL
if (PyFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4};
__pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 25, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
#if CYTHON_FAST_PYCCALL
if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) {
PyObject *__pyx_temp[2] = {__pyx_t_3, __pyx_t_4};
__pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-1, 1+1); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 25, __pyx_L1_error)
__Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0;
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0;
} else
#endif
{
__pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) __PYX_ERR(8, 25, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_5);
__Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __pyx_t_3 = NULL;
__Pyx_GIVEREF(__pyx_t_4);
PyTuple_SET_ITEM(__pyx_t_5, 0+1, __pyx_t_4);
__pyx_t_4 = 0;
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 25, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0;
}
}
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
/* "uvloop/cbhandles.pyx":24
*
* def __init__(self):
* raise TypeError( # <<<<<<<<<<<<<<
* '{} is not supposed to be instantiated from Python'.format(
* self.__class__.__name__))
*/
__pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(8, 24, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_2);
__Pyx_GIVEREF(__pyx_t_1);
PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1);
__pyx_t_1 = 0;
__pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(8, 24, __pyx_L1_error)
__Pyx_GOTREF(__pyx_t_1);
__Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
__Pyx_Raise(__pyx_t_1, 0, 0, 0);
__Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
__PYX_ERR(8, 24, __pyx_L1_error)
/* "uvloop/cbhandles.pyx":23
* raise RuntimeError('Handle.loop is None in Handle.__dealloc__')
*
* def __init__(self): # <<<<<<<<<<<<<<
* raise TypeError(
* '{} is not supposed to be instantiated from Python'.format(
*/
/* function exit code */
__pyx_L1_error:;
__Pyx_XDECREF(__pyx_t_1);
__Pyx_XDECREF(__pyx_t_2);
__Pyx_XDECREF(__pyx_t_3);
__Pyx_XDECREF(__pyx_t_4);
__Pyx_XDECREF(__pyx_t_5);
__Pyx_AddTraceback("uvloop.loop.Handle.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename);
__pyx_r = -1;
__Pyx_RefNannyFinishContext();
return __pyx_r;
}
/* "uvloop/cbhandles.pyx":28
* self.__class__.__name__))
*
* cdef inline _run(self): # <<<<<<<<<<<<<<
* cdef:
* int cb_type
*/
static CYTHON_INLINE PyObject *__pyx_f_6uvloop_4loop_6Handle__run(struct __pyx_obj_6uvloop_4loop_Handle *__pyx_v_self) {
int __pyx_v_cb_type;
PyObject *__pyx_v_callback = 0;
PyObject *__pyx_v_args = NULL;
PyObject *__pyx_v_ex = NULL;
PyObject *__pyx_v_msg = NULL;
PyObject *__pyx_v_context = NULL;
PyObject *__pyx_r = NULL;
__Pyx_RefNannyDeclarations
int __pyx_t_1;
int __pyx_t_2;
PyObject *__pyx_t_3 = NULL;
PyObject *__pyx_t_4 = NULL;
PyObject *__pyx_t_5 = NULL;
PyObject *__pyx_t_6 = NULL;
int __pyx_t_7;
PyObject *__pyx_t_8 = NULL;
PyObject *__pyx_t_9 = NULL;
PyObject *__pyx_t_10 = NULL;
PyObject *__pyx_t_11 = NULL;
PyObject *__pyx_t_12 = NULL;
PyObject *__pyx_t_13 = NULL;
int __pyx_t_14;
char const *__pyx_t_15;
PyObject *__pyx_t_16 = NULL;
PyObject *__pyx_t_17 = NULL;
PyObject *__pyx_t_18 = NULL;
PyObject *__pyx_t_19 = NULL;
PyObject *__pyx_t_20 = NULL;
PyObject *__pyx_t_21 = NULL;
char const *__pyx_t_22;
__Pyx_RefNannySetupContext("_run", 0);
/* "uvloop/cbhandles.pyx":33
* object callback
*
* if self.cancelled: # <<<<<<<<<<<<<<
* return
*
*/
__pyx_t_1 = (__pyx_v_self->cancelled != 0);
if (__pyx_t_1) {
/* "uvloop/cbhandles.pyx":34
*
* if self.cancelled:
* return # <<<<<<<<<<<<<<
*
* cb_type = self.cb_type
*/
__Pyx_XDECREF(__pyx_r);
__pyx_r = Py_None; __Pyx_INCREF(Py_None);
goto __pyx_L0;
/* "uvloop/cbhandles.pyx":33
* object callback
*
* if self.cancelled: # <<<<<<<<<<<<<<
* return
*
*/
}
/* "uvloop/cbhandles.pyx":36
* return
*
* cb_type = self.cb_type # <<<<<<<<<<<<<<
*
* Py_INCREF(self) # Since _run is a cdef and there's no BoundMethod,
*/
__pyx_t_2 = __pyx_v_self->cb_type;
__pyx_v_cb_type = __pyx_t_2;
/* "uvloop/cbhandles.pyx":38
* cb_type = self.cb_type
*
* Py_INCREF(self) # Since _run is a cdef and there's no BoundMethod, # <<<<<<<<<<<<<<
* # we guard 'self' manually (since the callback
* # might cause GC of the handle.)
*/
Py_INCREF(((PyObject *)__pyx_v_self));
/* "uvloop/cbhandles.pyx":41
* # we guard 'self' manually (since the callback
* # might cause GC of the handle.)
* try: # <<<<<<<<<<<<<<
* if cb_type == 1:
* callback = self.arg1
*/
/*try:*/ {
{
__Pyx_PyThreadState_declare
__Pyx_PyThreadState_assign
__Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5);
__Pyx_XGOTREF(__pyx_t_3);
__Pyx_XGOTREF(__pyx_t_4);
__Pyx_XGOTREF(__pyx_t_5);
/*try:*/ {
/* "uvloop/cbhandles.pyx":42
* # might cause GC of the handle.)
* try:
* if cb_type == 1: # <<<<<<<<<<<<<<
* callback = self.arg1
* args = self.arg2
*/
switch (__pyx_v_cb_type) {
case 1:
/* "uvloop/cbhandles.pyx":43
* try:
* if cb_type == 1:
* callback = self.arg1 # <<<<<<<<<<<<<<
* args = self.arg2
*
*/
__pyx_t_6 = __pyx_v_self->arg1;
__Pyx_INCREF(__pyx_t_6);
__pyx_v_callback = __pyx_t_6;
__pyx_t_6 = 0;
/* "uvloop/cbhandles.pyx":44
* if cb_type == 1:
* callback = self.arg1
* args = self.arg2 # <<<<<<<<<<<<<<
*
* if args is None:
*/
__pyx_t_6 = __pyx_v_self->arg2;
__Pyx_INCREF(__pyx_t_6);
__pyx_v_args = __pyx_t_6;
__pyx_t_6 = 0;
/* "uvloop/cbhandles.pyx":46
* args = self.arg2
*
* if args is None: # <<<<<<<<<<<<<<
* callback()
* else:
*/
__pyx_t_1 = (__pyx_v_args == Py_None);
__pyx_t_7 = (__pyx_t_1 != 0);
if (__pyx_t_7) {
/* "uvloop/cbhandles.pyx":47
*
* if args is None:
* callback() # <<<<<<<<<<<<<<
* else:
* callback(*args)
*/
__Pyx_INCREF(__pyx_v_callback);
__pyx_t_8 = __pyx_v_callback; __pyx_t_9 = NULL;
if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) {
__pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8);
if (likely(__pyx_t_9)) {
PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8);
__Pyx_INCREF(__pyx_t_9);
__Pyx_INCREF(function);
__Pyx_DECREF_SET(__pyx_t_8, function);
}
}
if (__pyx_t_9) {
__pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(8, 47, __pyx_L7_error)
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
} else {
__pyx_t_6 = __Pyx_PyObject_CallNoArg(__pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(8, 47, __pyx_L7_error)
}
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "uvloop/cbhandles.pyx":46
* args = self.arg2
*
* if args is None: # <<<<<<<<<<<<<<
* callback()
* else:
*/
goto __pyx_L15;
}
/* "uvloop/cbhandles.pyx":49
* callback()
* else:
* callback(*args) # <<<<<<<<<<<<<<
*
* elif cb_type == 2:
*/
/*else*/ {
__pyx_t_6 = PySequence_Tuple(__pyx_v_args); if (unlikely(!__pyx_t_6)) __PYX_ERR(8, 49, __pyx_L7_error)
__Pyx_GOTREF(__pyx_t_6);
__pyx_t_8 = __Pyx_PyObject_Call(__pyx_v_callback, __pyx_t_6, NULL); if (unlikely(!__pyx_t_8)) __PYX_ERR(8, 49, __pyx_L7_error)
__Pyx_GOTREF(__pyx_t_8);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
}
__pyx_L15:;
/* "uvloop/cbhandles.pyx":42
* # might cause GC of the handle.)
* try:
* if cb_type == 1: # <<<<<<<<<<<<<<
* callback = self.arg1
* args = self.arg2
*/
break;
/* "uvloop/cbhandles.pyx":51
* callback(*args)
*
* elif cb_type == 2: # <<<<<<<<<<<<<<
* (self.callback)(self.arg1)
*
*/
case 2:
/* "uvloop/cbhandles.pyx":52
*
* elif cb_type == 2:
* (self.callback)(self.arg1) # <<<<<<<<<<<<<<
*
* elif cb_type == 3:
*/
__pyx_t_8 = __pyx_v_self->arg1;
__Pyx_INCREF(__pyx_t_8);
__pyx_t_6 = ((__pyx_t_6uvloop_4loop_method_t)__pyx_v_self->callback)(__pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(8, 52, __pyx_L7_error)
__Pyx_GOTREF(__pyx_t_6);
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
/* "uvloop/cbhandles.pyx":51
* callback(*args)
*
* elif cb_type == 2: # <<<<<<<<<<<<<<
* (self.callback)(self.arg1)
*
*/
break;
/* "uvloop/cbhandles.pyx":54
* (self.callback)(self.arg1)
*
* elif cb_type == 3: # <<<<<<<<<<<<<<
* (self.callback)(self.arg1, self.arg2)
*
*/
case 3:
/* "uvloop/cbhandles.pyx":55
*
* elif cb_type == 3:
* (self.callback)(self.arg1, self.arg2) # <<<<<<<<<<<<<<
*
* elif cb_type == 4:
*/
__pyx_t_6 = __pyx_v_self->arg1;
__Pyx_INCREF(__pyx_t_6);
__pyx_t_8 = __pyx_v_self->arg2;
__Pyx_INCREF(__pyx_t_8);
__pyx_t_9 = ((__pyx_t_6uvloop_4loop_method1_t)__pyx_v_self->callback)(__pyx_t_6, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(8, 55, __pyx_L7_error)
__Pyx_GOTREF(__pyx_t_9);
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
/* "uvloop/cbhandles.pyx":54
* (self.callback)(self.arg1)
*
* elif cb_type == 3: # <<<<<<<<<<<<<<
* (self.callback)(self.arg1, self.arg2)
*
*/
break;
/* "uvloop/cbhandles.pyx":57
* (self.callback)(self.arg1, self.arg2)
*
* elif cb_type == 4: # <<<<<<<<<<<<<<
* (self.callback)(self.arg1, self.arg2, self.arg3)
*
*/
case 4:
/* "uvloop/cbhandles.pyx":58
*
* elif cb_type == 4:
* (self.callback)(self.arg1, self.arg2, self.arg3) # <<<<<<<<<<<<<<
*
* elif cb_type == 5:
*/
__pyx_t_9 = __pyx_v_self->arg1;
__Pyx_INCREF(__pyx_t_9);
__pyx_t_8 = __pyx_v_self->arg2;
__Pyx_INCREF(__pyx_t_8);
__pyx_t_6 = __pyx_v_self->arg3;
__Pyx_INCREF(__pyx_t_6);
__pyx_t_10 = ((__pyx_t_6uvloop_4loop_method2_t)__pyx_v_self->callback)(__pyx_t_9, __pyx_t_8, __pyx_t_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(8, 58, __pyx_L7_error)
__Pyx_GOTREF(__pyx_t_10);
__Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0;
__Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0;
__Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
__Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
/* "uvloop/cbhandles.pyx":57
* (self.callback)(self.arg1, self.arg2)
*
* elif cb_type == 4: # <<<<<<<<<<<<<<
* (